From 8bcb84eacc67832bd41d58140b11bbd027b99749 Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Sun, 2 Aug 2020 21:49:18 +0300
Subject: [PATCH 01/34] Adding typeconverter

---
 .idea/gradle.xml                              |   2 +-
 commons/build.gradle                          |   3 -
 .../src/main/java/promise/db/ColumnInfo.kt    |   8 +-
 compiler/build.gradle                         |  37 -----
 .../java/promise/db/ompiler/ClassProcessor.kt |  22 +++
 ...CodeBlockGenerator.kt => CodeGenerator.kt} |   2 +-
 ...kt => DatabaseAbstractMethodsGenerator.kt} |   5 +-
 .../DatabaseAnnotationGenerator.kt            |   9 +-
 ...kt => DatabaseCrudStubMethodsGenerator.kt} |   4 +-
 .../db/ompiler/DatabaseEntityProcessor.kt     |  89 +++++++++++
 ....kt => DatabaseMigrationFieldGenerator.kt} |   8 +-
 .../promise/db/ompiler/DatabaseProcessor.kt   | 150 ------------------
 ...r.kt => DatabaseStaticMethodsGenerator.kt} |  25 ++-
 .../promise/db/ompiler/EntityProcessor.kt     | 107 +++----------
 .../java/promise/db/ompiler/JavaUtils.java    |  84 +++++++---
 .../db/ompiler/PersistableEntityUtils.kt      |  83 +++++++++-
 .../db/ompiler/PromiseDatabaseCompiler.kt     |  98 ++++++++++++
 .../{relations => }/RelationsGenerator.kt     |   5 +-
 .../TableAnnotationGenerator.java             |   6 +-
 ...rator.kt => TableColumnFieldsGenerator.kt} | 122 ++++++++------
 ...kt => TableDeserializerMethodGenerator.kt} |   4 +-
 ... TableRegisteredColumnsMethodGenerator.kt} |   7 +-
 ...r.kt => TableSerializerMethodGenerator.kt} |   4 +-
 .../db/ompiler/TypeConverterProcessor.kt      | 119 ++++++++++++++
 .../src/main/java/promise/db/ompiler/Utils.kt |   1 +
 .../ompiler/PersistableEntityUtilsKtTest.kt   |  30 ++++
 database/build.gradle                         |   1 -
 27 files changed, 647 insertions(+), 388 deletions(-)
 create mode 100644 compiler/src/main/java/promise/db/ompiler/ClassProcessor.kt
 rename compiler/src/main/java/promise/db/ompiler/{CodeBlockGenerator.kt => CodeGenerator.kt} (94%)
 rename compiler/src/main/java/promise/db/ompiler/{DatabaseAbstractFuncsGenerator.kt => DatabaseAbstractMethodsGenerator.kt} (97%)
 rename compiler/src/main/java/promise/db/ompiler/{annotation => }/DatabaseAnnotationGenerator.kt (87%)
 rename compiler/src/main/java/promise/db/ompiler/{DatabaseCrudStubsGenerator.kt => DatabaseCrudStubMethodsGenerator.kt} (90%)
 create mode 100644 compiler/src/main/java/promise/db/ompiler/DatabaseEntityProcessor.kt
 rename compiler/src/main/java/promise/db/ompiler/{migration/MigrationGenerator.kt => DatabaseMigrationFieldGenerator.kt} (94%)
 delete mode 100644 compiler/src/main/java/promise/db/ompiler/DatabaseProcessor.kt
 rename compiler/src/main/java/promise/db/ompiler/{DatabaseCompanionPropsGenerator.kt => DatabaseStaticMethodsGenerator.kt} (94%)
 create mode 100644 compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt
 rename compiler/src/main/java/promise/db/ompiler/{relations => }/RelationsGenerator.kt (93%)
 rename compiler/src/main/java/promise/db/ompiler/{annotation => }/TableAnnotationGenerator.java (97%)
 rename compiler/src/main/java/promise/db/ompiler/{TableColumnPropsGenerator.kt => TableColumnFieldsGenerator.kt} (55%)
 rename compiler/src/main/java/promise/db/ompiler/{DeserializerGenerator.kt => TableDeserializerMethodGenerator.kt} (97%)
 rename compiler/src/main/java/promise/db/ompiler/{RegisterColumnsGenerator.kt => TableRegisteredColumnsMethodGenerator.kt} (89%)
 rename compiler/src/main/java/promise/db/ompiler/{SerializerGenerator.kt => TableSerializerMethodGenerator.kt} (96%)
 create mode 100644 compiler/src/main/java/promise/db/ompiler/TypeConverterProcessor.kt
 create mode 100644 compiler/src/test/java/promise/db/ompiler/PersistableEntityUtilsKtTest.kt

diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index ecfc06b..a018472 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -11,10 +11,10 @@
         <option name="modules">
           <set>
             <option value="$PROJECT_DIR$" />
-            <option value="$PROJECT_DIR$/androidpromisedatabase" />
             <option value="$PROJECT_DIR$/app" />
             <option value="$PROJECT_DIR$/commons" />
             <option value="$PROJECT_DIR$/compiler" />
+            <option value="$PROJECT_DIR$/database" />
           </set>
         </option>
         <option name="resolveModulePerSourceSet" value="false" />
diff --git a/commons/build.gradle b/commons/build.gradle
index ecc89a1..35e2feb 100644
--- a/commons/build.gradle
+++ b/commons/build.gradle
@@ -13,12 +13,9 @@
 
 apply plugin: 'java-library'
 apply plugin: 'kotlin'
-
 apply plugin: 'maven'
 
-
 dependencies {
-    implementation fileTree(dir: 'libs', include: ['*.jar'])
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
 }
 
diff --git a/commons/src/main/java/promise/db/ColumnInfo.kt b/commons/src/main/java/promise/db/ColumnInfo.kt
index 8d69f50..788f778 100644
--- a/commons/src/main/java/promise/db/ColumnInfo.kt
+++ b/commons/src/main/java/promise/db/ColumnInfo.kt
@@ -12,6 +12,7 @@
  */
 package promise.db
 
+import kotlin.reflect.KClass
 
 @Target(AnnotationTarget.FIELD)
 @Retention(AnnotationRetention.SOURCE)
@@ -64,8 +65,13 @@ annotation class Migrate(val fromVersion: Int,
                          val action: MigrationOptions)
 
 
-
 @Target(AnnotationTarget.FIELD)
 @Retention(AnnotationRetention.SOURCE)
 annotation class Migrations(val values: Array<Migrate>)
 
+@Target(AnnotationTarget.FIELD, AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.SOURCE)
+annotation class TypeConverter
+
+
+
diff --git a/compiler/build.gradle b/compiler/build.gradle
index df1b268..6a3f654 100644
--- a/compiler/build.gradle
+++ b/compiler/build.gradle
@@ -16,45 +16,8 @@ import org.gradle.internal.jvm.Jvm
 apply plugin: 'java-library'
 apply plugin: 'kotlin'
 apply plugin: 'kotlin-kapt'
-
-
 apply plugin: 'maven'
 
-
-
-//android {
-//    compileSdkVersion 29
-//    buildToolsVersion "29.0.2"
-//
-//    defaultConfig {
-//        minSdkVersion 21
-//        targetSdkVersion 29
-//        versionCode 1
-//        versionName "1.0"
-//
-//        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
-//        consumerProguardFiles 'consumer-rules.pro'
-//    }
-//
-//    buildTypes {
-//        release {
-//            minifyEnabled false
-//            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
-//        }
-//
-//        debug {
-//
-//        }
-//    }
-//
-//
-//    compileOptions {
-//        sourceCompatibility = '1.8'
-//        targetCompatibility = '1.8'
-//    }
-//
-//}
-
 dependencies {
     compileOnly project(path: ':commons')
     //compileOnly files(Jvm.current().getJre().homeDir.getAbsolutePath()+'/lib/rt.jar')
diff --git a/compiler/src/main/java/promise/db/ompiler/ClassProcessor.kt b/compiler/src/main/java/promise/db/ompiler/ClassProcessor.kt
new file mode 100644
index 0000000..4b02275
--- /dev/null
+++ b/compiler/src/main/java/promise/db/ompiler/ClassProcessor.kt
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db.ompiler
+
+import com.squareup.javapoet.JavaFile
+import javax.annotation.processing.ProcessingEnvironment
+import javax.annotation.processing.RoundEnvironment
+
+abstract class ClassProcessor  {
+  abstract fun process( environment: RoundEnvironment?): List<JavaFile.Builder?>?
+}
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/db/ompiler/CodeBlockGenerator.kt b/compiler/src/main/java/promise/db/ompiler/CodeGenerator.kt
similarity index 94%
rename from compiler/src/main/java/promise/db/ompiler/CodeBlockGenerator.kt
rename to compiler/src/main/java/promise/db/ompiler/CodeGenerator.kt
index d99b4f6..ac32e65 100644
--- a/compiler/src/main/java/promise/db/ompiler/CodeBlockGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/CodeGenerator.kt
@@ -14,7 +14,7 @@
 package promise.db.ompiler
 
 
-interface CodeBlockGenerator<out T> {
+interface CodeGenerator<out T> {
   @Throws(Exception::class)
   fun generate(): T
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseAbstractFuncsGenerator.kt b/compiler/src/main/java/promise/db/ompiler/DatabaseAbstractMethodsGenerator.kt
similarity index 97%
rename from compiler/src/main/java/promise/db/ompiler/DatabaseAbstractFuncsGenerator.kt
rename to compiler/src/main/java/promise/db/ompiler/DatabaseAbstractMethodsGenerator.kt
index 59980f8..6d584c1 100644
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseAbstractFuncsGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/DatabaseAbstractMethodsGenerator.kt
@@ -29,10 +29,9 @@ import javax.lang.model.type.TypeKind
 import javax.lang.model.util.ElementFilter
 import javax.tools.Diagnostic
 
-
-class DatabaseAbstractFuncsGenerator(
+class DatabaseAbstractMethodsGenerator(
     private val element: TypeElement,
-    private val processingEnv: ProcessingEnvironment) : CodeBlockGenerator<List<MethodSpec>?> {
+    private val processingEnv: ProcessingEnvironment) : CodeGenerator<List<MethodSpec>?> {
 
 
   override fun generate(): List<MethodSpec>? {
diff --git a/compiler/src/main/java/promise/db/ompiler/annotation/DatabaseAnnotationGenerator.kt b/compiler/src/main/java/promise/db/ompiler/DatabaseAnnotationGenerator.kt
similarity index 87%
rename from compiler/src/main/java/promise/db/ompiler/annotation/DatabaseAnnotationGenerator.kt
rename to compiler/src/main/java/promise/db/ompiler/DatabaseAnnotationGenerator.kt
index c949ffb..e4b73a4 100644
--- a/compiler/src/main/java/promise/db/ompiler/annotation/DatabaseAnnotationGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/DatabaseAnnotationGenerator.kt
@@ -11,16 +11,11 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler.annotation
+package promise.db.ompiler
 
 import com.squareup.javapoet.AnnotationSpec
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
-import promise.db.ompiler.CodeBlockGenerator
-import promise.db.ompiler.Utils
-import promise.db.ompiler.getClassName
-import promise.db.ompiler.getDatabaseVersion
-import promise.db.ompiler.getTableEntities
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.TypeElement
@@ -29,7 +24,7 @@ import javax.tools.Diagnostic
 
 class DatabaseAnnotationGenerator(
     private val processingEnv: ProcessingEnvironment,
-    private val element: Element) : CodeBlockGenerator<AnnotationSpec> {
+    private val element: Element) : CodeGenerator<AnnotationSpec> {
   /*
   @Database(
     tables = [
diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseCrudStubsGenerator.kt b/compiler/src/main/java/promise/db/ompiler/DatabaseCrudStubMethodsGenerator.kt
similarity index 90%
rename from compiler/src/main/java/promise/db/ompiler/DatabaseCrudStubsGenerator.kt
rename to compiler/src/main/java/promise/db/ompiler/DatabaseCrudStubMethodsGenerator.kt
index a1239c2..0512480 100644
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseCrudStubsGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/DatabaseCrudStubMethodsGenerator.kt
@@ -18,10 +18,10 @@ import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.TypeElement
 
-class DatabaseCrudStubsGenerator(
+class DatabaseCrudStubMethodsGenerator(
     private val typeSpec: TypeSpec.Builder,
     private val element: Element,
-    private val processingEnv: ProcessingEnvironment) : CodeBlockGenerator<String> {
+    private val processingEnv: ProcessingEnvironment) : CodeGenerator<String> {
 
   override fun generate(): String {
     val pack = processingEnv.elementUtils.getPackageOf(element).toString()
diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseEntityProcessor.kt b/compiler/src/main/java/promise/db/ompiler/DatabaseEntityProcessor.kt
new file mode 100644
index 0000000..7f6d06e
--- /dev/null
+++ b/compiler/src/main/java/promise/db/ompiler/DatabaseEntityProcessor.kt
@@ -0,0 +1,89 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db.ompiler
+
+import com.squareup.javapoet.ClassName
+import com.squareup.javapoet.FieldSpec
+import com.squareup.javapoet.JavaFile
+import com.squareup.javapoet.MethodSpec
+import com.squareup.javapoet.TypeSpec
+import promise.db.DatabaseEntity
+import javax.annotation.processing.ProcessingEnvironment
+import javax.annotation.processing.RoundEnvironment
+import javax.lang.model.element.Element
+import javax.lang.model.element.ElementKind
+import javax.lang.model.element.Modifier
+import javax.lang.model.element.TypeElement
+import javax.tools.Diagnostic
+
+class DatabaseEntityProcessor(private val processingEnv: ProcessingEnvironment): ClassProcessor() {
+
+  override fun process(environment: RoundEnvironment?): List<JavaFile.Builder?>? {
+        return environment?.getElementsAnnotatedWith(DatabaseEntity::class.java)
+        ?.map { element ->
+          if (element.kind != ElementKind.CLASS) {
+            processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "Only classes can be annotated")
+            return null
+          }
+//          if (JavaUtils.isSubtypeOfType(element.asType(), "promise.db.PromiseDatabase")) {
+//             processElement(element)
+//          }
+//          processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "Database class must extend from promise.db.PromiseDatabase")
+//           null
+
+          processElement(element)
+        }
+  }
+
+  private fun processElement(element: Element): JavaFile.Builder {
+    processingEnv.messager.printMessage(Diagnostic.Kind.OTHER, "DatabaseProcessor Processing: ${element.simpleName}")
+
+    val className = element.simpleName.toString()
+    val pack = processingEnv.elementUtils.getPackageOf(element).toString()
+
+    val fileName = "${className}_Impl"
+
+    val tableAnnotationSpec = DatabaseAnnotationGenerator(processingEnv, element).generate()
+
+    val classBuilder = TypeSpec.classBuilder(fileName)
+
+    val constructorMethod = MethodSpec.constructorBuilder()
+        .addParameter(ClassName.get("promise.db", "FastDatabase"),
+            "fastDatabase")
+        .addModifiers(Modifier.PRIVATE)
+        .addStatement("super()")
+        .addStatement("this.instance = fastDatabase")
+    if (TypeConverterProcessor.typeConverter != null) {
+      JavaUtils.generateAddConverterStatementInDatabaseConstructorMethod(processingEnv, constructorMethod, TypeConverterProcessor.typeConverter!!)
+    }
+    classBuilder.superclass(ClassName.get(pack, className))
+        .addAnnotation(tableAnnotationSpec)
+        .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
+        .addMethod(constructorMethod
+            .build())
+
+    DatabaseStaticMethodsGenerator(classBuilder, element, processingEnv).generate()
+
+    val abstractFuncsBuilder = DatabaseAbstractMethodsGenerator((element as TypeElement), processingEnv)
+
+    abstractFuncsBuilder.generate()?.forEach {
+      classBuilder.addMethod(it)
+    }
+
+    DatabaseCrudStubMethodsGenerator(classBuilder, element, processingEnv).generate()
+
+   return JavaFile.builder(pack, classBuilder.build())
+
+  }
+}
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/db/ompiler/migration/MigrationGenerator.kt b/compiler/src/main/java/promise/db/ompiler/DatabaseMigrationFieldGenerator.kt
similarity index 94%
rename from compiler/src/main/java/promise/db/ompiler/migration/MigrationGenerator.kt
rename to compiler/src/main/java/promise/db/ompiler/DatabaseMigrationFieldGenerator.kt
index a082e25..98fdc90 100644
--- a/compiler/src/main/java/promise/db/ompiler/migration/MigrationGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/DatabaseMigrationFieldGenerator.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler.migration
+package promise.db.ompiler
 
 import com.squareup.javapoet.AnnotationSpec
 import com.squareup.javapoet.ClassName
@@ -21,13 +21,11 @@ import org.jetbrains.annotations.NotNull
 import promise.db.Migrate
 import promise.db.MigrationOptions
 import promise.db.Migrations
-import promise.db.ompiler.CodeBlockGenerator
-import promise.db.ompiler.getNameOfColumn
 import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
 
-class MigrationGenerator(
-    private val elements: Map<Element, String>) : CodeBlockGenerator<MethodSpec?> {
+class DatabaseMigrationFieldGenerator(
+    private val elements: Map<Element, String>) : CodeGenerator<MethodSpec?> {
   init {
     //fileSpec.addImport("android.content", "ContentValues")
   }
diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseProcessor.kt b/compiler/src/main/java/promise/db/ompiler/DatabaseProcessor.kt
deleted file mode 100644
index 75cf95a..0000000
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseProcessor.kt
+++ /dev/null
@@ -1,150 +0,0 @@
-/*
- * Copyright 2017, Peter Vincent
- * Licensed under the Apache License, Version 2.0, Android Promise.
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package promise.db.ompiler
-
-import com.squareup.javapoet.ClassName
-import com.squareup.javapoet.JavaFile
-import com.squareup.javapoet.MethodSpec
-import com.squareup.javapoet.TypeSpec
-import promise.db.DatabaseEntity
-import promise.db.ompiler.annotation.DatabaseAnnotationGenerator
-import javax.annotation.processing.ProcessingEnvironment
-import javax.annotation.processing.RoundEnvironment
-import javax.lang.model.element.Element
-import javax.lang.model.element.ElementKind
-import javax.lang.model.element.Modifier
-import javax.lang.model.element.TypeElement
-import javax.tools.Diagnostic
-
-class DatabaseProcessor(private val processingEnv: ProcessingEnvironment) {
-  fun process(_mutableSet: MutableSet<out TypeElement>?, environment: RoundEnvironment?): Boolean {
-    environment?.getElementsAnnotatedWith(DatabaseEntity::class.java)
-        ?.forEach { element ->
-          if (element.kind != ElementKind.CLASS) {
-            processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "Only classes can be annotated")
-            return false
-          }
-//          val promiseDatabaseInterface = processingEnv.elementUtils.getTypeElement("promise.db.PromiseDatabase")
-//          if (JavaUtils.implementsInterface(processingEnv, element as TypeElement, promiseDatabaseInterface.asType())) {
-//            processElement(element)
-//          }
-//          else {
-//            processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "The database class ${element.simpleName} must implement PromiseDatabase")
-//            return false
-//          }
-          processElement(element)
-        }
-    return true
-  }
-
-  private fun processElement(element: Element) {
-    processingEnv.messager.printMessage(Diagnostic.Kind.OTHER, "DatabaseProcessor Processing: ${element.simpleName}")
-
-    val className = element.simpleName.toString()
-    val pack = processingEnv.elementUtils.getPackageOf(element).toString()
-
-    val fileName = "${className}_Impl"
-
-    //fileBuilder.addComment("Generated by Promise database compiler")
-
-    //fileBuilder.addImport(pack, className)
-    val tableAnnotationSpec = DatabaseAnnotationGenerator(processingEnv, element).generate()
-
-    val classBuilder = TypeSpec.classBuilder(fileName)
-    classBuilder.superclass(ClassName.get(pack, className))
-        .addAnnotation(tableAnnotationSpec)
-        .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
-        .addMethod(MethodSpec.constructorBuilder()
-            .addParameter(ClassName.get("promise.db", "FastDatabase"),"instance")
-            .addModifiers(Modifier.PRIVATE)
-            .addStatement("super()")
-            .addStatement("this.instance = instance")
-            .build())
-    DatabaseCompanionPropsGenerator(classBuilder, element, processingEnv).generate()
-
-    val abstractFuncsBuilder = DatabaseAbstractFuncsGenerator((element as TypeElement), processingEnv)
-
-    abstractFuncsBuilder.generate()?.forEach {
-      classBuilder.addMethod(it)
-    }
-
-    DatabaseCrudStubsGenerator(classBuilder, element, processingEnv).generate()
-
-//    // static column block generation
-//    val columnsGenerator: ColumnsGenerator = ColumnsGenerator(fileBuilder, processingEnv, element.enclosedElements)
-//    val companionBuilder = TypeSpec.companionObjectBuilder()
-//
-//    val idColumnSpec = PropertySpec.builder("idColumn", ClassName("promise.db", "Column")
-//        .parameterizedBy(Int::class.asTypeName()))
-//        .initializer(CodeBlock.of("""
-//                id
-//              """.trimIndent())
-//        )
-//        .build()
-//
-//    companionBuilder.addProperty(idColumnSpec)
-//
-//    val columnSpecs = columnsGenerator.generate()
-//
-//    columnSpecs.values.forEach {
-//      companionBuilder.addProperty(it)
-//    }
-//
-//    classBuilder.addType(companionBuilder.build())
-//
-//    // column register generation
-//    val columnRegSpecGenerator = RegisterColumnsGenerator(fileBuilder, columnsGenerator.genColValues.map { it.second })
-//    classBuilder.addProperty(columnRegSpecGenerator.generate())
-//
-//    // serializer generator
-//    val serializerGenerator = SerializerGenerator(fileBuilder, pack, className, columnsGenerator.genColValues)
-//    classBuilder.addFunction(serializerGenerator.generate())
-//
-//    // deserializer generator
-//    val deserializerGenerator = DeserializerGenerator(fileBuilder, processingEnv,
-//        pack, className, columnsGenerator.genColValues)
-//    classBuilder.addFunction(deserializerGenerator.generate())
-//
-//    // migrations
-//    val elemMap = HashMap<Element, String>()
-//    columnSpecs.forEach {
-//      elemMap[it.key.first] = it.key.second
-//    }
-//    val migrationGenerator = MigrationGenerator(fileBuilder, elemMap)
-//    val migrationFunc = migrationGenerator.generate()
-//    if (migrationFunc != null) classBuilder.addFunction(migrationFunc)
-
-    val fileBuilder = JavaFile.builder(pack, classBuilder.build())
-    val file = fileBuilder
-        .indent("    ")
-        .skipJavaLangImports(true)
-        .addFileComment(
-            """
-            Copyright 2017, Android Promise Database
-            Licensed under the Apache License, Version 2.0, Android Promise.
-            you may not use this file except in compliance with the License.
-            You may obtain a copy of the License at
-            http://www.apache.org/licenses/LICENSE-2.0
-            Unless required by applicable law or agreed to in writing,
-            software distributed under the License is distributed on an AS IS BASIS,
-            WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied
-            See the License for the specific language governing permissions and
-            limitations under the License
-            """.trimIndent()
-            )
-        .build()
-    //val kaptKotlinGeneratedDir = processingEnv.options[EntityProcessor.KAPT_JAVA_GENERATED_OPTION_NAME]!!
-    file.writeTo(processingEnv.filer)
-  }
-}
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseCompanionPropsGenerator.kt b/compiler/src/main/java/promise/db/ompiler/DatabaseStaticMethodsGenerator.kt
similarity index 94%
rename from compiler/src/main/java/promise/db/ompiler/DatabaseCompanionPropsGenerator.kt
rename to compiler/src/main/java/promise/db/ompiler/DatabaseStaticMethodsGenerator.kt
index 2d2f0f6..e375e40 100644
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseCompanionPropsGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/DatabaseStaticMethodsGenerator.kt
@@ -25,10 +25,10 @@ import javax.lang.model.element.Modifier
 import javax.lang.model.element.TypeElement
 import javax.tools.Diagnostic
 
-class DatabaseCompanionPropsGenerator(
+class DatabaseStaticMethodsGenerator(
     private val typeSpec: TypeSpec.Builder,
     private val element: Element,
-    private val processingEnv: ProcessingEnvironment) : CodeBlockGenerator<String> {
+    private val processingEnv: ProcessingEnvironment) : CodeGenerator<String> {
 
   override fun generate(): String {
     val className = element.simpleName.toString()
@@ -43,18 +43,7 @@ class DatabaseCompanionPropsGenerator(
 
     val entities = (element as TypeElement).getTableEntities(processingEnv)
 
-    /**
-     * private static Migration getMigration() {
-            return new Migration() {
-              @Override
-              public void onMigrate(@NotNull FastDatabase database, @NotNull SQLiteDatabase sqLiteDatabase, int oldVersion, int newVersion) {
-                if (oldVersion == 2 && newVersion == 3) {
-                  database.add(sqLiteDatabase, database.obtain(PersonFastTable.class));
-                }
-              }
-            };
-          }
-     */
+
     var migrationInitialzer = """
       return new Migration() {
               @Override
@@ -92,6 +81,14 @@ class DatabaseCompanionPropsGenerator(
         .addModifiers(Modifier.PRIVATE)
         .build())
 
+    if (TypeConverterProcessor.typeConverter != null) {
+      typeSpec.addField(FieldSpec.builder(
+          TypeConverterProcessor.typeConverter!!.toTypeName(),
+          "typeConverter")
+          .addModifiers(Modifier.PRIVATE)
+          .build())
+    }
+
     typeSpec.addField(FieldSpec.builder(Boolean::class.javaPrimitiveType,"initialized")
         .initializer("false")
         .addModifiers(Modifier.PRIVATE, Modifier.VOLATILE, Modifier.STATIC)
diff --git a/compiler/src/main/java/promise/db/ompiler/EntityProcessor.kt b/compiler/src/main/java/promise/db/ompiler/EntityProcessor.kt
index f1a08f4..6afad03 100644
--- a/compiler/src/main/java/promise/db/ompiler/EntityProcessor.kt
+++ b/compiler/src/main/java/promise/db/ompiler/EntityProcessor.kt
@@ -13,7 +13,6 @@
 
 package promise.db.ompiler
 
-import com.google.auto.service.AutoService
 import com.squareup.javapoet.AnnotationSpec
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
@@ -22,69 +21,40 @@ import com.squareup.javapoet.JavaFile
 import com.squareup.javapoet.MethodSpec
 import com.squareup.javapoet.ParameterizedTypeName
 import com.squareup.javapoet.TypeSpec
-import net.ltgt.gradle.incap.IncrementalAnnotationProcessor
-import net.ltgt.gradle.incap.IncrementalAnnotationProcessorType
 import org.jetbrains.annotations.NotNull
-import promise.db.DatabaseEntity
 import promise.db.Entity
-import promise.db.ompiler.annotation.TableAnnotationGenerator
-import promise.db.ompiler.migration.MigrationGenerator
-import java.util.*
-import javax.annotation.processing.AbstractProcessor
 import javax.annotation.processing.ProcessingEnvironment
-import javax.annotation.processing.Processor
 import javax.annotation.processing.RoundEnvironment
-import javax.annotation.processing.SupportedOptions
-import javax.annotation.processing.SupportedSourceVersion
-import javax.lang.model.SourceVersion
 import javax.lang.model.element.Element
 import javax.lang.model.element.ElementKind
 import javax.lang.model.element.Modifier
 import javax.lang.model.element.TypeElement
 import javax.tools.Diagnostic
 
-
-@AutoService(Processor::class) // For registering the service
-@IncrementalAnnotationProcessor(IncrementalAnnotationProcessorType.DYNAMIC)
-@SupportedSourceVersion(SourceVersion.RELEASE_7) // to support Java 8
-@SupportedOptions(EntityProcessor.KAPT_JAVA_GENERATED_OPTION_NAME)
-class EntityProcessor : AbstractProcessor() {
-
-  override fun init(processingEnv: ProcessingEnvironment?) {
-    super.init(processingEnv)
-  }
-
-  override fun process(mutableSet: MutableSet<out TypeElement>?, environment: RoundEnvironment?): Boolean {
-    try {
-      environment?.getElementsAnnotatedWith(Entity::class.java)
-          ?.forEach { element ->
-            if (element.kind != ElementKind.CLASS) {
-              processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "Only classes can be annotated")
-              return false
-            }
+class EntityProcessor(private val processingEnv: ProcessingEnvironment) : ClassProcessor() {
+  override fun process(environment: RoundEnvironment?): List<JavaFile.Builder?>? {
+    return environment?.getElementsAnnotatedWith(Entity::class.java)
+        ?.map { element ->
+          if (element.kind != ElementKind.CLASS) {
+            processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "Only classes can be annotated")
+            return null
+          }
 
 //            val identifiableInterface = processingEnv.elementUtils.getTypeElement("promise.commons.model.Identifiable")
 //            processingEnv.messager.printMessage(Diagnostic.Kind.NOTE, "Entity class ${element.simpleName}, interfaceType ${identifiableInterface.toString()}")
 //            if (JavaUtils.implementsInterface(processingEnv, element as TypeElement, identifiableInterface.asType())) {
 //              processAnnotation(element)
 //            }
-             processAnnotation(element)
+          processAnnotation(element)
 //            else {
 //              processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "The Entity class ${element.simpleName} must implement Identifiable")
 //              return false
 //            }
-          }
-      //return true
-      return DatabaseProcessor(processingEnv).process(mutableSet, environment)
-    } catch (e: Throwable) {
-      processingEnv.messager.printMessage(Diagnostic.Kind.ERROR,
-          //"EntityProcessor: ${Utils.getStackTraceString(e)} " +
-              "EntityProcessor Trace: ${Arrays.toString(e.stackTrace)}")
-      return false
-    }
+        }
   }
 
-  private fun processAnnotation(element: Element) {
+
+  private fun processAnnotation(element: Element): JavaFile.Builder {
     processingEnv.messager.printMessage(Diagnostic.Kind.OTHER, "Entity Processing: ${element.simpleName}")
 
     val className = element.simpleName.toString()
@@ -113,15 +83,15 @@ class EntityProcessor : AbstractProcessor() {
 
     if (Utils.elementExtendsSuperClass((element as TypeElement), "promise.db.ActiveRecord"))
       classBuilder.addMethod(MethodSpec.methodBuilder("createEntityInstance")
-        .addAnnotation(Override::class.java)
-        .addAnnotation(NotNull::class.java)
-        .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
-        .returns(ClassName.get(pack, className))
-        .addCode("return new $className();")
-        .build())
+          .addAnnotation(Override::class.java)
+          .addAnnotation(NotNull::class.java)
+          .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
+          .returns(ClassName.get(pack, className))
+          .addCode("return new $className();")
+          .build())
 
     // static column block generation
-    val tableColumnPropsGenerator = TableColumnPropsGenerator(classBuilder, processingEnv, element.enclosedElements)
+    val tableColumnPropsGenerator = TableColumnFieldsGenerator(processingEnv, element.enclosedElements)
 
     val idColumnSpec = FieldSpec.builder(
         ParameterizedTypeName.get(
@@ -150,15 +120,15 @@ class EntityProcessor : AbstractProcessor() {
     }
 
     // column register generation
-    val columnRegSpecGenerator = RegisterColumnsGenerator(tableColumnPropsGenerator.genColValues.map { it.second })
+    val columnRegSpecGenerator = TableRegisteredColumnsMethodGenerator(tableColumnPropsGenerator.genColValues.map { it.second })
     classBuilder.addMethod(columnRegSpecGenerator.generate())
 
     // serializer generator
-    val serializerGenerator = SerializerGenerator(pack, className, tableColumnPropsGenerator.genColValues)
+    val serializerGenerator = TableSerializerMethodGenerator(pack, className, tableColumnPropsGenerator.genColValues)
     classBuilder.addMethod(serializerGenerator.generate())
 
     // deserializer generator
-    val deserializerGenerator = DeserializerGenerator(pack, className,
+    val deserializerGenerator = TableDeserializerMethodGenerator(pack, className,
         tableColumnPropsGenerator.genColValues)
     classBuilder.addMethod(deserializerGenerator.generate())
 
@@ -167,41 +137,12 @@ class EntityProcessor : AbstractProcessor() {
     columnSpecs.forEach {
       elemMap[it.key.first] = it.key.second
     }
-    val migrationGenerator = MigrationGenerator(elemMap)
+    val migrationGenerator = DatabaseMigrationFieldGenerator(elemMap)
     val migrationFunc = migrationGenerator.generate()
     if (migrationFunc != null) classBuilder.addMethod(migrationFunc)
 
-    val fileBuilder = JavaFile.builder(pack, classBuilder.build())
-    //val kaptKotlinGeneratedDir = processingEnv.options[KAPT_JAVA_GENERATED_OPTION_NAME]!!
-
-    fileBuilder
-        .indent("    ")
-        .skipJavaLangImports(true)
-        .addFileComment(
-            """
-            Copyright 2017, Android Promise Database
-            Licensed under the Apache License, Version 2.0, Android Promise.
-            you may not use this file except in compliance with the License.
-            You may obtain a copy of the License at
-            http://www.apache.org/licenses/LICENSE-2.0
-            Unless required by applicable law or agreed to in writing,
-            software distributed under the License is distributed on an AS IS BASIS,
-            WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied
-            See the License for the specific language governing permissions and
-            limitations under the License
-            """.trimIndent()
-            )
-        .build()
-        .writeTo(processingEnv.filer)
+    return JavaFile.builder(pack, classBuilder.build())
   }
 
-  override fun getSupportedAnnotationTypes(): MutableSet<String> = mutableSetOf(
-      Entity::class.java.name,
-      DatabaseEntity::class.java.name
-  )
-
-  companion object {
-    const val KAPT_JAVA_GENERATED_OPTION_NAME = "kapt.java.generated"
-  }
 
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/db/ompiler/JavaUtils.java b/compiler/src/main/java/promise/db/ompiler/JavaUtils.java
index ad97721..6e3429a 100644
--- a/compiler/src/main/java/promise/db/ompiler/JavaUtils.java
+++ b/compiler/src/main/java/promise/db/ompiler/JavaUtils.java
@@ -15,13 +15,20 @@
 
 import com.squareup.javapoet.ClassName;
 import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.MethodSpec;
 import com.squareup.javapoet.TypeName;
 
+import org.jetbrains.annotations.Nullable;
+
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.Element;
 import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeKind;
 import javax.lang.model.type.TypeMirror;
 
 public class JavaUtils {
@@ -38,6 +45,17 @@ public class JavaUtils {
     put(void.class, Void.class);
   }};
 
+  public static void generateAddConverterStatementInDatabaseConstructorMethod(
+      ProcessingEnvironment processingEnvironment,
+      MethodSpec.Builder constructorMethod,
+      TypeElement converter) {
+    String pack = processingEnvironment.getElementUtils().getPackageOf(converter).toString();
+    constructorMethod.addStatement("this.typeConverter = $T.provider($T.create(new $T())).get()",
+        ClassName.get("promise.commons", "SingletonInstanceProvider"),
+        ClassName.get(pack, TypeConverterProcessorKt.getTypeConverterClassName(converter)),
+        UtilsKt.toTypeName(converter));
+  }
+
   public static void generateIfStatementObtainClassString(
       ProcessingEnvironment processingEnv,
       CodeBlock.Builder codeBlock,
@@ -54,27 +72,57 @@ public static <T> Class<T> wrap(Class<T> c) {
     return c.isPrimitive() ? (Class<T>) PRIMITIVES_TO_WRAPPERS.get(c) : c;
   }
 
-  public static boolean implementsInterface(
-      ProcessingEnvironment processingEnv,
-      TypeElement myTypeElement,
-      TypeMirror desiredInterface) {
-    boolean found = false;
-    while (myTypeElement.getSuperclass()
-        != processingEnv.getElementUtils().getTypeElement("java.lang.Object").asType()
-        &&   !found) {
-      for (TypeMirror t : myTypeElement.getInterfaces()) {
-        if (processingEnv.getTypeUtils().isAssignable(t, desiredInterface)){
-          found = true;
-          break;
-        }
-        else {
-          TypeElement elem = (TypeElement) processingEnv.getTypeUtils().asElement(t);
-          return implementsInterface(processingEnv, elem, desiredInterface);
+
+  public static TypeElement getSuperClass(TypeElement typeElement) {
+    TypeMirror type = typeElement.getSuperclass();
+    if (type.getKind() == TypeKind.NONE) {
+      return null;
+    }
+    return (TypeElement) ((DeclaredType) type).asElement();
+  }
+
+  static boolean isTypeEqual(TypeMirror typeMirror, TypeName otherType) {
+    return otherType.toString().equals(TypeName.get(typeMirror).toString());
+  }
+
+  static boolean isSubtypeOfType(TypeMirror typeMirror, TypeName otherType) {
+    if (isTypeEqual(typeMirror, otherType)) {
+      return true;
+    }
+    if (typeMirror.getKind() != TypeKind.DECLARED) {
+      return false;
+    }
+    DeclaredType declaredType = (DeclaredType) typeMirror;
+    List<? extends TypeMirror> typeArguments = declaredType.getTypeArguments();
+    if (typeArguments.size() > 0) {
+      StringBuilder typeString = new StringBuilder(declaredType.asElement().toString());
+      typeString.append('<');
+      for (int i = 0; i < typeArguments.size(); i++) {
+        if (i > 0) {
+          typeString.append(',');
         }
+        typeString.append('?');
+      }
+      typeString.append('>');
+      if (typeString.toString().equals(otherType)) {
+        return true;
       }
     }
-
-    return found;
+    Element element = declaredType.asElement();
+    if (!(element instanceof TypeElement)) {
+      return false;
+    }
+    TypeElement typeElement = (TypeElement) element;
+    TypeMirror superType = typeElement.getSuperclass();
+    if (isSubtypeOfType(superType, otherType)) {
+      return true;
+    }
+    for (TypeMirror interfaceType : typeElement.getInterfaces()) {
+      if (isSubtypeOfType(interfaceType, otherType)) {
+        return true;
+      }
+    }
+    return false;
   }
 
   public static boolean extendsClass(
diff --git a/compiler/src/main/java/promise/db/ompiler/PersistableEntityUtils.kt b/compiler/src/main/java/promise/db/ompiler/PersistableEntityUtils.kt
index a3083ef..99c5872 100644
--- a/compiler/src/main/java/promise/db/ompiler/PersistableEntityUtils.kt
+++ b/compiler/src/main/java/promise/db/ompiler/PersistableEntityUtils.kt
@@ -14,18 +14,23 @@
 package promise.db.ompiler
 
 import com.squareup.javapoet.ClassName
+import com.squareup.javapoet.TypeName
 import com.sun.tools.javac.code.Attribute
 import org.atteo.evo.inflector.English
 import promise.db.DatabaseEntity
 import promise.db.Entity
 import promise.db.ForeignKey
+import promise.db.HasMany
+import promise.db.HasOne
 import promise.db.Index
 import java.io.IOException
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
+import javax.lang.model.element.ExecutableElement
 import javax.lang.model.element.TypeElement
 import javax.lang.model.type.TypeMirror
 import javax.lang.model.util.ElementFilter
+import javax.tools.Diagnostic
 
 /**
  * gets the className for type element
@@ -148,4 +153,80 @@ fun Element.getNameOfColumn(): String {
 
 fun String.capitalizeFirst(): String = this.replaceFirst(this.first(), this.first().toUpperCase())
 
-fun String.camelCase(): String = this.replaceFirst(this.first(), this.first().toLowerCase())
\ No newline at end of file
+fun String.camelCase(): String = this.replaceFirst(this.first(), this.first().toLowerCase())
+
+fun Element.checkIfHasTypeConverter(): Boolean {
+  //return true
+  if (TypeConverterProcessor.typeConverter != null)
+    return this.getConverterCompatibleMethod(ConverterTypes.SERIALIZER) != null &&
+      this.getConverterCompatibleMethod(ConverterTypes.DESERIALIZER) != null
+  return false
+}
+
+fun Element.checkIfHasTypeConverter(processingEnv: ProcessingEnvironment): Boolean {
+  //return true
+  if (TypeConverterProcessor.typeConverter != null)
+    return this.getConverterCompatibleMethod(ConverterTypes.SERIALIZER, processingEnv) != null &&
+        this.getConverterCompatibleMethod(ConverterTypes.DESERIALIZER, processingEnv) != null
+  return false
+}
+
+enum class ConverterTypes {
+  DESERIALIZER,
+  SERIALIZER
+}
+
+fun Element.getConverterCompatibleMethod(converterTypes: ConverterTypes): ExecutableElement? {
+  if (TypeConverterProcessor.typeConverter != null) {
+    val methods =
+        ElementFilter.methodsIn(TypeConverterProcessor.typeConverter!!.enclosedElements)
+            .filter { it.parameters.size == 1 }
+    return methods.find {
+      when(converterTypes) {
+        ConverterTypes.DESERIALIZER -> {
+          JavaUtils.isTypeEqual(it.parameters[0].asType(), TypeName.get(String::class.java)) &&
+              JavaUtils.isTypeEqual(it.returnType, TypeName.get(this.asType()))
+        }
+        ConverterTypes.SERIALIZER -> {
+          JavaUtils.isTypeEqual(it.parameters[0].asType(), TypeName.get(this.asType())) &&
+              JavaUtils.isTypeEqual(it.returnType, TypeName.get(String::class.java))
+        }
+      }
+    }
+  }
+    else return null
+}
+
+
+fun Element.getConverterCompatibleMethod(converterTypes: ConverterTypes, processingEnv: ProcessingEnvironment): ExecutableElement? {
+  if (TypeConverterProcessor.typeConverter != null) {
+    val methods =
+        ElementFilter.methodsIn(TypeConverterProcessor.typeConverter!!.enclosedElements)
+            .filter {
+              it.parameters.size == 1 }
+    return methods.find {
+//      processingEnv.messager.printMessage(Diagnostic.Kind.NOTE, "Type converter: " +
+//          " method: ${it}, " +
+//          " returnType: ${TypeName.get(it.returnType)}" +
+//          " parameter: ${TypeName.get(it.parameters[0].asType())}" +
+//          " elementType ${TypeName.get(this.asType())}")
+      when(converterTypes) {
+        ConverterTypes.DESERIALIZER -> {
+
+          JavaUtils.isTypeEqual(it.parameters[0].asType(), TypeName.get(String::class.java)) &&
+              JavaUtils.isTypeEqual(it.returnType, TypeName.get(this.asType()))
+        }
+        ConverterTypes.SERIALIZER -> {
+          JavaUtils.isTypeEqual(it.parameters[0].asType(), TypeName.get(this.asType())) &&
+              JavaUtils.isTypeEqual(it.returnType, TypeName.get(String::class.java))
+        }
+      }
+    }
+  }
+  else return null
+}
+fun Element.isElementAnnotatedAsRelation(): Boolean {
+  //return false
+  return this.getAnnotation(HasMany::class.java) != null ||
+     this.getAnnotation(HasOne::class.java) != null
+}
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt b/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt
new file mode 100644
index 0000000..9ffa645
--- /dev/null
+++ b/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db.ompiler
+
+import com.google.auto.service.AutoService
+import com.squareup.javapoet.JavaFile
+import net.ltgt.gradle.incap.IncrementalAnnotationProcessor
+import net.ltgt.gradle.incap.IncrementalAnnotationProcessorType
+import promise.db.DatabaseEntity
+import promise.db.Entity
+import promise.db.TypeConverter
+import java.util.*
+import javax.annotation.processing.AbstractProcessor
+import javax.annotation.processing.Processor
+import javax.annotation.processing.RoundEnvironment
+import javax.annotation.processing.SupportedOptions
+import javax.annotation.processing.SupportedSourceVersion
+import javax.lang.model.SourceVersion
+import javax.lang.model.element.TypeElement
+import javax.tools.Diagnostic
+import kotlin.collections.ArrayList
+
+@AutoService(Processor::class) // For registering the service
+@IncrementalAnnotationProcessor(IncrementalAnnotationProcessorType.DYNAMIC)
+@SupportedSourceVersion(SourceVersion.RELEASE_7) // to support Java 8
+@SupportedOptions(PromiseDatabaseCompiler.KAPT_JAVA_GENERATED_OPTION_NAME)
+class PromiseDatabaseCompiler : AbstractProcessor() {
+
+  override fun process(mutableSet: MutableSet<out TypeElement>?, environment: RoundEnvironment?): Boolean {
+    try {
+      val javaFiles: ArrayList<JavaFile.Builder> = ArrayList()
+      val processors: ArrayList<ClassProcessor> = ArrayList()
+
+      processors.add(TypeConverterProcessor(processingEnv))
+      processors.add(EntityProcessor(processingEnv))
+      processors.add(DatabaseEntityProcessor(processingEnv))
+
+      processors.forEach {
+        val builder = it.process(environment)
+        if (builder != null) {
+          javaFiles.addAll(builder.filterNotNull())
+        }
+      }
+      javaFiles.forEach {
+        val file = it
+            .indent("  ")
+            .skipJavaLangImports(true)
+            .addFileComment(
+                """
+                Copyright 2017, Android Promise Database
+                Licensed under the Apache License, Version 2.0, Android Promise.
+                you may not use this file except in compliance with the License.
+                You may obtain a copy of the License at
+                http://www.apache.org/licenses/LICENSE-2.0
+                Unless required by applicable law or agreed to in writing,
+                software distributed under the License is distributed on an AS IS BASIS,
+                WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied
+                See the License for the specific language governing permissions and
+                limitations under the License
+                
+                Code Resource https://github.com/android-promise
+              
+            """.trimIndent()
+            )
+            .build()
+        file.writeTo(processingEnv.filer)
+      }
+      return true
+    } catch (e: Throwable) {
+      processingEnv.messager.printMessage(Diagnostic.Kind.ERROR,
+          //"EntityProcessor: ${Utils.getStackTraceString(e)} " +
+          "EntityProcessor Trace: ${Arrays.toString(e.stackTrace)}")
+      return false
+    }
+  }
+
+  override fun getSupportedAnnotationTypes(): MutableSet<String> = mutableSetOf(
+      Entity::class.java.name,
+      DatabaseEntity::class.java.name,
+      TypeConverter::class.java.name
+  )
+
+  companion object {
+    const val KAPT_JAVA_GENERATED_OPTION_NAME = "kapt.java.generated"
+  }
+
+}
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/db/ompiler/relations/RelationsGenerator.kt b/compiler/src/main/java/promise/db/ompiler/RelationsGenerator.kt
similarity index 93%
rename from compiler/src/main/java/promise/db/ompiler/relations/RelationsGenerator.kt
rename to compiler/src/main/java/promise/db/ompiler/RelationsGenerator.kt
index 7ba879d..7023a13 100644
--- a/compiler/src/main/java/promise/db/ompiler/relations/RelationsGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/RelationsGenerator.kt
@@ -11,12 +11,11 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler.relations
+package promise.db.ompiler
 
 import com.squareup.javapoet.MethodSpec
 import promise.db.HasMany
 import promise.db.HasOne
-import promise.db.ompiler.CodeBlockGenerator
 import java.util.*
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
@@ -27,7 +26,7 @@ class RelationsGenerator(
     private val processingEnvironment: ProcessingEnvironment
     ,
     private val setElements: List<Element>
-) : CodeBlockGenerator<List<MethodSpec>?> {
+) : CodeGenerator<List<MethodSpec>?> {
 
   override fun generate(): List<MethodSpec>? {
     val funSpecs = ArrayList<MethodSpec>()
diff --git a/compiler/src/main/java/promise/db/ompiler/annotation/TableAnnotationGenerator.java b/compiler/src/main/java/promise/db/ompiler/TableAnnotationGenerator.java
similarity index 97%
rename from compiler/src/main/java/promise/db/ompiler/annotation/TableAnnotationGenerator.java
rename to compiler/src/main/java/promise/db/ompiler/TableAnnotationGenerator.java
index db8a52e..6e9f3c3 100644
--- a/compiler/src/main/java/promise/db/ompiler/annotation/TableAnnotationGenerator.java
+++ b/compiler/src/main/java/promise/db/ompiler/TableAnnotationGenerator.java
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler.annotation;
+package promise.db.ompiler;
 
 import com.squareup.javapoet.AnnotationSpec;
 import com.squareup.javapoet.CodeBlock;
@@ -27,10 +27,10 @@
 
 import promise.db.Entity;
 import promise.db.Table;
-import promise.db.ompiler.CodeBlockGenerator;
+import promise.db.ompiler.CodeGenerator;
 import promise.db.ompiler.PersistableEntityUtilsKt;
 
-public class TableAnnotationGenerator implements CodeBlockGenerator<AnnotationSpec> {
+public class TableAnnotationGenerator implements CodeGenerator<AnnotationSpec> {
   private Element element;
   private ProcessingEnvironment processingEnvironment;
 
diff --git a/compiler/src/main/java/promise/db/ompiler/TableColumnPropsGenerator.kt b/compiler/src/main/java/promise/db/ompiler/TableColumnFieldsGenerator.kt
similarity index 55%
rename from compiler/src/main/java/promise/db/ompiler/TableColumnPropsGenerator.kt
rename to compiler/src/main/java/promise/db/ompiler/TableColumnFieldsGenerator.kt
index fdace1c..2ce4d86 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableColumnPropsGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/TableColumnFieldsGenerator.kt
@@ -18,7 +18,6 @@ import com.squareup.javapoet.CodeBlock
 import com.squareup.javapoet.FieldSpec
 import com.squareup.javapoet.ParameterizedTypeName
 import com.squareup.javapoet.TypeName
-import com.squareup.javapoet.TypeSpec
 import promise.db.Ignore
 import promise.db.PrimaryKey
 import promise.db.PrimaryKeyAutoIncrement
@@ -30,60 +29,89 @@ import javax.tools.Diagnostic
 import kotlin.collections.ArrayList
 import kotlin.collections.HashMap
 
-class TableColumnPropsGenerator(
-                                private val classBuilder: TypeSpec.Builder,
-                                private val processingEnvironment: ProcessingEnvironment
-                                ,
-                                private val setElements: List<Element>) : CodeBlockGenerator<Map<Pair<Element, String>, FieldSpec>> {
+/**
+ * generates column fields for the entity
+ */
+class TableColumnFieldsGenerator(
+    private val processingEnvironment: ProcessingEnvironment,
+    private val setElements: List<Element>) : CodeGenerator<Map<Pair<Element, String>, FieldSpec>> {
 
+  /**
+   *
+   */
   var genColValues: ArrayList<Pair<Pair<String, TypeName>, String>> = ArrayList()
 
-  init {
-    //fileSpec.addImport("promise.db", "Column")
-  }
-
   override fun generate(): Map<Pair<Element, String>, FieldSpec> {
     val map = HashMap<Pair<Element, String>, FieldSpec>()
-    filterPrimitiveElements(setElements.filter {
+    setElements.filter {
       it.kind.isField
-    }).forEachIndexed { i, element ->
+    }.forEachIndexed { i, element ->
       if (element.getAnnotation(PrimaryKeyAutoIncrement::class.java) != null ||
           element.getAnnotation(Ignore::class.java) != null) return@forEachIndexed
       val nameOfColumn = element.getNameOfColumn()
       if (nameOfColumn == "id") return@forEachIndexed
-
       val colVariableName = "${element.simpleName}Column"
       var variableClassType = element.toTypeName()
       if (variableClassType.isPrimitive) variableClassType = variableClassType.box()
-      //processingEnvironment.messager.printMessage(Diagnostic.Kind.OTHER, "gen column : ${element.simpleName} type: $variableClassType")
-
-      val parameterizedColumnTypeName = ParameterizedTypeName.get(ClassName.get("promise.db", "Column"), variableClassType)
-
-      val columnInitializer = getColumnInitializer(element, variableClassType)
-
-
-      val spec = FieldSpec.builder(parameterizedColumnTypeName, colVariableName)
-          .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
-          .initializer(CodeBlock.of("""
-              new Column<${variableClassType}>("$nameOfColumn", $columnInitializer, ${i + 1})
+      if (!isPersistable(element) && !element.isElementAnnotatedAsRelation()) {
+        val executableElement = element.getConverterCompatibleMethod(ConverterTypes.SERIALIZER)
+        if (element.checkIfHasTypeConverter(processingEnvironment)) {
+          val parameterizedColumnTypeName = ParameterizedTypeName.get(
+              ClassName.get("promise.db", "Column"),
+              TypeName.get(String::class.java))
+          val columnInitializer = getColumnInitializer(element, ClassName.get(String::class.java))
+          val spec = FieldSpec.builder(parameterizedColumnTypeName, colVariableName)
+              .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
+              .initializer(CodeBlock.of("""
+              new Column<String>("$nameOfColumn", $columnInitializer, ${i + 1})
             """.trimIndent())
-          )
-          .build()
-      map[Pair(element, colVariableName)] = spec
-      val pair: Pair<Pair<String, TypeName>, String> = Pair(Pair(element.simpleName.toString(), variableClassType), colVariableName)
-      genColValues.add(pair)
+              )
+              .build()
+          map[Pair(element, colVariableName)] = spec
+          val pair: Pair<Pair<String, TypeName>, String> = Pair(Pair(element.simpleName.toString(), TypeName.get(String::class.java)), colVariableName)
+          genColValues.add(pair)
+        }
+      } else if(isPersistable(element)) {
+        val spec = processField(element, nameOfColumn, i)
+        map[Pair(element, colVariableName)] = spec
+        val pair: Pair<Pair<String, TypeName>, String> = Pair(Pair(element.simpleName.toString(), variableClassType), colVariableName)
+        genColValues.add(pair)
+      }
     }
 
     return map
   }
 
+  /**
+   * generates field for the column type of this particular field
+   */
+  private fun processField(element: Element, nameOfColumn: String, i: Int): FieldSpec {
+    val colVariableName = "${element.simpleName}Column"
+    var variableClassType = element.toTypeName()
+    if (variableClassType.isPrimitive) variableClassType = variableClassType.box()
+    val parameterizedColumnTypeName = ParameterizedTypeName.get(
+        ClassName.get("promise.db", "Column"),
+        variableClassType)
+    val columnInitializer = getColumnInitializer(element, variableClassType)
+    return FieldSpec.builder(parameterizedColumnTypeName, colVariableName)
+        .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
+        .initializer(CodeBlock.of("""
+              new Column<${variableClassType}>("$nameOfColumn", $columnInitializer, ${i + 1})
+            """.trimIndent())
+        )
+        .build()
+  }
+
+  /**
+   * returns column type initializer for this column type
+   */
   private fun getColumnInitializer(element: Element, classTypeName: TypeName): String {
     var str = "Column.Type"
     if (classTypeName.isSameAs(Integer::class.java) ||
         classTypeName.isSameAs(Integer::class.java) ||
         classTypeName.isSameAs(Float::class.java) ||
         classTypeName.isSameAs(Double::class.java) ||
-       classTypeName.isSameAs(Boolean::class.java)) {
+        classTypeName.isSameAs(Boolean::class.java)) {
       str += ".INTEGER"
       if (element.getAnnotation(PrimaryKey::class.java) != null) {
         str += ".PRIMARY_KEY()"
@@ -101,7 +129,8 @@ class TableColumnPropsGenerator(
       } else {
         str += ".NULLABLE()"
       }
-    } else if (classTypeName.isSameAs(String::class.java)) {
+    }
+    else if (classTypeName.isSameAs(String::class.java)) {
       if (element.getAnnotation(promise.db.VarChar::class.java) != null) {
         str += ".VARCHAR"
         val annotation = element.getAnnotation(promise.db.VarChar::class.java)
@@ -114,7 +143,8 @@ class TableColumnPropsGenerator(
         } else {
           throw IllegalStateException("element ${element.simpleName} is annotated as varchar without length")
         }
-      } else {
+      }
+      else {
         if (element.getAnnotation(promise.db.Text::class.java) != null) {
           str += ".TEXT"
           val annotation = element.getAnnotation(promise.db.Text::class.java)
@@ -125,7 +155,8 @@ class TableColumnPropsGenerator(
           } else {
             throw IllegalStateException("element ${element.simpleName} is annotated as varchar without length")
           }
-        } else {
+        }
+        else {
           str += ".TEXT.NULLABLE()"
         }
       }
@@ -133,18 +164,17 @@ class TableColumnPropsGenerator(
     return str
   }
 
-  private fun filterPrimitiveElements(elements: List<Element>): List<Element> = elements.filter {
-
-    try {
-      it.toTypeName().isSameAs2(processingEnvironment, Integer::class.java) ||
-          it.toTypeName().isSameAs2(processingEnvironment, String::class.java) ||
-          it.toTypeName().isSameAs2(processingEnvironment, Float::class.java) ||
-          it.toTypeName().isSameAs2(processingEnvironment, Double::class.java) ||
-          it.toTypeName().isSameAs2(processingEnvironment, Boolean::class.java)
-    } catch (e: Throwable) {
-      processingEnvironment.messager.printMessage(Diagnostic.Kind.ERROR,
-          "FilterPrimitiveElement ${it.kind.name}: ${Arrays.toString(e.stackTrace)}")
-      false
-    }
+  private fun isPersistable(it: Element): Boolean = try {
+    it.toTypeName().isSameAs2(processingEnvironment, Integer::class.java) ||
+        it.toTypeName().isSameAs2(processingEnvironment, String::class.java) ||
+        it.toTypeName().isSameAs2(processingEnvironment, Float::class.java) ||
+        it.toTypeName().isSameAs2(processingEnvironment, Double::class.java) ||
+        it.toTypeName().isSameAs2(processingEnvironment, Boolean::class.java)
+  } catch (e: Throwable) {
+    processingEnvironment.messager.printMessage(Diagnostic.Kind.ERROR,
+        "isPersistable ${it.kind.name}: ${Arrays.toString(e.stackTrace)}")
+    false
   }
+
+
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/db/ompiler/DeserializerGenerator.kt b/compiler/src/main/java/promise/db/ompiler/TableDeserializerMethodGenerator.kt
similarity index 97%
rename from compiler/src/main/java/promise/db/ompiler/DeserializerGenerator.kt
rename to compiler/src/main/java/promise/db/ompiler/TableDeserializerMethodGenerator.kt
index 5c555ca..28c61a2 100644
--- a/compiler/src/main/java/promise/db/ompiler/DeserializerGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/TableDeserializerMethodGenerator.kt
@@ -19,10 +19,10 @@ import com.squareup.javapoet.MethodSpec
 import com.squareup.javapoet.TypeName
 import javax.lang.model.element.Modifier
 
-class DeserializerGenerator(
+class TableDeserializerMethodGenerator(
     private val typeDataTypePack: String,
     private val typeDataType: String,
-    private val columns: List<Pair<Pair<String, TypeName>, String>>) : CodeBlockGenerator<MethodSpec> {
+    private val columns: List<Pair<Pair<String, TypeName>, String>>) : CodeGenerator<MethodSpec> {
 
   init {
     //fileSpec.addImport(ClassName("android.database", "Cursor"))
diff --git a/compiler/src/main/java/promise/db/ompiler/RegisterColumnsGenerator.kt b/compiler/src/main/java/promise/db/ompiler/TableRegisteredColumnsMethodGenerator.kt
similarity index 89%
rename from compiler/src/main/java/promise/db/ompiler/RegisterColumnsGenerator.kt
rename to compiler/src/main/java/promise/db/ompiler/TableRegisteredColumnsMethodGenerator.kt
index 2ba173c..ec11918 100644
--- a/compiler/src/main/java/promise/db/ompiler/RegisterColumnsGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/TableRegisteredColumnsMethodGenerator.kt
@@ -20,14 +20,11 @@ import com.squareup.javapoet.ParameterizedTypeName
 import com.squareup.javapoet.TypeName
 import com.squareup.javapoet.WildcardTypeName
 import org.jetbrains.annotations.NotNull
-import java.lang.reflect.Type
 import javax.lang.model.element.Modifier
-import javax.lang.model.type.TypeVariable
-import javax.lang.model.type.WildcardType
 
 
-class RegisterColumnsGenerator(
-    private val columns: List<String>) : CodeBlockGenerator<MethodSpec> {
+class TableRegisteredColumnsMethodGenerator(
+    private val columns: List<String>) : CodeGenerator<MethodSpec> {
   init {
     //fileSpec.addImport("promise.commons.model", "List")
   }
diff --git a/compiler/src/main/java/promise/db/ompiler/SerializerGenerator.kt b/compiler/src/main/java/promise/db/ompiler/TableSerializerMethodGenerator.kt
similarity index 96%
rename from compiler/src/main/java/promise/db/ompiler/SerializerGenerator.kt
rename to compiler/src/main/java/promise/db/ompiler/TableSerializerMethodGenerator.kt
index abe6046..98aebf8 100644
--- a/compiler/src/main/java/promise/db/ompiler/SerializerGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/TableSerializerMethodGenerator.kt
@@ -20,10 +20,10 @@ import com.squareup.javapoet.TypeName
 import javax.lang.model.element.Modifier
 
 
-class SerializerGenerator(
+class TableSerializerMethodGenerator(
     private val typeDataTypePack: String,
     private val typeDataType: String,
-    private val columns: List<Pair<Pair<String, TypeName>, String>>) : CodeBlockGenerator<MethodSpec> {
+    private val columns: List<Pair<Pair<String, TypeName>, String>>) : CodeGenerator<MethodSpec> {
   init {
    // fileSpec.addImport("android.content", "ContentValues")
   }
diff --git a/compiler/src/main/java/promise/db/ompiler/TypeConverterProcessor.kt b/compiler/src/main/java/promise/db/ompiler/TypeConverterProcessor.kt
new file mode 100644
index 0000000..ce5e424
--- /dev/null
+++ b/compiler/src/main/java/promise/db/ompiler/TypeConverterProcessor.kt
@@ -0,0 +1,119 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db.ompiler
+
+import com.squareup.javapoet.ClassName
+import com.squareup.javapoet.CodeBlock
+import com.squareup.javapoet.FieldSpec
+import com.squareup.javapoet.JavaFile
+import com.squareup.javapoet.MethodSpec
+import com.squareup.javapoet.ParameterizedTypeName
+import com.squareup.javapoet.TypeSpec
+import promise.db.TypeConverter
+import java.util.*
+import javax.annotation.processing.ProcessingEnvironment
+import javax.annotation.processing.RoundEnvironment
+import javax.lang.model.element.Modifier
+import javax.lang.model.element.TypeElement
+import javax.tools.Diagnostic
+
+fun TypeElement.getTypeConverterClassName(): String {
+  val className = this.simpleName.toString()
+  return "${className}Holder"
+}
+
+fun TypeElement.getVariableName(): String {
+  val className = this.simpleName.toString()
+  return className.camelCase();
+}
+
+class TypeConverterProcessor(private val processingEnv: ProcessingEnvironment) : ClassProcessor() {
+
+  override fun process(environment: RoundEnvironment?): List<JavaFile.Builder?>? {
+    val typeConverters = environment?.getElementsAnnotatedWith(TypeConverter::class.java)
+    if (typeConverters != null) {
+      if (typeConverters.size > 1) processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "There can only be one typeConverter in the module")
+      else try {
+        typeConverter = typeConverters.firstOrNull() as TypeElement
+        return Collections.singletonList(processElement(typeConverter!!))
+      } catch (e: Throwable) {
+
+      }
+    }
+    return null
+  }
+
+  private fun processElement(element: TypeElement): JavaFile.Builder {
+    val className = element.simpleName.toString()
+    val pack = processingEnv.elementUtils.getPackageOf(element).toString()
+
+    val fileName = element.getTypeConverterClassName()
+
+    val varName = element.getVariableName()
+
+    val classBuilder = TypeSpec.classBuilder(fileName)
+        .addJavadoc("""
+          Class holder for instantiation of TypeConverter
+        """.trimIndent())
+        .addModifiers(Modifier.FINAL, Modifier.PUBLIC)
+        .addSuperinterface(ParameterizedTypeName.get(
+            ClassName.get("promise.commons", "InstanceProvider"),
+            ClassName.get(pack, className)
+        ))
+        // field instance for the holder
+        .addField(FieldSpec.builder(
+            ClassName.get(pack, fileName),
+            "instance"
+        ).addModifiers(Modifier.PRIVATE, Modifier.STATIC)
+            .build())
+        // holder for type converter
+        .addField(FieldSpec.builder(element.toTypeName(), varName,
+            Modifier.FINAL, Modifier.PRIVATE)
+            .addJavadoc("""
+              holder instance for the TypeConverter
+            """.trimIndent())
+            .build())
+        // constructor for the holder
+        .addMethod(MethodSpec.constructorBuilder()
+            .addModifiers(Modifier.PRIVATE)
+            .addParameter(ClassName.get(pack, className), varName)
+            .addStatement("this.$varName = $varName")
+            .build())
+        .addMethod(MethodSpec.methodBuilder("create")
+            .returns(ClassName.get(pack, fileName))
+            .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
+            .addParameter(
+                ClassName.get(pack, className),
+                varName)
+            .addCode(CodeBlock.builder()
+                .addStatement("if (instance == null) instance = new $fileName($varName)")
+                .addStatement("return instance")
+                .build())
+            .build())
+        .addMethod(MethodSpec.methodBuilder("get")
+            .addAnnotation(Override::class.java)
+            .returns(ClassName.get(pack, className))
+            .addModifiers(Modifier.PUBLIC)
+            .addCode("return $varName;")
+            .build())
+
+
+    return JavaFile.builder(pack, classBuilder.build())
+  }
+
+  companion object {
+    var typeConverter: TypeElement? = null
+
+  }
+}
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/db/ompiler/Utils.kt b/compiler/src/main/java/promise/db/ompiler/Utils.kt
index 3e7ebf1..323ee3e 100644
--- a/compiler/src/main/java/promise/db/ompiler/Utils.kt
+++ b/compiler/src/main/java/promise/db/ompiler/Utils.kt
@@ -82,6 +82,7 @@ fun TypeMirror.asTypeElement(processingEnv: ProcessingEnvironment): TypeElement
   }) as TypeElement
 }
 
+
 object Utils {
 
   fun getAnnotationMirror(typeElement: TypeElement, clazz: Class<*>): AnnotationMirror? {
diff --git a/compiler/src/test/java/promise/db/ompiler/PersistableEntityUtilsKtTest.kt b/compiler/src/test/java/promise/db/ompiler/PersistableEntityUtilsKtTest.kt
new file mode 100644
index 0000000..c7dd218
--- /dev/null
+++ b/compiler/src/test/java/promise/db/ompiler/PersistableEntityUtilsKtTest.kt
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db.ompiler
+
+import org.junit.After
+import org.junit.Before
+
+import org.junit.Assert.*
+
+class PersistableEntityUtilsKtTest {
+
+  @Before
+  fun setUp() {
+  }
+
+  @After
+  fun tearDown() {
+  }
+}
\ No newline at end of file
diff --git a/database/build.gradle b/database/build.gradle
index cfb8e80..a6478c7 100644
--- a/database/build.gradle
+++ b/database/build.gradle
@@ -13,7 +13,6 @@
 
 apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
-
 apply plugin: 'com.github.dcendents.android-maven'
 
 android {

From 761913a73347b35d1bd193889eac3fd5823b9a92 Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Mon, 3 Aug 2020 06:37:45 +0300
Subject: [PATCH 02/34] Type converter complete

---
 .../promise/db/ompiler/EntityProcessor.kt     | 23 +++++++--
 .../java/promise/db/ompiler/JavaUtils.java    | 26 +++++++++-
 .../db/ompiler/PersistableEntityUtils.kt      | 28 +++++++++++
 .../db/ompiler/PromiseDatabaseCompiler.kt     | 10 ++--
 .../db/ompiler/TableColumnFieldsGenerator.kt  | 50 +++++++++++++------
 .../TableDeserializerMethodGenerator.kt       | 16 +++++-
 .../ompiler/TableSerializerMethodGenerator.kt | 20 ++++++--
 .../src/main/java/promise/db/ompiler/Utils.kt | 39 +--------------
 8 files changed, 146 insertions(+), 66 deletions(-)

diff --git a/compiler/src/main/java/promise/db/ompiler/EntityProcessor.kt b/compiler/src/main/java/promise/db/ompiler/EntityProcessor.kt
index 6afad03..63c810e 100644
--- a/compiler/src/main/java/promise/db/ompiler/EntityProcessor.kt
+++ b/compiler/src/main/java/promise/db/ompiler/EntityProcessor.kt
@@ -20,6 +20,7 @@ import com.squareup.javapoet.FieldSpec
 import com.squareup.javapoet.JavaFile
 import com.squareup.javapoet.MethodSpec
 import com.squareup.javapoet.ParameterizedTypeName
+import com.squareup.javapoet.TypeName
 import com.squareup.javapoet.TypeSpec
 import org.jetbrains.annotations.NotNull
 import promise.db.Entity
@@ -81,7 +82,10 @@ class EntityProcessor(private val processingEnv: ProcessingEnvironment) : ClassP
 
     classBuilder.addAnnotation(tableAnnotationSpec)
 
-    if (Utils.elementExtendsSuperClass((element as TypeElement), "promise.db.ActiveRecord"))
+    val activeRecordType = processingEnv.typeUtils.erasure(
+        processingEnv.elementUtils.getTypeElement("promise.db.ActiveRecord").asType())
+
+    if (JavaUtils.isSubtypeOfType((element as TypeElement).asType(), TypeName.get(activeRecordType)))
       classBuilder.addMethod(MethodSpec.methodBuilder("createEntityInstance")
           .addAnnotation(Override::class.java)
           .addAnnotation(NotNull::class.java)
@@ -93,6 +97,19 @@ class EntityProcessor(private val processingEnv: ProcessingEnvironment) : ClassP
     // static column block generation
     val tableColumnPropsGenerator = TableColumnFieldsGenerator(processingEnv, element.enclosedElements)
 
+    if (element.checkIfNeedsTypeConverter()) {
+      classBuilder.addField(FieldSpec.builder(TypeName.get(TypeConverterProcessor
+          .typeConverter!!.asType()), "typeConverter")
+          .addModifiers(Modifier.PRIVATE)
+          .build())
+      classBuilder.addMethod(MethodSpec.methodBuilder("setTypeConverter")
+          .addModifiers(Modifier.PUBLIC)
+          .addParameter(TypeName.get(TypeConverterProcessor
+              .typeConverter!!.asType()), "typeConverter")
+          .addStatement("this.typeConverter = typeConverter")
+          .build())
+    }
+
     val idColumnSpec = FieldSpec.builder(
         ParameterizedTypeName.get(
             ClassName.get("promise.db", "Column"),
@@ -124,11 +141,11 @@ class EntityProcessor(private val processingEnv: ProcessingEnvironment) : ClassP
     classBuilder.addMethod(columnRegSpecGenerator.generate())
 
     // serializer generator
-    val serializerGenerator = TableSerializerMethodGenerator(pack, className, tableColumnPropsGenerator.genColValues)
+    val serializerGenerator = TableSerializerMethodGenerator(processingEnv, pack, className, tableColumnPropsGenerator.genColValues)
     classBuilder.addMethod(serializerGenerator.generate())
 
     // deserializer generator
-    val deserializerGenerator = TableDeserializerMethodGenerator(pack, className,
+    val deserializerGenerator = TableDeserializerMethodGenerator(processingEnv, pack, className,
         tableColumnPropsGenerator.genColValues)
     classBuilder.addMethod(deserializerGenerator.generate())
 
diff --git a/compiler/src/main/java/promise/db/ompiler/JavaUtils.java b/compiler/src/main/java/promise/db/ompiler/JavaUtils.java
index 6e3429a..7fcd2e9 100644
--- a/compiler/src/main/java/promise/db/ompiler/JavaUtils.java
+++ b/compiler/src/main/java/promise/db/ompiler/JavaUtils.java
@@ -61,7 +61,22 @@ public static void generateIfStatementObtainClassString(
       CodeBlock.Builder codeBlock,
       TypeElement entity) {
     String pack = processingEnv.getElementUtils().getPackageOf(entity).toString();
-    codeBlock.addStatement("if (entityClass == $T.class) return getDatabaseInstance().obtain($T.class)",
+    if (PersistableEntityUtilsKt.checkIfNeedsTypeConverter(entity)) {
+      String tableVarName = PersistableEntityUtilsKt.camelCase(PersistableEntityUtilsKt.getClassName(entity));
+      String stmt = "if (entityClass == Exam.class) {\n" +
+          "      ExamsTable examsTable = getDatabaseInstance().obtain(ExamsTable.class);\n" +
+          "      examsTable.setTypeConverter(typeConverter);\n" +
+          "      return (FastTable<T>) examsTable;\n" +
+          "    }";
+      codeBlock.beginControlFlow("if (entityClass == $T.class)", ClassName.get(pack, entity.getSimpleName().toString()));
+      codeBlock.addStatement("$T "+tableVarName+" = getDatabaseInstance().obtain($T.class)",
+          ClassName.get(pack, PersistableEntityUtilsKt.getClassName(entity)),
+          ClassName.get(pack, PersistableEntityUtilsKt.getClassName(entity)));
+      codeBlock.addStatement(tableVarName + ".setTypeConverter(typeConverter)");
+      codeBlock.addStatement("return (FastTable<T>) "+tableVarName);
+      codeBlock.endControlFlow();
+    }
+    else codeBlock.addStatement("if (entityClass == $T.class) return getDatabaseInstance().obtain($T.class)",
         ClassName.get(pack, entity.getSimpleName().toString()),
         ClassName.get(pack, PersistableEntityUtilsKt.getClassName(entity)));
   }
@@ -82,10 +97,17 @@ public static TypeElement getSuperClass(TypeElement typeElement) {
   }
 
   static boolean isTypeEqual(TypeMirror typeMirror, TypeName otherType) {
+    if (typeMirror.getKind() == TypeKind.NONE || otherType == TypeName.VOID ||
+    typeMirror.getKind() == TypeKind.VOID) {
+      return false;
+    }
     return otherType.toString().equals(TypeName.get(typeMirror).toString());
   }
 
   static boolean isSubtypeOfType(TypeMirror typeMirror, TypeName otherType) {
+    if (typeMirror.getKind() == TypeKind.NONE) {
+      return false;
+    }
     if (isTypeEqual(typeMirror, otherType)) {
       return true;
     }
@@ -104,7 +126,7 @@ static boolean isSubtypeOfType(TypeMirror typeMirror, TypeName otherType) {
         typeString.append('?');
       }
       typeString.append('>');
-      if (typeString.toString().equals(otherType)) {
+      if (typeString.toString().equals(otherType.toString())) {
         return true;
       }
     }
diff --git a/compiler/src/main/java/promise/db/ompiler/PersistableEntityUtils.kt b/compiler/src/main/java/promise/db/ompiler/PersistableEntityUtils.kt
index 99c5872..5d10dca 100644
--- a/compiler/src/main/java/promise/db/ompiler/PersistableEntityUtils.kt
+++ b/compiler/src/main/java/promise/db/ompiler/PersistableEntityUtils.kt
@@ -23,11 +23,15 @@ import promise.db.ForeignKey
 import promise.db.HasMany
 import promise.db.HasOne
 import promise.db.Index
+import promise.db.Text
+import promise.db.VarChar
 import java.io.IOException
+import java.util.*
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.ExecutableElement
 import javax.lang.model.element.TypeElement
+import javax.lang.model.type.TypeKind
 import javax.lang.model.type.TypeMirror
 import javax.lang.model.util.ElementFilter
 import javax.tools.Diagnostic
@@ -143,6 +147,12 @@ fun Element.getNameOfColumn(): String {
       this.getAnnotation(promise.db.VarChar::class.java) != null) {
     name = this.getAnnotation(promise.db.VarChar::class.java).columnName
   }
+  else if (this.getAnnotation(Text::class.java) != null) {
+    name = this.getAnnotation(Text::class.java).columnName
+  }
+  else if (this.getAnnotation(VarChar::class.java) != null) {
+    name = this.getAnnotation(VarChar::class.java).columnName
+  }
   if (name != null && name.isNotEmpty()) return name
   return this.simpleName.toString()
 }
@@ -155,6 +165,10 @@ fun String.capitalizeFirst(): String = this.replaceFirst(this.first(), this.firs
 
 fun String.camelCase(): String = this.replaceFirst(this.first(), this.first().toLowerCase())
 
+fun TypeElement.checkIfNeedsTypeConverter(): Boolean = ElementFilter.fieldsIn(this.enclosedElements).any {
+  it.checkIfHasTypeConverter()
+}
+
 fun Element.checkIfHasTypeConverter(): Boolean {
   //return true
   if (TypeConverterProcessor.typeConverter != null)
@@ -182,8 +196,10 @@ fun Element.getConverterCompatibleMethod(converterTypes: ConverterTypes): Execut
         ElementFilter.methodsIn(TypeConverterProcessor.typeConverter!!.enclosedElements)
             .filter { it.parameters.size == 1 }
     return methods.find {
+      if (this.asType().kind == TypeKind.VOID) return@find false
       when(converterTypes) {
         ConverterTypes.DESERIALIZER -> {
+
           JavaUtils.isTypeEqual(it.parameters[0].asType(), TypeName.get(String::class.java)) &&
               JavaUtils.isTypeEqual(it.returnType, TypeName.get(this.asType()))
         }
@@ -205,6 +221,7 @@ fun Element.getConverterCompatibleMethod(converterTypes: ConverterTypes, process
             .filter {
               it.parameters.size == 1 }
     return methods.find {
+      if (this.asType().kind == TypeKind.VOID) return@find false
 //      processingEnv.messager.printMessage(Diagnostic.Kind.NOTE, "Type converter: " +
 //          " method: ${it}, " +
 //          " returnType: ${TypeName.get(it.returnType)}" +
@@ -229,4 +246,15 @@ fun Element.isElementAnnotatedAsRelation(): Boolean {
   //return false
   return this.getAnnotation(HasMany::class.java) != null ||
      this.getAnnotation(HasOne::class.java) != null
+}
+
+ fun Element.isPersistable(): Boolean = try {
+  this.toTypeName().isSameAs(Integer::class.java) ||
+      this.toTypeName().isSameAs(String::class.java) ||
+      this.toTypeName().isSameAs(Float::class.java) ||
+      this.toTypeName().isSameAs(Double::class.java) ||
+      this.toTypeName().isSameAs(Boolean::class.java)
+} catch (e: Throwable) {
+
+  false
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt b/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt
index 9ffa645..91863f4 100644
--- a/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt
+++ b/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt
@@ -33,7 +33,7 @@ import kotlin.collections.ArrayList
 
 @AutoService(Processor::class) // For registering the service
 @IncrementalAnnotationProcessor(IncrementalAnnotationProcessorType.DYNAMIC)
-@SupportedSourceVersion(SourceVersion.RELEASE_7) // to support Java 8
+@SupportedSourceVersion(SourceVersion.RELEASE_8) // to support Java 8
 @SupportedOptions(PromiseDatabaseCompiler.KAPT_JAVA_GENERATED_OPTION_NAME)
 class PromiseDatabaseCompiler : AbstractProcessor() {
 
@@ -78,9 +78,13 @@ class PromiseDatabaseCompiler : AbstractProcessor() {
       }
       return true
     } catch (e: Throwable) {
+      val stringBuilder = StringBuilder()
+      //stringBuilder.append(Utils.getStackTraceString(e))
+      //stringBuilder.append("\n")
+      stringBuilder.append("Trace: ").append(Arrays.toString(e.stackTrace))
       processingEnv.messager.printMessage(Diagnostic.Kind.ERROR,
-          //"EntityProcessor: ${Utils.getStackTraceString(e)} " +
-          "EntityProcessor Trace: ${Arrays.toString(e.stackTrace)}")
+          "EntityProcessor: $stringBuilder " )
+         // "EntityProcessor Trace: ${Arrays.toString(e.stackTrace)}")
       return false
     }
   }
diff --git a/compiler/src/main/java/promise/db/ompiler/TableColumnFieldsGenerator.kt b/compiler/src/main/java/promise/db/ompiler/TableColumnFieldsGenerator.kt
index 2ce4d86..d4eaecd 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableColumnFieldsGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/TableColumnFieldsGenerator.kt
@@ -53,8 +53,7 @@ class TableColumnFieldsGenerator(
       val colVariableName = "${element.simpleName}Column"
       var variableClassType = element.toTypeName()
       if (variableClassType.isPrimitive) variableClassType = variableClassType.box()
-      if (!isPersistable(element) && !element.isElementAnnotatedAsRelation()) {
-        val executableElement = element.getConverterCompatibleMethod(ConverterTypes.SERIALIZER)
+      if (!element.isPersistable() && !element.isElementAnnotatedAsRelation()) {
         if (element.checkIfHasTypeConverter(processingEnvironment)) {
           val parameterizedColumnTypeName = ParameterizedTypeName.get(
               ClassName.get("promise.db", "Column"),
@@ -68,10 +67,10 @@ class TableColumnFieldsGenerator(
               )
               .build()
           map[Pair(element, colVariableName)] = spec
-          val pair: Pair<Pair<String, TypeName>, String> = Pair(Pair(element.simpleName.toString(), TypeName.get(String::class.java)), colVariableName)
+          val pair: Pair<Pair<String, TypeName>, String> = Pair(Pair(element.simpleName.toString(), variableClassType), colVariableName)
           genColValues.add(pair)
         }
-      } else if(isPersistable(element)) {
+      } else if(element.isPersistable()) {
         val spec = processField(element, nameOfColumn, i)
         map[Pair(element, colVariableName)] = spec
         val pair: Pair<Pair<String, TypeName>, String> = Pair(Pair(element.simpleName.toString(), variableClassType), colVariableName)
@@ -161,20 +160,41 @@ class TableColumnFieldsGenerator(
         }
       }
     }
+    else {
+      if (element.getAnnotation(promise.db.VarChar::class.java) != null) {
+        str += ".VARCHAR"
+        val annotation = element.getAnnotation(promise.db.VarChar::class.java)
+        str += if (annotation.unique && annotation.length != 0) {
+          ".UNIQUE(${annotation.length})"
+        } else if (annotation.nullable && annotation.length != 0) {
+          ".NULLABLE(${annotation.length})"
+        } else if (!annotation.nullable && annotation.length != 0) {
+          ".NOT_NULL(${annotation.length})"
+        } else {
+          throw IllegalStateException("element ${element.simpleName} is annotated as varchar without length")
+        }
+      }
+      else {
+        if (element.getAnnotation(promise.db.Text::class.java) != null) {
+          str += ".TEXT"
+          val annotation = element.getAnnotation(promise.db.Text::class.java)
+          str += if (annotation.nullable) {
+            ".NULLABLE()"
+          } else if (!annotation.nullable) {
+            ".NOT_NULL()"
+          } else {
+            throw IllegalStateException("element ${element.simpleName} is annotated as varchar without length")
+          }
+        }
+        else {
+          str += ".TEXT.NULLABLE()"
+        }
+      }
+    }
     return str
   }
 
-  private fun isPersistable(it: Element): Boolean = try {
-    it.toTypeName().isSameAs2(processingEnvironment, Integer::class.java) ||
-        it.toTypeName().isSameAs2(processingEnvironment, String::class.java) ||
-        it.toTypeName().isSameAs2(processingEnvironment, Float::class.java) ||
-        it.toTypeName().isSameAs2(processingEnvironment, Double::class.java) ||
-        it.toTypeName().isSameAs2(processingEnvironment, Boolean::class.java)
-  } catch (e: Throwable) {
-    processingEnvironment.messager.printMessage(Diagnostic.Kind.ERROR,
-        "isPersistable ${it.kind.name}: ${Arrays.toString(e.stackTrace)}")
-    false
-  }
+
 
 
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/db/ompiler/TableDeserializerMethodGenerator.kt b/compiler/src/main/java/promise/db/ompiler/TableDeserializerMethodGenerator.kt
index 28c61a2..5b87176 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableDeserializerMethodGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/TableDeserializerMethodGenerator.kt
@@ -17,9 +17,12 @@ import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
 import com.squareup.javapoet.MethodSpec
 import com.squareup.javapoet.TypeName
+import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Modifier
+import javax.tools.Diagnostic
 
 class TableDeserializerMethodGenerator(
+    private val processingEnvironment: ProcessingEnvironment,
     private val typeDataTypePack: String,
     private val typeDataType: String,
     private val columns: List<Pair<Pair<String, TypeName>, String>>) : CodeGenerator<MethodSpec> {
@@ -70,7 +73,18 @@ class TableDeserializerMethodGenerator(
     if (varType.isSameAs(Boolean::class.java)) {
       return "  $objectName.set${varName.capitalizeFirst()}(e.${getCursorReturn(varType)}(${colName}.getIndex(e)) == 1);\n"
     }
-    return "  $objectName.set${varName.capitalizeFirst()}(e.${getCursorReturn(varType)}(${colName}.getIndex(e)));\n"
+
+    val typeElement = processingEnvironment.elementUtils.getTypeElement(varType.toString())
+    if (!typeElement.isPersistable()) {
+//      processingEnvironment.messager.printMessage(Diagnostic.Kind.ERROR,
+//          "deserializer Checking element:  $typeElement for typename $varType" )
+      val executableFn = typeElement.getConverterCompatibleMethod(ConverterTypes.DESERIALIZER)
+      if (executableFn != null) {
+        return "  $objectName.set${varName.capitalizeFirst()}(typeConverter.${executableFn.simpleName}(e.${getCursorReturn(TypeName.get(String::class.java))}(${colName}.getIndex(e))));\n"
+      }
+    }
+    else return "  $objectName.set${varName.capitalizeFirst()}(e.${getCursorReturn(varType)}(${colName}.getIndex(e)));\n"
+    throw Exception("Could not generate deserializer method for entity")
   }
 
   private fun getCursorReturn(varType: TypeName): String =//processingEnvironment.messager.printMessage(Diagnostic.Kind.ERROR, "type ${varType.toString()}")
diff --git a/compiler/src/main/java/promise/db/ompiler/TableSerializerMethodGenerator.kt b/compiler/src/main/java/promise/db/ompiler/TableSerializerMethodGenerator.kt
index 98aebf8..1ac5942 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableSerializerMethodGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/TableSerializerMethodGenerator.kt
@@ -17,16 +17,17 @@ import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
 import com.squareup.javapoet.MethodSpec
 import com.squareup.javapoet.TypeName
+import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Modifier
+import javax.tools.Diagnostic
 
 
 class TableSerializerMethodGenerator(
+    private val processingEnvironment: ProcessingEnvironment,
     private val typeDataTypePack: String,
     private val typeDataType: String,
     private val columns: List<Pair<Pair<String, TypeName>, String>>) : CodeGenerator<MethodSpec> {
-  init {
-   // fileSpec.addImport("android.content", "ContentValues")
-  }
+
 
   override fun generate(): MethodSpec {
 
@@ -58,7 +59,18 @@ class TableSerializerMethodGenerator(
     if (varTypeName.isSameAs(Boolean::class.java)) {
       return "values.put(${columnName}.getName(), t.is${typeVariable.capitalizeFirst()}() ? 1 : 0); \n"
     }
-    return "values.put(${columnName}.getName(), t.get${typeVariable.capitalizeFirst()}()); \n"
+
+    val typeElement = processingEnvironment.elementUtils.getTypeElement(varTypeName.toString())
+    if (!typeElement.isPersistable()) {
+//      processingEnvironment.messager.printMessage(Diagnostic.Kind.ERROR,
+//          "serializer Checking element: $typeElement for typeName $varTypeName " )
+      val executableFn = typeElement.getConverterCompatibleMethod(ConverterTypes.SERIALIZER)
+      if (executableFn != null) {
+        return "values.put(${columnName}.getName(), typeConverter.${executableFn.simpleName}(t.get${typeVariable.capitalizeFirst()}())); \n"
+      }
+    }
+    else return "values.put(${columnName}.getName(), t.get${typeVariable.capitalizeFirst()}()); \n"
+    throw Exception("Could not generate serializer method for entity")
   }
 
 
diff --git a/compiler/src/main/java/promise/db/ompiler/Utils.kt b/compiler/src/main/java/promise/db/ompiler/Utils.kt
index 323ee3e..29bfa37 100644
--- a/compiler/src/main/java/promise/db/ompiler/Utils.kt
+++ b/compiler/src/main/java/promise/db/ompiler/Utils.kt
@@ -35,7 +35,7 @@ import kotlin.reflect.KClass
 
 
 fun TypeName.isSameAs(javaClass: Class<*>): Boolean {
-  if (this.isPrimitive) this.box()
+  if (this.isPrimitive) return this.box().toString() == JavaUtils.wrap(javaClass).name
   return this.toString() == JavaUtils.wrap(javaClass).name
 }
 
@@ -114,43 +114,6 @@ object Utils {
     return null
   }
 
-  fun elementExtendsSuperClass(
-      classElement: TypeElement,
-      superClassCanonicalName: String): Boolean {
-    return classElement.superclass.toString() == superClassCanonicalName
-//    if (typeUtils.isSameType(classElement.superclass, superClass.asType())) return true
-//    //if (classElement.superclass == superClass.asType()) return true
-//    val objectType = processingEnv.elementUtils.getTypeElement("java.lang.Object").asType()
-//    var extends = false
-//    while (classElement.superclass != objectType) {
-//      extends = elementExtendsSuperClass(processingEnv, classElement.superclass.asTypeElement(processingEnv), superClass)
-//      if (extends) break
-//    }
-//    return extends
-
-  }
-
-  fun classImplementsInterface(classElement: TypeElement, interfaceElement: TypeElement): Boolean {
-    for (interfaceType in classElement.interfaces) {
-      if ((interfaceType as DeclaredType).asElement() == interfaceElement) return true
-    }
-    val classMethods: List<Element> = classElement.enclosedElements
-    var implementsMethod: Boolean
-    for (interfaceMethod in ElementFilter.methodsIn(interfaceElement.enclosedElements)) {
-      implementsMethod = false
-      for (classMethod in classMethods) {
-        if (interfaceMethod == classMethod) {
-          implementsMethod = true
-          break
-        }
-      }
-      if (!implementsMethod) {
-        return false
-      }
-    }
-    return false
-  }
-
   /**
    * Returns true if a and b are equal, including if they are both null.
    *

From 1f20286d65b6092d629c0a0c1747dd1506f0f89c Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Mon, 3 Aug 2020 13:09:20 +0300
Subject: [PATCH 03/34] Adding column for hasOne relationship

---
 .../src/main/java/promise/db/EntityInfo.kt    |  4 +-
 .../promise/db/ompiler/EntityProcessor.kt     |  8 +--
 .../java/promise/db/ompiler/JavaUtils.java    | 58 ++++++++++++++++-
 .../db/ompiler/PersistableEntityUtils.kt      |  2 +-
 .../db/ompiler/TableColumnFieldsGenerator.kt  | 41 ++++++++++--
 .../TableDeserializerMethodGenerator.kt       | 64 +++++++++++--------
 .../ompiler/TableSerializerMethodGenerator.kt | 56 +++++++++-------
 .../db/ompiler/TypeConverterProcessor.kt      |  2 +-
 .../src/main/java/promise/db/FastDatabase.kt  |  3 +-
 9 files changed, 170 insertions(+), 68 deletions(-)

diff --git a/commons/src/main/java/promise/db/EntityInfo.kt b/commons/src/main/java/promise/db/EntityInfo.kt
index 224b916..ae5ed39 100644
--- a/commons/src/main/java/promise/db/EntityInfo.kt
+++ b/commons/src/main/java/promise/db/EntityInfo.kt
@@ -64,11 +64,11 @@ annotation class ForeignKey(
 
 @Target(AnnotationTarget.FIELD)
 @Retention(AnnotationRetention.SOURCE)
-annotation class HasOne(val entity: KClass<*>)
+annotation class HasOne
 
 @Target(AnnotationTarget.FIELD)
 @Retention(AnnotationRetention.SOURCE)
-annotation class HasMany(val entity: KClass<*>)
+annotation class HasMany
 
 @Target(AnnotationTarget.FUNCTION)
 @Retention(AnnotationRetention.SOURCE)
diff --git a/compiler/src/main/java/promise/db/ompiler/EntityProcessor.kt b/compiler/src/main/java/promise/db/ompiler/EntityProcessor.kt
index 63c810e..cdede91 100644
--- a/compiler/src/main/java/promise/db/ompiler/EntityProcessor.kt
+++ b/compiler/src/main/java/promise/db/ompiler/EntityProcessor.kt
@@ -97,7 +97,7 @@ class EntityProcessor(private val processingEnv: ProcessingEnvironment) : ClassP
     // static column block generation
     val tableColumnPropsGenerator = TableColumnFieldsGenerator(processingEnv, element.enclosedElements)
 
-    if (element.checkIfNeedsTypeConverter()) {
+    if (element.checkIfAnyElementNeedsTypeConverter()) {
       classBuilder.addField(FieldSpec.builder(TypeName.get(TypeConverterProcessor
           .typeConverter!!.asType()), "typeConverter")
           .addModifiers(Modifier.PRIVATE)
@@ -122,11 +122,7 @@ class EntityProcessor(private val processingEnv: ProcessingEnvironment) : ClassP
     /**
      * private static final String TAG = LogUtil.makeTag(PersonFastTable.class);
      */
-    val tagSpec = FieldSpec.builder(
-        String::class.java, "TAG")
-        .addModifiers(Modifier.STATIC, Modifier.PRIVATE, Modifier.FINAL)
-        .initializer("promise.commons.data.log.LogUtil.makeTag(${element.getClassName()}.class)")
-        .build()
+    val tagSpec = JavaUtils.generateEntityTableLogField(element)
 
     classBuilder.addField(tagSpec)
 
diff --git a/compiler/src/main/java/promise/db/ompiler/JavaUtils.java b/compiler/src/main/java/promise/db/ompiler/JavaUtils.java
index 7fcd2e9..f92ecf3 100644
--- a/compiler/src/main/java/promise/db/ompiler/JavaUtils.java
+++ b/compiler/src/main/java/promise/db/ompiler/JavaUtils.java
@@ -15,10 +15,10 @@
 
 import com.squareup.javapoet.ClassName;
 import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.FieldSpec;
 import com.squareup.javapoet.MethodSpec;
 import com.squareup.javapoet.TypeName;
-
-import org.jetbrains.annotations.Nullable;
+import com.sun.tools.javac.jvm.Code;
 
 import java.util.HashMap;
 import java.util.List;
@@ -26,6 +26,7 @@
 
 import javax.annotation.processing.ProcessingEnvironment;
 import javax.lang.model.element.Element;
+import javax.lang.model.element.Modifier;
 import javax.lang.model.element.TypeElement;
 import javax.lang.model.type.DeclaredType;
 import javax.lang.model.type.TypeKind;
@@ -45,6 +46,15 @@ public class JavaUtils {
     put(void.class, Void.class);
   }};
 
+  public static FieldSpec generateEntityTableLogField(Element element) {
+    return FieldSpec.builder(
+        String.class, "TAG")
+        .addModifiers(Modifier.STATIC, Modifier.PRIVATE, Modifier.FINAL)
+        .initializer("$T.makeTag(" +element.getSimpleName() +".class)",
+            ClassName.get("promise.commons.data.log","LogUtil" ))
+        .build();
+  }
+
   public static void generateAddConverterStatementInDatabaseConstructorMethod(
       ProcessingEnvironment processingEnvironment,
       MethodSpec.Builder constructorMethod,
@@ -61,7 +71,7 @@ public static void generateIfStatementObtainClassString(
       CodeBlock.Builder codeBlock,
       TypeElement entity) {
     String pack = processingEnv.getElementUtils().getPackageOf(entity).toString();
-    if (PersistableEntityUtilsKt.checkIfNeedsTypeConverter(entity)) {
+    if (PersistableEntityUtilsKt.checkIfAnyElementNeedsTypeConverter(entity)) {
       String tableVarName = PersistableEntityUtilsKt.camelCase(PersistableEntityUtilsKt.getClassName(entity));
       String stmt = "if (entityClass == Exam.class) {\n" +
           "      ExamsTable examsTable = getDatabaseInstance().obtain(ExamsTable.class);\n" +
@@ -81,6 +91,48 @@ public static void generateIfStatementObtainClassString(
         ClassName.get(pack, PersistableEntityUtilsKt.getClassName(entity)));
   }
 
+  public static CodeBlock generateSerializerRelationPutStatement(Element element, String colName) {
+    CodeBlock.Builder codeBlock =  CodeBlock.builder();
+    String variableName = PersistableEntityUtilsKt.camelCase(element.getSimpleName().toString());
+    codeBlock.addStatement("$T "+ variableName+ " = t.get"+PersistableEntityUtilsKt.capitalizeFirst(element.getSimpleName().toString())+"()", TypeName.get(element.asType()));
+    codeBlock.beginControlFlow("if("+variableName+" != null)");
+    codeBlock.addStatement("values.put("+colName+".getName(), "+variableName+".getId())");
+    codeBlock.endControlFlow();
+    return codeBlock.build();
+  }
+
+  public static CodeBlock generateDeserializerRelationSetStatement(
+      String entitySetName,
+      Element element,
+      String colName) {
+    String gen = "" +
+        " int personId = e.getInt(personColumn.getIndex(e));\n" +
+        "      if (personId != 0) {\n" +
+        "        Person person = new Person();\n" +
+        "        person.setId(personId);\n" +
+        "        dog.setPerson(person);\n" +
+        "      }";
+    CodeBlock.Builder codeBlock =  CodeBlock.builder();
+    String variableName = PersistableEntityUtilsKt.camelCase(element.getSimpleName().toString());
+    String variableNameId = variableName + "Id";
+    codeBlock.addStatement("int "+ variableNameId+ " = e.getInt("+colName+".getIndex(e))");
+    codeBlock.beginControlFlow("if("+variableNameId+" != 0)");
+    codeBlock.addStatement("$T "+variableName+ " = new $T()",
+        TypeName.get(element.asType()),
+        TypeName.get(element.asType()));
+    codeBlock.addStatement(variableName + ".setId("+variableNameId+")");
+    codeBlock.addStatement(entitySetName+".set"+PersistableEntityUtilsKt.capitalizeFirst(element.getSimpleName().toString())+"("+variableName+")");
+    codeBlock.endControlFlow();
+    return codeBlock.build();
+  }
+
+  public static void generateCatchSQliteExceptionBlockForDeserializer(CodeBlock.Builder codeBlock, String typeDataType) {
+    codeBlock.beginControlFlow("catch($T ex)",
+        ClassName.get("android.database", "CursorIndexOutOfBoundsException"));
+    codeBlock.addStatement("LogUtil.e(TAG, \"deserialize\", ex)");
+    codeBlock.addStatement("return new "+typeDataType+"()");
+  }
+
   // safe because both Long.class and long.class are of type Class<Long>
   @SuppressWarnings("unchecked")
   public static <T> Class<T> wrap(Class<T> c) {
diff --git a/compiler/src/main/java/promise/db/ompiler/PersistableEntityUtils.kt b/compiler/src/main/java/promise/db/ompiler/PersistableEntityUtils.kt
index 5d10dca..039bce0 100644
--- a/compiler/src/main/java/promise/db/ompiler/PersistableEntityUtils.kt
+++ b/compiler/src/main/java/promise/db/ompiler/PersistableEntityUtils.kt
@@ -165,7 +165,7 @@ fun String.capitalizeFirst(): String = this.replaceFirst(this.first(), this.firs
 
 fun String.camelCase(): String = this.replaceFirst(this.first(), this.first().toLowerCase())
 
-fun TypeElement.checkIfNeedsTypeConverter(): Boolean = ElementFilter.fieldsIn(this.enclosedElements).any {
+fun TypeElement.checkIfAnyElementNeedsTypeConverter(): Boolean = ElementFilter.fieldsIn(this.enclosedElements).any {
   it.checkIfHasTypeConverter()
 }
 
diff --git a/compiler/src/main/java/promise/db/ompiler/TableColumnFieldsGenerator.kt b/compiler/src/main/java/promise/db/ompiler/TableColumnFieldsGenerator.kt
index d4eaecd..115a059 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableColumnFieldsGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/TableColumnFieldsGenerator.kt
@@ -18,6 +18,7 @@ import com.squareup.javapoet.CodeBlock
 import com.squareup.javapoet.FieldSpec
 import com.squareup.javapoet.ParameterizedTypeName
 import com.squareup.javapoet.TypeName
+import promise.db.HasOne
 import promise.db.Ignore
 import promise.db.PrimaryKey
 import promise.db.PrimaryKeyAutoIncrement
@@ -39,7 +40,7 @@ class TableColumnFieldsGenerator(
   /**
    *
    */
-  var genColValues: ArrayList<Pair<Pair<String, TypeName>, String>> = ArrayList()
+  var genColValues: ArrayList<Pair<Pair<String, Element>, String>> = ArrayList()
 
   override fun generate(): Map<Pair<Element, String>, FieldSpec> {
     val map = HashMap<Pair<Element, String>, FieldSpec>()
@@ -48,11 +49,14 @@ class TableColumnFieldsGenerator(
     }.forEachIndexed { i, element ->
       if (element.getAnnotation(PrimaryKeyAutoIncrement::class.java) != null ||
           element.getAnnotation(Ignore::class.java) != null) return@forEachIndexed
-      val nameOfColumn = element.getNameOfColumn()
+      var nameOfColumn = element.getNameOfColumn()
       if (nameOfColumn == "id") return@forEachIndexed
       val colVariableName = "${element.simpleName}Column"
       var variableClassType = element.toTypeName()
       if (variableClassType.isPrimitive) variableClassType = variableClassType.box()
+      /**
+       * For fields that need type converter
+       */
       if (!element.isPersistable() && !element.isElementAnnotatedAsRelation()) {
         if (element.checkIfHasTypeConverter(processingEnvironment)) {
           val parameterizedColumnTypeName = ParameterizedTypeName.get(
@@ -67,13 +71,40 @@ class TableColumnFieldsGenerator(
               )
               .build()
           map[Pair(element, colVariableName)] = spec
-          val pair: Pair<Pair<String, TypeName>, String> = Pair(Pair(element.simpleName.toString(), variableClassType), colVariableName)
+          val pair: Pair<Pair<String, Element>, String> = Pair(Pair(element.simpleName.toString(), element), colVariableName)
           genColValues.add(pair)
         }
-      } else if(element.isPersistable()) {
+       }
+      /**
+       * for fields marked as relation, additional column needs to be added
+       */
+      else if (element.isElementAnnotatedAsRelation()) {
+        val hasOneAnnotation = element.getAnnotation(HasOne::class.java)
+        if (hasOneAnnotation != null) {
+          nameOfColumn = "${element.simpleName}Id"
+          val parameterizedColumnTypeName = ParameterizedTypeName.get(
+              ClassName.get("promise.db", "Column"),
+              TypeName.get(Integer::class.java))
+          val columnInitializer = getColumnInitializer(element, ClassName.get(Integer::class.java))
+          val spec = FieldSpec.builder(parameterizedColumnTypeName, colVariableName)
+              .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
+              .initializer(CodeBlock.of("""
+              new Column<Integer>("$nameOfColumn", $columnInitializer, ${i + 1})
+            """.trimIndent())
+              )
+              .build()
+          map[Pair(element, colVariableName)] = spec
+          val pair: Pair<Pair<String, Element>, String> = Pair(Pair(element.simpleName.toString(), element), colVariableName)
+          genColValues.add(pair)
+        }
+      }
+      /**
+       * for normal persistable fields
+       */
+      else if(element.isPersistable()) {
         val spec = processField(element, nameOfColumn, i)
         map[Pair(element, colVariableName)] = spec
-        val pair: Pair<Pair<String, TypeName>, String> = Pair(Pair(element.simpleName.toString(), variableClassType), colVariableName)
+        val pair: Pair<Pair<String, Element>, String> = Pair(Pair(element.simpleName.toString(), element), colVariableName)
         genColValues.add(pair)
       }
     }
diff --git a/compiler/src/main/java/promise/db/ompiler/TableDeserializerMethodGenerator.kt b/compiler/src/main/java/promise/db/ompiler/TableDeserializerMethodGenerator.kt
index 5b87176..e0580e6 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableDeserializerMethodGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/TableDeserializerMethodGenerator.kt
@@ -18,6 +18,7 @@ import com.squareup.javapoet.CodeBlock
 import com.squareup.javapoet.MethodSpec
 import com.squareup.javapoet.TypeName
 import javax.annotation.processing.ProcessingEnvironment
+import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
 import javax.tools.Diagnostic
 
@@ -25,31 +26,27 @@ class TableDeserializerMethodGenerator(
     private val processingEnvironment: ProcessingEnvironment,
     private val typeDataTypePack: String,
     private val typeDataType: String,
-    private val columns: List<Pair<Pair<String, TypeName>, String>>) : CodeGenerator<MethodSpec> {
+    private val columns: List<Pair<Pair<String, Element>, String>>) : CodeGenerator<MethodSpec> {
 
   init {
     //fileSpec.addImport(ClassName("android.database", "Cursor"))
   }
 
   override fun generate(): MethodSpec {
+    val codeBlock = CodeBlock.builder()
     val varName = typeDataType.camelCase()
-    var stmt = """
-      try {
-        $typeDataType $varName = new $typeDataType();   
-
-    """.trimIndent()
+    codeBlock.beginControlFlow("try")
+    codeBlock.addStatement("$typeDataType $varName = new $typeDataType()")
     columns.forEach {
-      stmt += generateSetStatement(
+      generateSetStatement(
+          codeBlock,
           varName,
           it.first.first, it.first.second, it.second)
     }
-    stmt += """
-      return $varName;      
-    } catch(android.database.CursorIndexOutOfBoundsException ex) {
-      promise.commons.data.log.LogUtil.e(TAG, "deserialize", ex);
-      return new $typeDataType();
-    }
-    """.trimIndent()
+    codeBlock.addStatement("return $varName")
+    codeBlock.endControlFlow()
+    JavaUtils.generateCatchSQliteExceptionBlockForDeserializer(codeBlock, typeDataType)
+    codeBlock.endControlFlow()
 
     //fileSpec.addImport("android.database", "CursorIndexOutOfBoundsException")
 
@@ -58,7 +55,7 @@ class TableDeserializerMethodGenerator(
         .addAnnotation(Override::class.java)
         .addModifiers(Modifier.PUBLIC)
         .returns(ClassName.get(typeDataTypePack, typeDataType))
-        .addCode(CodeBlock.of(stmt))
+        .addCode(codeBlock.build())
         .build()
   }
 
@@ -66,25 +63,38 @@ class TableDeserializerMethodGenerator(
    * person.setAge(cursor.getInt(ageColumn.getIndex(cursor)));
    */
   private fun generateSetStatement(
+      codeBlock: CodeBlock.Builder,
       objectName: String,
       varName: String,
-      varType: TypeName,
-      colName: String): String {
-    if (varType.isSameAs(Boolean::class.java)) {
-      return "  $objectName.set${varName.capitalizeFirst()}(e.${getCursorReturn(varType)}(${colName}.getIndex(e)) == 1);\n"
+      varType: Element,
+      colName: String) {
+    if (varType.toTypeName().isSameAs(Boolean::class.java)) {
+      codeBlock.addStatement("$objectName.set${varName.capitalizeFirst()}(e.${getCursorReturn(varType.toTypeName())}(${colName}.getIndex(e)) == 1)")
+      return
     }
 
-    val typeElement = processingEnvironment.elementUtils.getTypeElement(varType.toString())
-    if (!typeElement.isPersistable()) {
-//      processingEnvironment.messager.printMessage(Diagnostic.Kind.ERROR,
-//          "deserializer Checking element:  $typeElement for typename $varType" )
-      val executableFn = typeElement.getConverterCompatibleMethod(ConverterTypes.DESERIALIZER)
+//    processingEnvironment.messager.printMessage(Diagnostic.Kind.ERROR,
+//         "deserializer Checking element:  $varType for typename $varType" )
+    if (varType.checkIfHasTypeConverter()) {
+
+      val executableFn = varType.getConverterCompatibleMethod(ConverterTypes.DESERIALIZER)
       if (executableFn != null) {
-        return "  $objectName.set${varName.capitalizeFirst()}(typeConverter.${executableFn.simpleName}(e.${getCursorReturn(TypeName.get(String::class.java))}(${colName}.getIndex(e))));\n"
+        codeBlock.addStatement("$objectName.set${varName.capitalizeFirst()}(typeConverter.${executableFn.simpleName}(e.${getCursorReturn(TypeName.get(String::class.java))}(${colName}.getIndex(e))))")
+      }
+    }
+    else if (varType.isElementAnnotatedAsRelation()) {
+      val gen = """
+        int personId = e.getInt(personColumn.getIndex(e));
+      if (personId != 0) {
+        Person person = new Person();
+        person.setId(personId);
+        dog.setPerson(person);
       }
+      """.trimIndent()
+      codeBlock.add(JavaUtils.generateDeserializerRelationSetStatement(objectName, varType, colName))
     }
-    else return "  $objectName.set${varName.capitalizeFirst()}(e.${getCursorReturn(varType)}(${colName}.getIndex(e)));\n"
-    throw Exception("Could not generate deserializer method for entity")
+    else codeBlock.addStatement("$objectName.set${varName.capitalizeFirst()}(e.${getCursorReturn(varType.toTypeName())}(${colName}.getIndex(e)))")
+    //throw Exception("Could not generate deserializer method for entity")
   }
 
   private fun getCursorReturn(varType: TypeName): String =//processingEnvironment.messager.printMessage(Diagnostic.Kind.ERROR, "type ${varType.toString()}")
diff --git a/compiler/src/main/java/promise/db/ompiler/TableSerializerMethodGenerator.kt b/compiler/src/main/java/promise/db/ompiler/TableSerializerMethodGenerator.kt
index 1ac5942..28f1b9e 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableSerializerMethodGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/TableSerializerMethodGenerator.kt
@@ -16,9 +16,10 @@ package promise.db.ompiler
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
 import com.squareup.javapoet.MethodSpec
-import com.squareup.javapoet.TypeName
 import javax.annotation.processing.ProcessingEnvironment
+import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
+import javax.lang.model.element.TypeElement
 import javax.tools.Diagnostic
 
 
@@ -26,28 +27,26 @@ class TableSerializerMethodGenerator(
     private val processingEnvironment: ProcessingEnvironment,
     private val typeDataTypePack: String,
     private val typeDataType: String,
-    private val columns: List<Pair<Pair<String, TypeName>, String>>) : CodeGenerator<MethodSpec> {
+    private val columns: List<Pair<Pair<String, Element>, String>>) : CodeGenerator<MethodSpec> {
 
 
   override fun generate(): MethodSpec {
 
-    var stmt =
-        "ContentValues values = new ContentValues();\n"
+    val codeBlock = CodeBlock.builder()
+
+    codeBlock.addStatement("ContentValues values = new ContentValues()")
+
     columns.forEach {
-      stmt += generatePutStatement(it.first.first, it.second, it.first.second)
+      generatePutStatement(codeBlock, it.first.first, it.second, it.first.second)
     }
-
-    stmt += """
-      return values;
-  
-    """.trimIndent()
+    codeBlock.addStatement("return values")
 
     return MethodSpec.methodBuilder("serialize")
         .addModifiers(Modifier.PUBLIC)
         .addParameter(ClassName.get(typeDataTypePack, typeDataType),"t")
         .addAnnotation(Override::class.java)
         .returns(ClassName.get("android.content", "ContentValues"))
-        .addCode(CodeBlock.of(stmt))
+        .addCode(codeBlock.build())
         .build()
   }
 
@@ -55,22 +54,35 @@ class TableSerializerMethodGenerator(
    * values.put(nameColumn.getName(), t.getName());
    * values.put(isAdultColumn.getName(), person.isAdult() ? 1 : 0);
    */
-  private fun generatePutStatement(typeVariable: String, columnName: String, varTypeName: TypeName): String {
-    if (varTypeName.isSameAs(Boolean::class.java)) {
-      return "values.put(${columnName}.getName(), t.is${typeVariable.capitalizeFirst()}() ? 1 : 0); \n"
+  private fun generatePutStatement(
+      codeBlock: CodeBlock.Builder,
+      typeVariable: String, columnName: String, varTypeName: Element) {
+    if (varTypeName.toTypeName().isSameAs(Boolean::class.java)) {
+      codeBlock.addStatement("values.put(${columnName}.getName(), t.is${typeVariable.capitalizeFirst()}() ? 1 : 0)")
+      return
     }
 
-    val typeElement = processingEnvironment.elementUtils.getTypeElement(varTypeName.toString())
-    if (!typeElement.isPersistable()) {
-//      processingEnvironment.messager.printMessage(Diagnostic.Kind.ERROR,
-//          "serializer Checking element: $typeElement for typeName $varTypeName " )
-      val executableFn = typeElement.getConverterCompatibleMethod(ConverterTypes.SERIALIZER)
+    if (varTypeName.checkIfHasTypeConverter()) {
+
+      val executableFn = varTypeName.getConverterCompatibleMethod(ConverterTypes.SERIALIZER)
       if (executableFn != null) {
-        return "values.put(${columnName}.getName(), typeConverter.${executableFn.simpleName}(t.get${typeVariable.capitalizeFirst()}())); \n"
+        codeBlock.addStatement("values.put(${columnName}.getName(), typeConverter.${executableFn.simpleName}(t.get${typeVariable.capitalizeFirst()}()))")
       }
     }
-    else return "values.put(${columnName}.getName(), t.get${typeVariable.capitalizeFirst()}()); \n"
-    throw Exception("Could not generate serializer method for entity")
+    else if (varTypeName.isElementAnnotatedAsRelation()) {
+//            processingEnvironment.messager.printMessage(Diagnostic.Kind.ERROR,
+//         "serializer Checking element: $varTypeName for typeName $varTypeName " )
+      val gen = """
+         Person person = t.getPerson();
+          if (person != null) {
+            values.put(personColumn.getName(), person.getId());
+          }    
+      """.trimIndent()
+      codeBlock.add(JavaUtils.generateSerializerRelationPutStatement(varTypeName, columnName))
+      //return "values.put(${columnName}.getName(), t.get${typeVariable.capitalizeFirst()}()); \n"
+    }
+    else codeBlock.addStatement("values.put(${columnName}.getName(), t.get${typeVariable.capitalizeFirst()}())")
+    //throw Exception("Could not generate serializer method for entity")
   }
 
 
diff --git a/compiler/src/main/java/promise/db/ompiler/TypeConverterProcessor.kt b/compiler/src/main/java/promise/db/ompiler/TypeConverterProcessor.kt
index ce5e424..d10ccc5 100644
--- a/compiler/src/main/java/promise/db/ompiler/TypeConverterProcessor.kt
+++ b/compiler/src/main/java/promise/db/ompiler/TypeConverterProcessor.kt
@@ -30,7 +30,7 @@ import javax.tools.Diagnostic
 
 fun TypeElement.getTypeConverterClassName(): String {
   val className = this.simpleName.toString()
-  return "${className}Holder"
+  return "${className}InstanceProvider"
 }
 
 fun TypeElement.getVariableName(): String {
diff --git a/database/src/main/java/promise/db/FastDatabase.kt b/database/src/main/java/promise/db/FastDatabase.kt
index 1454538..fd6742e 100644
--- a/database/src/main/java/promise/db/FastDatabase.kt
+++ b/database/src/main/java/promise/db/FastDatabase.kt
@@ -85,7 +85,8 @@ open class FastDatabase internal constructor(
   final override fun onUpgrade(database: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
     LogUtil.d(TAG, "onUpgrade", oldVersion, newVersion)
     if (newVersion - oldVersion == 1)
-      onUpgradeDatabase(database, oldVersion, newVersion) else {
+      onUpgradeDatabase(database, oldVersion, newVersion)
+    else {
       var i = oldVersion
       while (i < newVersion) {
         onUpgradeDatabase(database, i, i + 1)

From c12932aa14e79642916988727e954263900a0d98 Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Mon, 3 Aug 2020 14:05:32 +0300
Subject: [PATCH 04/34] mended generating abstract funcs in database class

---
 .../DatabaseAbstractMethodsGenerator.kt       |  6 ++++
 .../ompiler/DatabaseStaticMethodsGenerator.kt | 29 +++++++------------
 .../promise/db/ompiler/EntityProcessor.kt     |  2 +-
 .../java/promise/db/ompiler/JavaUtils.java    |  8 +++++
 .../db/ompiler/PromiseDatabaseCompiler.kt     |  4 ++-
 ...tor.kt => TableMigrationFieldGenerator.kt} |  2 +-
 6 files changed, 29 insertions(+), 22 deletions(-)
 rename compiler/src/main/java/promise/db/ompiler/{DatabaseMigrationFieldGenerator.kt => TableMigrationFieldGenerator.kt} (99%)

diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseAbstractMethodsGenerator.kt b/compiler/src/main/java/promise/db/ompiler/DatabaseAbstractMethodsGenerator.kt
index 6d584c1..50848f4 100644
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseAbstractMethodsGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/DatabaseAbstractMethodsGenerator.kt
@@ -41,9 +41,15 @@ class DatabaseAbstractMethodsGenerator(
     val abstractFunctions = methods.filter {
       it.modifiers.contains(Modifier.ABSTRACT)
     }
+
     //if (abstractFunctions.isNullOrEmpty()) return null
     val funSpecs = ArrayList<MethodSpec>()
 
+    abstractFunctions.forEach {
+      funSpecs.add(MethodSpec.overriding(it)
+          .build())
+    }
+
     abstractFunctions.filter {
       it.parameters.isEmpty() && it.returnType.kind != TypeKind.VOID
     }.forEach { method ->
diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseStaticMethodsGenerator.kt b/compiler/src/main/java/promise/db/ompiler/DatabaseStaticMethodsGenerator.kt
index e375e40..60b3c59 100644
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseStaticMethodsGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/DatabaseStaticMethodsGenerator.kt
@@ -43,34 +43,25 @@ class DatabaseStaticMethodsGenerator(
 
     val entities = (element as TypeElement).getTableEntities(processingEnv)
 
+    val migrationCodeBlock = CodeBlock.builder()
 
-    var migrationInitialzer = """
-      return new Migration() {
-              @Override
-              public void onMigrate(FastDatabase database, android.database.sqlite.SQLiteDatabase sqLiteDatabase, int oldVersion, int newVersion) {
-    """.plus("\n").trimIndent()
+    migrationCodeBlock.beginControlFlow("return new Migration()")
+    JavaUtils.generateDatabaseMigrationOverrideControlBlock(migrationCodeBlock)
     entities.forEach {
       val migrationAnnoTation = it.getAnnotation(AddedEntity::class.java)
       if (migrationAnnoTation != null) {
-        migrationInitialzer += """
-          if (oldVersion == ${migrationAnnoTation.fromVersion} && newVersion == ${migrationAnnoTation.toVersion}) {
-            database.add(sqLiteDatabase, database.obtain(${it.getClassName()}.class));
-          } 
-          
-    """.trimIndent()
+        migrationCodeBlock.beginControlFlow("if (oldVersion == ${migrationAnnoTation.fromVersion} && newVersion == ${migrationAnnoTation.toVersion})")
+        migrationCodeBlock.addStatement("database.add(sqLiteDatabase, database.obtain(${it.getClassName()}.class))")
+        migrationCodeBlock.endControlFlow()
       }
     }
-
-
-    migrationInitialzer += """
-        }
-      };
-    """.trimIndent()
-
+    migrationCodeBlock.endControlFlow()
+    migrationCodeBlock.endControlFlow()
+    migrationCodeBlock.add(";")
     val migrationPropSpec = MethodSpec.methodBuilder("getMigration")
         .returns(ClassName.get("promise.db", "Migration"))
         .addModifiers(Modifier.PRIVATE, Modifier.STATIC)
-        .addCode(CodeBlock.of(migrationInitialzer))
+        .addCode(migrationCodeBlock.build())
         .build()
 
     typeSpec.addMethod(migrationPropSpec)
diff --git a/compiler/src/main/java/promise/db/ompiler/EntityProcessor.kt b/compiler/src/main/java/promise/db/ompiler/EntityProcessor.kt
index cdede91..42e36be 100644
--- a/compiler/src/main/java/promise/db/ompiler/EntityProcessor.kt
+++ b/compiler/src/main/java/promise/db/ompiler/EntityProcessor.kt
@@ -150,7 +150,7 @@ class EntityProcessor(private val processingEnv: ProcessingEnvironment) : ClassP
     columnSpecs.forEach {
       elemMap[it.key.first] = it.key.second
     }
-    val migrationGenerator = DatabaseMigrationFieldGenerator(elemMap)
+    val migrationGenerator = TableMigrationFieldGenerator(elemMap)
     val migrationFunc = migrationGenerator.generate()
     if (migrationFunc != null) classBuilder.addMethod(migrationFunc)
 
diff --git a/compiler/src/main/java/promise/db/ompiler/JavaUtils.java b/compiler/src/main/java/promise/db/ompiler/JavaUtils.java
index f92ecf3..c67dfb3 100644
--- a/compiler/src/main/java/promise/db/ompiler/JavaUtils.java
+++ b/compiler/src/main/java/promise/db/ompiler/JavaUtils.java
@@ -98,6 +98,9 @@ public static CodeBlock generateSerializerRelationPutStatement(Element element,
     codeBlock.beginControlFlow("if("+variableName+" != null)");
     codeBlock.addStatement("values.put("+colName+".getName(), "+variableName+".getId())");
     codeBlock.endControlFlow();
+    codeBlock.beginControlFlow("else");
+    codeBlock.addStatement("values.put("+colName+".getName(), 0)");
+    codeBlock.endControlFlow();
     return codeBlock.build();
   }
 
@@ -133,6 +136,11 @@ public static void generateCatchSQliteExceptionBlockForDeserializer(CodeBlock.Bu
     codeBlock.addStatement("return new "+typeDataType+"()");
   }
 
+  public static void generateDatabaseMigrationOverrideControlBlock(CodeBlock.Builder codeBlock) {
+    codeBlock.add("@Override \n");
+    codeBlock.beginControlFlow("public void onMigrate(FastDatabase database, $T sqLiteDatabase, int oldVersion, int newVersion)", ClassName.get("android.database.sqlite", "SQLiteDatabase"));
+  }
+
   // safe because both Long.class and long.class are of type Class<Long>
   @SuppressWarnings("unchecked")
   public static <T> Class<T> wrap(Class<T> c) {
diff --git a/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt b/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt
index 91863f4..d916dd1 100644
--- a/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt
+++ b/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt
@@ -69,7 +69,9 @@ class PromiseDatabaseCompiler : AbstractProcessor() {
                 See the License for the specific language governing permissions and
                 limitations under the License
                 
-                Code Resource https://github.com/android-promise
+                Resource https://github.com/android-promise
+                
+                Generated by Android Promise Database Compiler, do not modify
               
             """.trimIndent()
             )
diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseMigrationFieldGenerator.kt b/compiler/src/main/java/promise/db/ompiler/TableMigrationFieldGenerator.kt
similarity index 99%
rename from compiler/src/main/java/promise/db/ompiler/DatabaseMigrationFieldGenerator.kt
rename to compiler/src/main/java/promise/db/ompiler/TableMigrationFieldGenerator.kt
index 98fdc90..69200c0 100644
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseMigrationFieldGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/TableMigrationFieldGenerator.kt
@@ -24,7 +24,7 @@ import promise.db.Migrations
 import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
 
-class DatabaseMigrationFieldGenerator(
+class TableMigrationFieldGenerator(
     private val elements: Map<Element, String>) : CodeGenerator<MethodSpec?> {
   init {
     //fileSpec.addImport("android.content", "ContentValues")

From 18ce055be504ab7e30d0c1404d4c9c829f9c9dfd Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Tue, 4 Aug 2020 20:07:41 +0300
Subject: [PATCH 05/34] compiler relation daos

---
 commons/bin/main/promise/db/ColumnInfo.kt     |   1 -
 commons/bin/main/promise/db/EntityInfo.kt     |   7 +-
 .../src/main/java/promise/db/ColumnInfo.kt    |   2 -
 .../main/java/promise/db/DatabaseEntity.java  |   2 +
 .../src/main/java/promise/db/EntityInfo.kt    |  18 +-
 commons/src/main/java/promise/db/Table.java   |   3 +
 .../DatabaseCompanionPropsGenerator.kt        |  38 +-
 .../promise/db/ompiler/DatabaseProcessor.kt   |   4 +-
 .../db/ompiler/DeserializerGenerator.kt       |   2 +-
 .../promise/db/ompiler/EntityProcessor.kt     |   4 +-
 .../promise/db/ompiler/SerializerGenerator.kt |   4 +-
 .../db/ompiler/TableColumnPropsGenerator.kt   |  10 +-
 compiler/bin/main/promise/db/ompiler/Utils.kt |   2 +-
 .../ompiler/migration/MigrationGenerator.kt   |   1 +
 compiler/gradle.properties                    |   1 -
 compiler/src/main/AndroidManifest.xml         |   3 +-
 ...rocessor.kt => AnnotatedClassProcessor.kt} |   5 +-
 .../DatabaseAbstractMethodsGenerator.kt       |  34 +-
 .../db/ompiler/DatabaseAnnotationGenerator.kt |   4 +
 .../DatabaseCrudStubMethodsGenerator.kt       |   1 +
 ...kt => DatabaseEntityAnnotatedProcessor.kt} |  32 +-
 .../ompiler/DatabaseStaticMethodsGenerator.kt | 109 ++++-
 ...ocessor.kt => EntityAnnotatedProcessor.kt} |  63 ++-
 .../db/ompiler/PromiseDatabaseCompiler.kt     |  27 +-
 .../promise/db/ompiler/RelationsGenerator.kt  |  57 ---
 .../db/ompiler/TableAnnotationGenerator.java  |   3 +-
 .../db/ompiler/TableColumnFieldsGenerator.kt  |  43 +-
 .../TableDeserializerMethodGenerator.kt       |  17 +-
 .../ompiler/TableMigrationFieldGenerator.kt   |   7 +-
 .../TableRegisteredColumnsMethodGenerator.kt  |   3 +
 .../db/ompiler/TableRelationsGenerator.java   | 311 ++++++++++++
 .../ompiler/TableSerializerMethodGenerator.kt |  19 +-
 .../TypeConverterAnnotatedProcessor.kt        | 110 +++++
 .../db/ompiler/TypeConverterProcessor.kt      | 119 -----
 .../db/ompiler/{ => utils}/JavaUtils.java     | 158 ++++---
 .../{ => utils}/PersistableEntityUtils.kt     |  45 +-
 .../promise/db/ompiler/{ => utils}/Utils.kt   |  96 +++-
 .../promise/db/ompiler/ExampleUnitTest.kt     |   3 +-
 .../ompiler/PersistableEntityUtilsKtTest.kt   |   2 -
 .../promise/db/ExampleInstrumentedTest.java   |   2 +-
 database/src/main/AndroidManifest.xml         |   3 +-
 .../src/main/java/promise/db/ActiveRecord.kt  |   5 +-
 database/src/main/java/promise/db/Column.java |   2 +
 database/src/main/java/promise/db/Crud.kt     |   4 +-
 .../src/main/java/promise/db/FastDatabase.kt  | 440 ++---------------
 .../main/java/promise/db/FastDatabaseImpl.kt  | 443 ++++++++++++++++++
 .../promise/db/FastDatabaseOpenHelper.java    |   5 -
 .../src/main/java/promise/db/FastTable.kt     |  39 +-
 .../main/java/promise/db/PromiseDatabase.java |   3 +-
 .../src/main/java/promise/db/ReactiveCrud.kt  |   6 +-
 .../java/promise/db/ReactiveFastDatabase.kt   |  10 +-
 .../src/main/java/promise/db/TableCrud.kt     |   1 +
 .../src/main/java/promise/db/from/From.java   |   2 +-
 .../promise/db/projection/Projection.java     |   2 +-
 .../java/promise/model/IdentifiableList.java  |  10 +-
 .../test/java/promise/db/ExampleUnitTest.java |   2 +-
 56 files changed, 1437 insertions(+), 912 deletions(-)
 rename compiler/src/main/java/promise/db/ompiler/{ClassProcessor.kt => AnnotatedClassProcessor.kt} (80%)
 rename compiler/src/main/java/promise/db/ompiler/{DatabaseEntityProcessor.kt => DatabaseEntityAnnotatedProcessor.kt} (71%)
 rename compiler/src/main/java/promise/db/ompiler/{EntityProcessor.kt => EntityAnnotatedProcessor.kt} (70%)
 delete mode 100644 compiler/src/main/java/promise/db/ompiler/RelationsGenerator.kt
 create mode 100644 compiler/src/main/java/promise/db/ompiler/TableRelationsGenerator.java
 create mode 100644 compiler/src/main/java/promise/db/ompiler/TypeConverterAnnotatedProcessor.kt
 delete mode 100644 compiler/src/main/java/promise/db/ompiler/TypeConverterProcessor.kt
 rename compiler/src/main/java/promise/db/ompiler/{ => utils}/JavaUtils.java (56%)
 rename compiler/src/main/java/promise/db/ompiler/{ => utils}/PersistableEntityUtils.kt (89%)
 rename compiler/src/main/java/promise/db/ompiler/{ => utils}/Utils.kt (65%)
 create mode 100644 database/src/main/java/promise/db/FastDatabaseImpl.kt

diff --git a/commons/bin/main/promise/db/ColumnInfo.kt b/commons/bin/main/promise/db/ColumnInfo.kt
index 55f314c..483a6cd 100644
--- a/commons/bin/main/promise/db/ColumnInfo.kt
+++ b/commons/bin/main/promise/db/ColumnInfo.kt
@@ -85,7 +85,6 @@ annotation class Migrate(val fromVersion: Int,
                          val action: MigrationOptions)
 
 
-
 @Target(AnnotationTarget.FIELD)
 @Retention(AnnotationRetention.SOURCE)
 annotation class Migrations(val values: Array<Migrate>)
diff --git a/commons/bin/main/promise/db/EntityInfo.kt b/commons/bin/main/promise/db/EntityInfo.kt
index 03924dd..8b56d82 100644
--- a/commons/bin/main/promise/db/EntityInfo.kt
+++ b/commons/bin/main/promise/db/EntityInfo.kt
@@ -24,9 +24,9 @@ annotation class AddedEntity(val fromVersion: Int,
 @Retention(AnnotationRetention.SOURCE)
 annotation class Entity(val tableName: String = "",
                         /**
-                              * @return
-                              */
-                             val compoundIndices: Array<CompoundIndex> = []
+                         * @return
+                         */
+                        val compoundIndices: Array<CompoundIndex> = []
 ) {
   /**
    *
@@ -45,6 +45,7 @@ annotation class Entity(val tableName: String = "",
    */
 
 }
+
 @Target(AnnotationTarget.FIELD)
 @Retention(AnnotationRetention.SOURCE)
 annotation class Index
diff --git a/commons/src/main/java/promise/db/ColumnInfo.kt b/commons/src/main/java/promise/db/ColumnInfo.kt
index 788f778..551bc2e 100644
--- a/commons/src/main/java/promise/db/ColumnInfo.kt
+++ b/commons/src/main/java/promise/db/ColumnInfo.kt
@@ -12,8 +12,6 @@
  */
 package promise.db
 
-import kotlin.reflect.KClass
-
 @Target(AnnotationTarget.FIELD)
 @Retention(AnnotationRetention.SOURCE)
 annotation class VarChar(val columnName: String = "",
diff --git a/commons/src/main/java/promise/db/DatabaseEntity.java b/commons/src/main/java/promise/db/DatabaseEntity.java
index bad0ffb..c385ab5 100644
--- a/commons/src/main/java/promise/db/DatabaseEntity.java
+++ b/commons/src/main/java/promise/db/DatabaseEntity.java
@@ -22,6 +22,8 @@
 @Retention(RetentionPolicy.SOURCE)
 public @interface DatabaseEntity {
   int version() default 1;
+
   boolean generateCrudStubs() default false;
+
   Class<?>[] persistableEntities();
 }
diff --git a/commons/src/main/java/promise/db/EntityInfo.kt b/commons/src/main/java/promise/db/EntityInfo.kt
index ae5ed39..81e65ab 100644
--- a/commons/src/main/java/promise/db/EntityInfo.kt
+++ b/commons/src/main/java/promise/db/EntityInfo.kt
@@ -24,9 +24,9 @@ annotation class AddedEntity(val fromVersion: Int,
 @Retention(AnnotationRetention.SOURCE)
 annotation class Entity(val tableName: String = "",
                         /**
-                              * @return
-                              */
-                             val compoundIndices: Array<CompoundIndex> = []
+                         * @return
+                         */
+                        val compoundIndices: Array<CompoundIndex> = []
 ) {
   /**
    *
@@ -45,6 +45,7 @@ annotation class Entity(val tableName: String = "",
    */
 
 }
+
 @Target(AnnotationTarget.FIELD)
 @Retention(AnnotationRetention.SOURCE)
 annotation class Index
@@ -70,16 +71,5 @@ annotation class HasOne
 @Retention(AnnotationRetention.SOURCE)
 annotation class HasMany
 
-@Target(AnnotationTarget.FUNCTION)
-@Retention(AnnotationRetention.SOURCE)
-annotation class OneToMany(val parent: KClass<*>, val child: KClass<*>)
-
-@Target(AnnotationTarget.FUNCTION)
-@Retention(AnnotationRetention.SOURCE)
-annotation class OneToOne(val parent: KClass<*>, val child: KClass<*>)
-
-@Target(AnnotationTarget.FUNCTION)
-@Retention(AnnotationRetention.SOURCE)
-annotation class FindAll
 
 
diff --git a/commons/src/main/java/promise/db/Table.java b/commons/src/main/java/promise/db/Table.java
index 3dd1f02..513d2d7 100644
--- a/commons/src/main/java/promise/db/Table.java
+++ b/commons/src/main/java/promise/db/Table.java
@@ -33,6 +33,7 @@
    * @return
    */
   Index[] indices() default {};
+
   CompoundIndex[] compoundIndexes() default {};
 
   /**
@@ -50,6 +51,7 @@
      * @return
      */
     String columnName();
+
     ;
   }
 
@@ -60,6 +62,7 @@
   @Retention(RetentionPolicy.RUNTIME)
   @interface CompoundIndex {
     boolean unique() default false;
+
     Index[] indexes() default {};
   }
 
diff --git a/compiler/bin/main/promise/db/ompiler/DatabaseCompanionPropsGenerator.kt b/compiler/bin/main/promise/db/ompiler/DatabaseCompanionPropsGenerator.kt
index 2d2f0f6..a5702cc 100644
--- a/compiler/bin/main/promise/db/ompiler/DatabaseCompanionPropsGenerator.kt
+++ b/compiler/bin/main/promise/db/ompiler/DatabaseCompanionPropsGenerator.kt
@@ -45,15 +45,15 @@ class DatabaseCompanionPropsGenerator(
 
     /**
      * private static Migration getMigration() {
-            return new Migration() {
-              @Override
-              public void onMigrate(@NotNull FastDatabase database, @NotNull SQLiteDatabase sqLiteDatabase, int oldVersion, int newVersion) {
-                if (oldVersion == 2 && newVersion == 3) {
-                  database.add(sqLiteDatabase, database.obtain(PersonFastTable.class));
-                }
-              }
-            };
-          }
+    return new Migration() {
+    @Override
+    public void onMigrate(@NotNull FastDatabase database, @NotNull SQLiteDatabase sqLiteDatabase, int oldVersion, int newVersion) {
+    if (oldVersion == 2 && newVersion == 3) {
+    database.add(sqLiteDatabase, database.obtain(PersonFastTable.class));
+    }
+    }
+    };
+    }
      */
     var migrationInitialzer = """
       return new Migration() {
@@ -87,12 +87,12 @@ class DatabaseCompanionPropsGenerator(
     typeSpec.addMethod(migrationPropSpec)
     // adding db instance var
     // private static volatile FastDatabase instance = null;
-    typeSpec.addField(FieldSpec.builder(ClassName.get("promise.db", "FastDatabase"),"instance")
+    typeSpec.addField(FieldSpec.builder(ClassName.get("promise.db", "FastDatabase"), "instance")
         .initializer("null")
         .addModifiers(Modifier.PRIVATE)
         .build())
 
-    typeSpec.addField(FieldSpec.builder(Boolean::class.javaPrimitiveType,"initialized")
+    typeSpec.addField(FieldSpec.builder(Boolean::class.javaPrimitiveType, "initialized")
         .initializer("false")
         .addModifiers(Modifier.PRIVATE, Modifier.VOLATILE, Modifier.STATIC)
         .build())
@@ -107,7 +107,7 @@ class DatabaseCompanionPropsGenerator(
     //    }
     typeSpec.addMethod(MethodSpec.methodBuilder("createDatabase")
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
-        .addParameter(ClassName.get(String::class.java),"name")
+        .addParameter(ClassName.get(String::class.java), "name")
         .returns(ClassName.get(pack, className))
         .addCode(CodeBlock.of("""
           if (initialized) throw new IllegalStateException("Database already created");
@@ -119,8 +119,8 @@ class DatabaseCompanionPropsGenerator(
     // add with creation callback
     typeSpec.addMethod(MethodSpec.methodBuilder("createDatabase")
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
-        .addParameter(ClassName.get(String::class.java),"name")
-        .addParameter(ClassName.get("promise.db", "DatabaseCreationCallback"),"databaseCreationCallback")
+        .addParameter(ClassName.get(String::class.java), "name")
+        .addParameter(ClassName.get("promise.db", "DatabaseCreationCallback"), "databaseCreationCallback")
         .returns(ClassName.get(pack, className))
         .addCode(CodeBlock.of("""
           if (initialized) throw new IllegalStateException("Database already created");
@@ -147,7 +147,7 @@ class DatabaseCompanionPropsGenerator(
     // with in memory database
     typeSpec.addMethod(MethodSpec.methodBuilder("createInMemoryDatabase")
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
-        .addParameter(ClassName.get("promise.db", "DatabaseCreationCallback"),"databaseCreationCallback")
+        .addParameter(ClassName.get("promise.db", "DatabaseCreationCallback"), "databaseCreationCallback")
         .returns(ClassName.get(pack, className))
         .addCode(CodeBlock.of("""
           if (initialized) throw new IllegalStateException("Database already created");
@@ -174,7 +174,7 @@ class DatabaseCompanionPropsGenerator(
     // with callback
     typeSpec.addMethod(MethodSpec.methodBuilder("createReactiveInMemoryDatabase")
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
-        .addParameter(ClassName.get("promise.db", "DatabaseCreationCallback"),"databaseCreationCallback")
+        .addParameter(ClassName.get("promise.db", "DatabaseCreationCallback"), "databaseCreationCallback")
         .returns(ClassName.get(pack, className))
         .addCode(CodeBlock.of("""
           if (initialized) throw new IllegalStateException("Database already created");
@@ -192,7 +192,7 @@ class DatabaseCompanionPropsGenerator(
     //    }
     typeSpec.addMethod(MethodSpec.methodBuilder("createReactiveDatabase")
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
-        .addParameter(ClassName.get(String::class.java),"name")
+        .addParameter(ClassName.get(String::class.java), "name")
         .returns(ClassName.get(pack, className))
         .addCode(CodeBlock.of("""
           if (initialized) throw new IllegalStateException("Database already created");
@@ -204,8 +204,8 @@ class DatabaseCompanionPropsGenerator(
     // with creation callback
     typeSpec.addMethod(MethodSpec.methodBuilder("createReactiveDatabase")
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
-        .addParameter(ClassName.get(String::class.java),"name")
-        .addParameter(ClassName.get("promise.db", "DatabaseCreationCallback"),"databaseCreationCallback")
+        .addParameter(ClassName.get(String::class.java), "name")
+        .addParameter(ClassName.get("promise.db", "DatabaseCreationCallback"), "databaseCreationCallback")
         .returns(ClassName.get(pack, className))
         .addCode(CodeBlock.of("""
           if (initialized) throw new IllegalStateException("Database already created");
diff --git a/compiler/bin/main/promise/db/ompiler/DatabaseProcessor.kt b/compiler/bin/main/promise/db/ompiler/DatabaseProcessor.kt
index a5778f4..10b7850 100644
--- a/compiler/bin/main/promise/db/ompiler/DatabaseProcessor.kt
+++ b/compiler/bin/main/promise/db/ompiler/DatabaseProcessor.kt
@@ -66,7 +66,7 @@ class DatabaseProcessor(private val processingEnv: ProcessingEnvironment) {
         .addAnnotation(tableAnnotationSpec)
         .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
         .addMethod(MethodSpec.constructorBuilder()
-            .addParameter(ClassName.get("promise.db", "FastDatabase"),"instance")
+            .addParameter(ClassName.get("promise.db", "FastDatabase"), "instance")
             .addModifiers(Modifier.PRIVATE)
             .addStatement("super()")
             .addStatement("this.instance = instance")
@@ -140,7 +140,7 @@ class DatabaseProcessor(private val processingEnv: ProcessingEnvironment) {
             See the License for the specific language governing permissions and
             limitations under the License
             """.trimIndent()
-            )
+        )
         .build()
     //val kaptKotlinGeneratedDir = processingEnv.options[EntityProcessor.KAPT_JAVA_GENERATED_OPTION_NAME]!!
     file.writeTo(processingEnv.filer)
diff --git a/compiler/bin/main/promise/db/ompiler/DeserializerGenerator.kt b/compiler/bin/main/promise/db/ompiler/DeserializerGenerator.kt
index 0c4243f..bd7df96 100644
--- a/compiler/bin/main/promise/db/ompiler/DeserializerGenerator.kt
+++ b/compiler/bin/main/promise/db/ompiler/DeserializerGenerator.kt
@@ -48,7 +48,7 @@ class DeserializerGenerator(
     //fileSpec.addImport("android.database", "CursorIndexOutOfBoundsException")
 
     return MethodSpec.methodBuilder("deserialize")
-        .addParameter(ClassName.get("android.database", "Cursor"),"e")
+        .addParameter(ClassName.get("android.database", "Cursor"), "e")
         .addAnnotation(Override::class.java)
         .addModifiers(Modifier.PUBLIC)
         .returns(ClassName.get(typeDataTypePack, typeDataType))
diff --git a/compiler/bin/main/promise/db/ompiler/EntityProcessor.kt b/compiler/bin/main/promise/db/ompiler/EntityProcessor.kt
index ac8d399..b5e7e2c 100644
--- a/compiler/bin/main/promise/db/ompiler/EntityProcessor.kt
+++ b/compiler/bin/main/promise/db/ompiler/EntityProcessor.kt
@@ -68,7 +68,7 @@ class EntityProcessor : AbstractProcessor() {
 //            if (JavaUtils.implementsInterface(processingEnv, element as TypeElement, identifiableInterface.asType())) {
 //              processAnnotation(element)
 //            }
-             processAnnotation(element)
+            processAnnotation(element)
 //            else {
 //              processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "The Entity class ${element.simpleName} must implement Identifiable")
 //              return false
@@ -180,7 +180,7 @@ class EntityProcessor : AbstractProcessor() {
             See the License for the specific language governing permissions and
             limitations under the License
             """.trimIndent()
-            )
+        )
         .build()
         .writeTo(processingEnv.filer)
   }
diff --git a/compiler/bin/main/promise/db/ompiler/SerializerGenerator.kt b/compiler/bin/main/promise/db/ompiler/SerializerGenerator.kt
index 64a7be0..449207c 100644
--- a/compiler/bin/main/promise/db/ompiler/SerializerGenerator.kt
+++ b/compiler/bin/main/promise/db/ompiler/SerializerGenerator.kt
@@ -25,7 +25,7 @@ class SerializerGenerator(
     private val typeDataType: String,
     private val columns: List<Pair<Pair<String, TypeName>, String>>) : CodeBlockGenerator<MethodSpec> {
   init {
-   // fileSpec.addImport("android.content", "ContentValues")
+    // fileSpec.addImport("android.content", "ContentValues")
   }
 
   override fun generate(): MethodSpec {
@@ -43,7 +43,7 @@ class SerializerGenerator(
 
     return MethodSpec.methodBuilder("serialize")
         .addModifiers(Modifier.PUBLIC)
-        .addParameter(ClassName.get(typeDataTypePack, typeDataType),"t")
+        .addParameter(ClassName.get(typeDataTypePack, typeDataType), "t")
         .addAnnotation(Override::class.java)
         .returns(ClassName.get("android.content", "ContentValues"))
         .addCode(CodeBlock.of(stmt))
diff --git a/compiler/bin/main/promise/db/ompiler/TableColumnPropsGenerator.kt b/compiler/bin/main/promise/db/ompiler/TableColumnPropsGenerator.kt
index fdace1c..c32ad27 100644
--- a/compiler/bin/main/promise/db/ompiler/TableColumnPropsGenerator.kt
+++ b/compiler/bin/main/promise/db/ompiler/TableColumnPropsGenerator.kt
@@ -31,10 +31,10 @@ import kotlin.collections.ArrayList
 import kotlin.collections.HashMap
 
 class TableColumnPropsGenerator(
-                                private val classBuilder: TypeSpec.Builder,
-                                private val processingEnvironment: ProcessingEnvironment
-                                ,
-                                private val setElements: List<Element>) : CodeBlockGenerator<Map<Pair<Element, String>, FieldSpec>> {
+    private val classBuilder: TypeSpec.Builder,
+    private val processingEnvironment: ProcessingEnvironment
+    ,
+    private val setElements: List<Element>) : CodeBlockGenerator<Map<Pair<Element, String>, FieldSpec>> {
 
   var genColValues: ArrayList<Pair<Pair<String, TypeName>, String>> = ArrayList()
 
@@ -83,7 +83,7 @@ class TableColumnPropsGenerator(
         classTypeName.isSameAs(Integer::class.java) ||
         classTypeName.isSameAs(Float::class.java) ||
         classTypeName.isSameAs(Double::class.java) ||
-       classTypeName.isSameAs(Boolean::class.java)) {
+        classTypeName.isSameAs(Boolean::class.java)) {
       str += ".INTEGER"
       if (element.getAnnotation(PrimaryKey::class.java) != null) {
         str += ".PRIMARY_KEY()"
diff --git a/compiler/bin/main/promise/db/ompiler/Utils.kt b/compiler/bin/main/promise/db/ompiler/Utils.kt
index f3c4ba6..217f986 100644
--- a/compiler/bin/main/promise/db/ompiler/Utils.kt
+++ b/compiler/bin/main/promise/db/ompiler/Utils.kt
@@ -44,7 +44,7 @@ fun TypeName.isSameAs(javaClass: Class<*>): Boolean {
 
 fun TypeName.isSameAs2(processingEnvironment: ProcessingEnvironment, javaClass: Class<*>): Boolean {
   processingEnvironment.messager.printMessage(Diagnostic.Kind.OTHER, "comparing \n: elem typeName ${this}, javaClass: ${JavaUtils.wrap(javaClass).name}")
-  if (this.isPrimitive)  return this.box().toString() == JavaUtils.wrap(javaClass).name
+  if (this.isPrimitive) return this.box().toString() == JavaUtils.wrap(javaClass).name
   return this.toString() == JavaUtils.wrap(javaClass).name
 }
 
diff --git a/compiler/bin/main/promise/db/ompiler/migration/MigrationGenerator.kt b/compiler/bin/main/promise/db/ompiler/migration/MigrationGenerator.kt
index 22da0c2..7f3a5f3 100644
--- a/compiler/bin/main/promise/db/ompiler/migration/MigrationGenerator.kt
+++ b/compiler/bin/main/promise/db/ompiler/migration/MigrationGenerator.kt
@@ -60,6 +60,7 @@ class MigrationGenerator(
       codeBlock.add("}\n")
     }
   }
+
   private fun buildMigration(
       codeBlock: CodeBlock.Builder,
       column: String,
diff --git a/compiler/gradle.properties b/compiler/gradle.properties
index 25239fe..efdd2fc 100644
--- a/compiler/gradle.properties
+++ b/compiler/gradle.properties
@@ -10,7 +10,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-
 POM_NAME=Promise Database Compiler
 POM_ARTIFACT_ID=promise-db-compiler
 POM_PACKAGING=war
\ No newline at end of file
diff --git a/compiler/src/main/AndroidManifest.xml b/compiler/src/main/AndroidManifest.xml
index afb7daa..44905cb 100644
--- a/compiler/src/main/AndroidManifest.xml
+++ b/compiler/src/main/AndroidManifest.xml
@@ -11,5 +11,4 @@
   ~ limitations under the License.
   -->
 
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="promise.db.ompiler" />
+<manifest package="promise.db.ompiler" />
diff --git a/compiler/src/main/java/promise/db/ompiler/ClassProcessor.kt b/compiler/src/main/java/promise/db/ompiler/AnnotatedClassProcessor.kt
similarity index 80%
rename from compiler/src/main/java/promise/db/ompiler/ClassProcessor.kt
rename to compiler/src/main/java/promise/db/ompiler/AnnotatedClassProcessor.kt
index 4b02275..a1b2537 100644
--- a/compiler/src/main/java/promise/db/ompiler/ClassProcessor.kt
+++ b/compiler/src/main/java/promise/db/ompiler/AnnotatedClassProcessor.kt
@@ -14,9 +14,8 @@
 package promise.db.ompiler
 
 import com.squareup.javapoet.JavaFile
-import javax.annotation.processing.ProcessingEnvironment
 import javax.annotation.processing.RoundEnvironment
 
-abstract class ClassProcessor  {
-  abstract fun process( environment: RoundEnvironment?): List<JavaFile.Builder?>?
+abstract class AnnotatedClassProcessor {
+  abstract fun process(environment: RoundEnvironment?): List<JavaFile.Builder?>?
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseAbstractMethodsGenerator.kt b/compiler/src/main/java/promise/db/ompiler/DatabaseAbstractMethodsGenerator.kt
index 50848f4..bbe26d3 100644
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseAbstractMethodsGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/DatabaseAbstractMethodsGenerator.kt
@@ -20,6 +20,10 @@ import com.squareup.javapoet.ParameterizedTypeName
 import com.squareup.javapoet.TypeVariableName
 import com.squareup.javapoet.WildcardTypeName
 import org.jetbrains.annotations.NotNull
+import promise.db.ompiler.utils.JavaUtils
+import promise.db.ompiler.utils.asTypeElement
+import promise.db.ompiler.utils.getClassName
+import promise.db.ompiler.utils.getTableEntities
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.ExecutableElement
@@ -29,11 +33,11 @@ import javax.lang.model.type.TypeKind
 import javax.lang.model.util.ElementFilter
 import javax.tools.Diagnostic
 
+
 class DatabaseAbstractMethodsGenerator(
     private val element: TypeElement,
     private val processingEnv: ProcessingEnvironment) : CodeGenerator<List<MethodSpec>?> {
 
-
   override fun generate(): List<MethodSpec>? {
     val enclosedElements: List<Element?> = element.enclosedElements
     val methods: MutableList<ExecutableElement> = ArrayList(ElementFilter.methodsIn(enclosedElements))
@@ -42,14 +46,8 @@ class DatabaseAbstractMethodsGenerator(
       it.modifiers.contains(Modifier.ABSTRACT)
     }
 
-    //if (abstractFunctions.isNullOrEmpty()) return null
     val funSpecs = ArrayList<MethodSpec>()
 
-    abstractFunctions.forEach {
-      funSpecs.add(MethodSpec.overriding(it)
-          .build())
-    }
-
     abstractFunctions.filter {
       it.parameters.isEmpty() && it.returnType.kind != TypeKind.VOID
     }.forEach { method ->
@@ -79,15 +77,6 @@ class DatabaseAbstractMethodsGenerator(
     }
     codeBlock.addStatement("throw new IllegalArgumentException(entityClass.getCanonicalName() + \"not registered with this database\")")
 
-    /**
-     * @Override
-    @NotNull
-    public <T extends Identifiable<Integer>> FastTable<T> getTable(Class<? extends T> entityClass) throws IllegalArgumentException {
-    if (entityClass == Person.class) return getDatabaseInstance().obtain(PersonFastTable.class);
-    if (entityClass == Exam.class) return getDatabaseInstance().obtain(ExamFastTable.class);
-    throw new IllegalArgumentException(entityClass.getCanonicalName() + "not registered with this database");
-    }
-     */
     val typeVariable: TypeVariableName? = TypeVariableName.get("T").withBounds(
         ParameterizedTypeName.get(
             ClassName.get("promise.commons.model", "Identifiable"),
@@ -99,12 +88,23 @@ class DatabaseAbstractMethodsGenerator(
         ), "entityClass")
         .addAnnotation(Override::class.java)
         .addAnnotation(NotNull::class.java)
+        .addJavadoc("""
+          Returns the table for the specified entity
+          @Param entityClass Class of the entity persisted
+          @Returns the table instance
+        """.trimIndent())
         .addException(IllegalArgumentException::class.java)
         .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
-        .returns(ParameterizedTypeName.get(ClassName.get("promise.db", "FastTable"), TypeVariableName.get("T")))
+        .returns(ParameterizedTypeName.get(
+            ClassName.get("promise.db", "FastTable"),
+            TypeVariableName.get("T")))
         .addCode(codeBlock.build())
         .build())
 
+    val retutnType = """
+      TableCrud<T, ? super SQLiteDatabase> 
+    """.trimIndent()
+
     return funSpecs
   }
 
diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseAnnotationGenerator.kt b/compiler/src/main/java/promise/db/ompiler/DatabaseAnnotationGenerator.kt
index e4b73a4..06b5d3b 100644
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseAnnotationGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/DatabaseAnnotationGenerator.kt
@@ -16,6 +16,10 @@ package promise.db.ompiler
 import com.squareup.javapoet.AnnotationSpec
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
+import promise.db.ompiler.utils.Utils
+import promise.db.ompiler.utils.getClassName
+import promise.db.ompiler.utils.getDatabaseVersion
+import promise.db.ompiler.utils.getTableEntities
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.TypeElement
diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseCrudStubMethodsGenerator.kt b/compiler/src/main/java/promise/db/ompiler/DatabaseCrudStubMethodsGenerator.kt
index 0512480..0a09e1f 100644
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseCrudStubMethodsGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/DatabaseCrudStubMethodsGenerator.kt
@@ -14,6 +14,7 @@
 package promise.db.ompiler
 
 import com.squareup.javapoet.TypeSpec
+import promise.db.ompiler.utils.getTableEntities
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.TypeElement
diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseEntityProcessor.kt b/compiler/src/main/java/promise/db/ompiler/DatabaseEntityAnnotatedProcessor.kt
similarity index 71%
rename from compiler/src/main/java/promise/db/ompiler/DatabaseEntityProcessor.kt
rename to compiler/src/main/java/promise/db/ompiler/DatabaseEntityAnnotatedProcessor.kt
index 7f6d06e..57aa15d 100644
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseEntityProcessor.kt
+++ b/compiler/src/main/java/promise/db/ompiler/DatabaseEntityAnnotatedProcessor.kt
@@ -14,11 +14,11 @@
 package promise.db.ompiler
 
 import com.squareup.javapoet.ClassName
-import com.squareup.javapoet.FieldSpec
 import com.squareup.javapoet.JavaFile
 import com.squareup.javapoet.MethodSpec
 import com.squareup.javapoet.TypeSpec
 import promise.db.DatabaseEntity
+import promise.db.ompiler.utils.JavaUtils
 import javax.annotation.processing.ProcessingEnvironment
 import javax.annotation.processing.RoundEnvironment
 import javax.lang.model.element.Element
@@ -27,21 +27,23 @@ import javax.lang.model.element.Modifier
 import javax.lang.model.element.TypeElement
 import javax.tools.Diagnostic
 
-class DatabaseEntityProcessor(private val processingEnv: ProcessingEnvironment): ClassProcessor() {
+class DatabaseEntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment) : AnnotatedClassProcessor() {
 
   override fun process(environment: RoundEnvironment?): List<JavaFile.Builder?>? {
-        return environment?.getElementsAnnotatedWith(DatabaseEntity::class.java)
+    return environment?.getElementsAnnotatedWith(DatabaseEntity::class.java)
         ?.map { element ->
           if (element.kind != ElementKind.CLASS) {
             processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "Only classes can be annotated")
             return null
           }
-//          if (JavaUtils.isSubtypeOfType(element.asType(), "promise.db.PromiseDatabase")) {
-//             processElement(element)
-//          }
-//          processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "Database class must extend from promise.db.PromiseDatabase")
-//           null
-
+          if (element.kind == ElementKind.CLASS && !(element as TypeElement).modifiers.contains(Modifier.ABSTRACT)) {
+            processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "Database class must be abstract")
+          }
+          val promiseDatabaseType = JavaUtils.getDeclaredType(processingEnv,
+              processingEnv.elementUtils.getTypeElement("promise.db.PromiseDatabase"))
+          if (!JavaUtils.isSubTypeOfDeclaredType(processingEnv, element, promiseDatabaseType)) {
+            processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "Database class must extend from promise.db.PromiseDatabase")
+          }
           processElement(element)
         }
   }
@@ -64,14 +66,16 @@ class DatabaseEntityProcessor(private val processingEnv: ProcessingEnvironment):
         .addModifiers(Modifier.PRIVATE)
         .addStatement("super()")
         .addStatement("this.instance = fastDatabase")
-    if (TypeConverterProcessor.typeConverter != null) {
-      JavaUtils.generateAddConverterStatementInDatabaseConstructorMethod(processingEnv, constructorMethod, TypeConverterProcessor.typeConverter!!)
+    if (TypeConverterAnnotatedProcessor.typeConverter != null) {
+      constructorMethod.addJavadoc("""
+        Initializes the TypeConverter as singleton
+      """.trimIndent())
+      JavaUtils.generateAddConverterStatementInDatabaseConstructorMethod(processingEnv, constructorMethod, TypeConverterAnnotatedProcessor.typeConverter!!)
     }
     classBuilder.superclass(ClassName.get(pack, className))
         .addAnnotation(tableAnnotationSpec)
         .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
-        .addMethod(constructorMethod
-            .build())
+        .addMethod(constructorMethod.build())
 
     DatabaseStaticMethodsGenerator(classBuilder, element, processingEnv).generate()
 
@@ -83,7 +87,7 @@ class DatabaseEntityProcessor(private val processingEnv: ProcessingEnvironment):
 
     DatabaseCrudStubMethodsGenerator(classBuilder, element, processingEnv).generate()
 
-   return JavaFile.builder(pack, classBuilder.build())
+    return JavaFile.builder(pack, classBuilder.build())
 
   }
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseStaticMethodsGenerator.kt b/compiler/src/main/java/promise/db/ompiler/DatabaseStaticMethodsGenerator.kt
index 60b3c59..a34b092 100644
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseStaticMethodsGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/DatabaseStaticMethodsGenerator.kt
@@ -19,6 +19,11 @@ import com.squareup.javapoet.FieldSpec
 import com.squareup.javapoet.MethodSpec
 import com.squareup.javapoet.TypeSpec
 import promise.db.AddedEntity
+import promise.db.ompiler.utils.JavaUtils
+import promise.db.ompiler.utils.Utils
+import promise.db.ompiler.utils.getClassName
+import promise.db.ompiler.utils.getTableEntities
+import promise.db.ompiler.utils.toTypeName
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
@@ -42,46 +47,60 @@ class DatabaseStaticMethodsGenerator(
     }
 
     val entities = (element as TypeElement).getTableEntities(processingEnv)
-
+        .filter {
+          it.getAnnotation(AddedEntity::class.java) != null
+        }
     val migrationCodeBlock = CodeBlock.builder()
-
-    migrationCodeBlock.beginControlFlow("return new Migration()")
-    JavaUtils.generateDatabaseMigrationOverrideControlBlock(migrationCodeBlock)
-    entities.forEach {
-      val migrationAnnoTation = it.getAnnotation(AddedEntity::class.java)
-      if (migrationAnnoTation != null) {
-        migrationCodeBlock.beginControlFlow("if (oldVersion == ${migrationAnnoTation.fromVersion} && newVersion == ${migrationAnnoTation.toVersion})")
+    if (entities.isEmpty()) migrationCodeBlock.addStatement("return null")
+    else {
+      migrationCodeBlock.beginControlFlow("return new Migration()")
+      JavaUtils.generateDatabaseMigrationOverrideControlBlock(migrationCodeBlock)
+      entities.forEach {
+        val migrationAnnotation = it.getAnnotation(AddedEntity::class.java)
+        migrationCodeBlock.beginControlFlow("if (oldVersion == ${migrationAnnotation.fromVersion} && newVersion == ${migrationAnnotation.toVersion})")
         migrationCodeBlock.addStatement("database.add(sqLiteDatabase, database.obtain(${it.getClassName()}.class))")
         migrationCodeBlock.endControlFlow()
       }
+      migrationCodeBlock.endControlFlow()
+      migrationCodeBlock.add("};")
     }
-    migrationCodeBlock.endControlFlow()
-    migrationCodeBlock.endControlFlow()
-    migrationCodeBlock.add(";")
+
     val migrationPropSpec = MethodSpec.methodBuilder("getMigration")
         .returns(ClassName.get("promise.db", "Migration"))
         .addModifiers(Modifier.PRIVATE, Modifier.STATIC)
         .addCode(migrationCodeBlock.build())
+        .addJavadoc("""
+          Migration callback for adding tables into existing database
+        """.trimIndent())
         .build()
 
     typeSpec.addMethod(migrationPropSpec)
     // adding db instance var
     // private static volatile FastDatabase instance = null;
-    typeSpec.addField(FieldSpec.builder(ClassName.get("promise.db", "FastDatabase"),"instance")
+    typeSpec.addField(FieldSpec.builder(ClassName.get("promise.db", "FastDatabase"), "instance")
         .initializer("null")
         .addModifiers(Modifier.PRIVATE)
+        .addJavadoc("""
+          Database instance
+        """.trimIndent())
         .build())
 
-    if (TypeConverterProcessor.typeConverter != null) {
+    if (TypeConverterAnnotatedProcessor.typeConverter != null) {
       typeSpec.addField(FieldSpec.builder(
-          TypeConverterProcessor.typeConverter!!.toTypeName(),
+          TypeConverterAnnotatedProcessor.typeConverter!!.toTypeName(),
           "typeConverter")
           .addModifiers(Modifier.PRIVATE)
+          .addJavadoc("""
+            TypeConverter instance
+          """.trimIndent())
           .build())
     }
 
-    typeSpec.addField(FieldSpec.builder(Boolean::class.javaPrimitiveType,"initialized")
+    typeSpec.addField(FieldSpec.builder(Boolean::class.javaPrimitiveType, "initialized")
         .initializer("false")
+        .addJavadoc("""
+          Check to ensure database instance is not instantiated more than once
+        """.trimIndent())
         .addModifiers(Modifier.PRIVATE, Modifier.VOLATILE, Modifier.STATIC)
         .build())
 
@@ -95,8 +114,12 @@ class DatabaseStaticMethodsGenerator(
     //    }
     typeSpec.addMethod(MethodSpec.methodBuilder("createDatabase")
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
-        .addParameter(ClassName.get(String::class.java),"name")
+        .addParameter(ClassName.get(String::class.java), "name")
         .returns(ClassName.get(pack, className))
+        .addJavadoc("""
+          Creates the simplest database with name specified
+          @Param name the name of the database
+        """.trimIndent())
         .addCode(CodeBlock.of("""
           if (initialized) throw new IllegalStateException("Database already created");
           initialized = true;
@@ -107,13 +130,20 @@ class DatabaseStaticMethodsGenerator(
     // add with creation callback
     typeSpec.addMethod(MethodSpec.methodBuilder("createDatabase")
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
-        .addParameter(ClassName.get(String::class.java),"name")
-        .addParameter(ClassName.get("promise.db", "DatabaseCreationCallback"),"databaseCreationCallback")
+        .addParameter(ClassName.get(String::class.java), "name")
+        .addParameter(ClassName.get("promise.db", "DatabaseCreationCallback"), "databaseCreationCallback")
         .returns(ClassName.get(pack, className))
+        .addJavadoc("""
+          Creates the simplest database with name specified with callback
+          Callback can be used to pre populate database with records or
+          set flags like foreign keys
+          @Param name the name of the database
+          @Param databaseCreationCallback callback
+        """.trimIndent())
         .addCode(CodeBlock.of("""
           if (initialized) throw new IllegalStateException("Database already created");
           initialized = true;
-          return new $classnameImpl(FastDatabase.createDatabase($classnameImpl.class, name, getMigration()).setDatabaseCreationCallback(databaseCreationCallback));
+          return new $classnameImpl(FastDatabase.createDatabase($classnameImpl.class, name, getMigration(), databaseCreationCallback));
         """.trimIndent()))
         .build())
 
@@ -126,6 +156,9 @@ class DatabaseStaticMethodsGenerator(
     typeSpec.addMethod(MethodSpec.methodBuilder("createInMemoryDatabase")
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
         .returns(ClassName.get(pack, className))
+        .addJavadoc("""
+          Creates an in memory database, useful for tests
+        """.trimIndent())
         .addCode(CodeBlock.of("""
           if (initialized) throw new IllegalStateException("Database already created");
           initialized = true;
@@ -135,12 +168,18 @@ class DatabaseStaticMethodsGenerator(
     // with in memory database
     typeSpec.addMethod(MethodSpec.methodBuilder("createInMemoryDatabase")
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
-        .addParameter(ClassName.get("promise.db", "DatabaseCreationCallback"),"databaseCreationCallback")
+        .addParameter(ClassName.get("promise.db", "DatabaseCreationCallback"), "databaseCreationCallback")
         .returns(ClassName.get(pack, className))
+        .addJavadoc("""
+          Creates an in memory database, useful for tests
+          Callback can be used to pre populate database with records or
+          set flags like foreign keys
+          @Param databaseCreationCallback callback
+        """.trimIndent())
         .addCode(CodeBlock.of("""
           if (initialized) throw new IllegalStateException("Database already created");
           initialized = true;
-          return new $classnameImpl(FastDatabase.createInMemoryDatabase($classnameImpl.class).setDatabaseCreationCallback(databaseCreationCallback));
+          return new $classnameImpl(FastDatabase.createInMemoryDatabase($classnameImpl.class, databaseCreationCallback));
         """.trimIndent()))
         .build())
 
@@ -153,6 +192,9 @@ class DatabaseStaticMethodsGenerator(
     typeSpec.addMethod(MethodSpec.methodBuilder("createReactiveInMemoryDatabase")
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
         .returns(ClassName.get(pack, className))
+        .addJavadoc("""
+          Creates an in memory database, enables calling rx DML functions in the tables
+        """.trimIndent())
         .addCode(CodeBlock.of("""
           if (initialized) throw new IllegalStateException("Database already created");
           initialized = true;
@@ -162,8 +204,14 @@ class DatabaseStaticMethodsGenerator(
     // with callback
     typeSpec.addMethod(MethodSpec.methodBuilder("createReactiveInMemoryDatabase")
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
-        .addParameter(ClassName.get("promise.db", "DatabaseCreationCallback"),"databaseCreationCallback")
+        .addParameter(ClassName.get("promise.db", "DatabaseCreationCallback"), "databaseCreationCallback")
         .returns(ClassName.get(pack, className))
+        .addJavadoc("""
+          Creates an in memory database, enables calling rx DML functions in the tables
+          Callback can be used to pre populate database with records or
+          set flags like foreign keys
+          @Param databaseCreationCallback callback
+        """.trimIndent())
         .addCode(CodeBlock.of("""
           if (initialized) throw new IllegalStateException("Database already created");
           initialized = true;
@@ -180,8 +228,12 @@ class DatabaseStaticMethodsGenerator(
     //    }
     typeSpec.addMethod(MethodSpec.methodBuilder("createReactiveDatabase")
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
-        .addParameter(ClassName.get(String::class.java),"name")
+        .addParameter(ClassName.get(String::class.java), "name")
         .returns(ClassName.get(pack, className))
+        .addJavadoc("""
+          Creates database, that enables calling rx DML functions in the tables
+          @Param name name of the database 
+        """.trimIndent())
         .addCode(CodeBlock.of("""
           if (initialized) throw new IllegalStateException("Database already created");
            initialized = true;
@@ -192,9 +244,16 @@ class DatabaseStaticMethodsGenerator(
     // with creation callback
     typeSpec.addMethod(MethodSpec.methodBuilder("createReactiveDatabase")
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
-        .addParameter(ClassName.get(String::class.java),"name")
-        .addParameter(ClassName.get("promise.db", "DatabaseCreationCallback"),"databaseCreationCallback")
+        .addParameter(ClassName.get(String::class.java), "name")
+        .addParameter(ClassName.get("promise.db", "DatabaseCreationCallback"), "databaseCreationCallback")
         .returns(ClassName.get(pack, className))
+        .addJavadoc("""
+          Creates database, that enables calling rx DML functions in the tables
+          Callback can be used to pre populate database with records or
+          set flags like foreign keys
+          @Param name name of the database 
+          @Param databaseCreationCallback callback
+        """.trimIndent())
         .addCode(CodeBlock.of("""
           if (initialized) throw new IllegalStateException("Database already created");
            initialized = true;
diff --git a/compiler/src/main/java/promise/db/ompiler/EntityProcessor.kt b/compiler/src/main/java/promise/db/ompiler/EntityAnnotatedProcessor.kt
similarity index 70%
rename from compiler/src/main/java/promise/db/ompiler/EntityProcessor.kt
rename to compiler/src/main/java/promise/db/ompiler/EntityAnnotatedProcessor.kt
index 42e36be..064ebff 100644
--- a/compiler/src/main/java/promise/db/ompiler/EntityProcessor.kt
+++ b/compiler/src/main/java/promise/db/ompiler/EntityAnnotatedProcessor.kt
@@ -24,39 +24,41 @@ import com.squareup.javapoet.TypeName
 import com.squareup.javapoet.TypeSpec
 import org.jetbrains.annotations.NotNull
 import promise.db.Entity
+import promise.db.ompiler.utils.JavaUtils
+import promise.db.ompiler.utils.checkIfAnyElementNeedsTypeConverter
+import promise.db.ompiler.utils.getClassName
+import promise.db.ompiler.utils.isElementAnnotatedAsRelation
 import javax.annotation.processing.ProcessingEnvironment
 import javax.annotation.processing.RoundEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.ElementKind
 import javax.lang.model.element.Modifier
 import javax.lang.model.element.TypeElement
+import javax.lang.model.util.ElementFilter
 import javax.tools.Diagnostic
 
-class EntityProcessor(private val processingEnv: ProcessingEnvironment) : ClassProcessor() {
+class EntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment) : AnnotatedClassProcessor() {
   override fun process(environment: RoundEnvironment?): List<JavaFile.Builder?>? {
-    return environment?.getElementsAnnotatedWith(Entity::class.java)
-        ?.map { element ->
+    val javaFiles = ArrayList<JavaFile.Builder?>()
+    environment?.getElementsAnnotatedWith(Entity::class.java)
+        ?.forEach { element ->
           if (element.kind != ElementKind.CLASS) {
             processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "Only classes can be annotated")
-            return null
           }
-
-//            val identifiableInterface = processingEnv.elementUtils.getTypeElement("promise.commons.model.Identifiable")
-//            processingEnv.messager.printMessage(Diagnostic.Kind.NOTE, "Entity class ${element.simpleName}, interfaceType ${identifiableInterface.toString()}")
-//            if (JavaUtils.implementsInterface(processingEnv, element as TypeElement, identifiableInterface.asType())) {
-//              processAnnotation(element)
-//            }
-          processAnnotation(element)
-//            else {
-//              processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "The Entity class ${element.simpleName} must implement Identifiable")
-//              return false
-//            }
+          val identifiableInterface = processingEnv.elementUtils.getTypeElement("promise.commons.model.Identifiable")
+          val declaredInterface = JavaUtils.toWildCardType(processingEnv, identifiableInterface, 1)
+          if (!JavaUtils.isSubTypeOfDeclaredType(processingEnv, element as TypeElement, declaredInterface)) {
+            processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "The Entity class ${element.simpleName} must implement Identifiable")
+          } else {
+            javaFiles.add(processAnnotation(element))
+            javaFiles.addAll(processElementDaos(element))
+          }
+          //processAnnotation(element)
         }
+    return javaFiles
   }
 
-
   private fun processAnnotation(element: Element): JavaFile.Builder {
-    processingEnv.messager.printMessage(Diagnostic.Kind.OTHER, "Entity Processing: ${element.simpleName}")
 
     val className = element.simpleName.toString()
     val pack = processingEnv.elementUtils.getPackageOf(element).toString()
@@ -67,6 +69,9 @@ class EntityProcessor(private val processingEnv: ProcessingEnvironment) : ClassP
 
     val classBuilder = TypeSpec.classBuilder(fileName)
         .addModifiers(Modifier.PUBLIC)
+        .addJavadoc("""
+          Table for ${element.simpleName}
+        """.trimIndent())
         .superclass(ParameterizedTypeName.get(
             ClassName.get("promise.db", "FastTable"),
             ClassName.get(pack, className))
@@ -82,10 +87,10 @@ class EntityProcessor(private val processingEnv: ProcessingEnvironment) : ClassP
 
     classBuilder.addAnnotation(tableAnnotationSpec)
 
-    val activeRecordType = processingEnv.typeUtils.erasure(
-        processingEnv.elementUtils.getTypeElement("promise.db.ActiveRecord").asType())
+    val activeRecordType = processingEnv.elementUtils.getTypeElement("promise.db.ActiveRecord")
+    val declaredActiveRecordType = JavaUtils.toWildCardType(processingEnv, activeRecordType, 1)
 
-    if (JavaUtils.isSubtypeOfType((element as TypeElement).asType(), TypeName.get(activeRecordType)))
+    if (JavaUtils.isSubTypeOfDeclaredType(processingEnv, (element as TypeElement), declaredActiveRecordType))
       classBuilder.addMethod(MethodSpec.methodBuilder("createEntityInstance")
           .addAnnotation(Override::class.java)
           .addAnnotation(NotNull::class.java)
@@ -98,13 +103,16 @@ class EntityProcessor(private val processingEnv: ProcessingEnvironment) : ClassP
     val tableColumnPropsGenerator = TableColumnFieldsGenerator(processingEnv, element.enclosedElements)
 
     if (element.checkIfAnyElementNeedsTypeConverter()) {
-      classBuilder.addField(FieldSpec.builder(TypeName.get(TypeConverterProcessor
+      classBuilder.addField(FieldSpec.builder(TypeName.get(TypeConverterAnnotatedProcessor
           .typeConverter!!.asType()), "typeConverter")
           .addModifiers(Modifier.PRIVATE)
+          .addJavadoc("""
+            TypeConverter for fields not directly persistable
+          """.trimIndent())
           .build())
       classBuilder.addMethod(MethodSpec.methodBuilder("setTypeConverter")
           .addModifiers(Modifier.PUBLIC)
-          .addParameter(TypeName.get(TypeConverterProcessor
+          .addParameter(TypeName.get(TypeConverterAnnotatedProcessor
               .typeConverter!!.asType()), "typeConverter")
           .addStatement("this.typeConverter = typeConverter")
           .build())
@@ -116,6 +124,9 @@ class EntityProcessor(private val processingEnv: ProcessingEnvironment) : ClassP
             ClassName.get(Integer::class.java)
         ), "idColumn")
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC, Modifier.FINAL)
+        .addJavadoc("""
+          Column for primary key
+        """.trimIndent())
         .initializer(CodeBlock.of("FastTable.getId()")).build()
 
     classBuilder.addField(idColumnSpec)
@@ -157,5 +168,13 @@ class EntityProcessor(private val processingEnv: ProcessingEnvironment) : ClassP
     return JavaFile.builder(pack, classBuilder.build())
   }
 
+  private fun processElementDaos(element: Element): List<JavaFile.Builder?> {
+    val javaFiles = ArrayList<JavaFile.Builder?>()
+    val fields = ElementFilter.fieldsIn(element.enclosedElements).filter {
+      it.isElementAnnotatedAsRelation()
+    }
+    if (fields.isNotEmpty()) javaFiles.addAll(TableRelationsGenerator(processingEnv, element as TypeElement, fields).generate())
 
+    return javaFiles
+  }
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt b/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt
index d916dd1..b29fab1 100644
--- a/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt
+++ b/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt
@@ -20,6 +20,7 @@ import net.ltgt.gradle.incap.IncrementalAnnotationProcessorType
 import promise.db.DatabaseEntity
 import promise.db.Entity
 import promise.db.TypeConverter
+import promise.db.ompiler.utils.Utils
 import java.util.*
 import javax.annotation.processing.AbstractProcessor
 import javax.annotation.processing.Processor
@@ -40,20 +41,18 @@ class PromiseDatabaseCompiler : AbstractProcessor() {
   override fun process(mutableSet: MutableSet<out TypeElement>?, environment: RoundEnvironment?): Boolean {
     try {
       val javaFiles: ArrayList<JavaFile.Builder> = ArrayList()
-      val processors: ArrayList<ClassProcessor> = ArrayList()
+      val processors: ArrayList<AnnotatedClassProcessor> = ArrayList()
 
-      processors.add(TypeConverterProcessor(processingEnv))
-      processors.add(EntityProcessor(processingEnv))
-      processors.add(DatabaseEntityProcessor(processingEnv))
+      processors.add(TypeConverterAnnotatedProcessor(processingEnv))
+      processors.add(EntityAnnotatedProcessor(processingEnv))
+      processors.add(DatabaseEntityAnnotatedProcessor(processingEnv))
 
       processors.forEach {
-        val builder = it.process(environment)
-        if (builder != null) {
-          javaFiles.addAll(builder.filterNotNull())
-        }
+        val builders = it.process(environment)
+        if (builders != null) javaFiles.addAll(builders.filterNotNull())
       }
       javaFiles.forEach {
-        val file = it
+        it
             .indent("  ")
             .skipJavaLangImports(true)
             .addFileComment(
@@ -76,17 +75,17 @@ class PromiseDatabaseCompiler : AbstractProcessor() {
             """.trimIndent()
             )
             .build()
-        file.writeTo(processingEnv.filer)
+            .writeTo(processingEnv.filer)
       }
       return true
     } catch (e: Throwable) {
       val stringBuilder = StringBuilder()
-      //stringBuilder.append(Utils.getStackTraceString(e))
-      //stringBuilder.append("\n")
+      stringBuilder.append(Utils.getStackTraceString(e))
+      stringBuilder.append("\n")
       stringBuilder.append("Trace: ").append(Arrays.toString(e.stackTrace))
       processingEnv.messager.printMessage(Diagnostic.Kind.ERROR,
-          "EntityProcessor: $stringBuilder " )
-         // "EntityProcessor Trace: ${Arrays.toString(e.stackTrace)}")
+          "EntityProcessor: $stringBuilder ")
+      // "EntityProcessor Trace: ${Arrays.toString(e.stackTrace)}")
       return false
     }
   }
diff --git a/compiler/src/main/java/promise/db/ompiler/RelationsGenerator.kt b/compiler/src/main/java/promise/db/ompiler/RelationsGenerator.kt
deleted file mode 100644
index 7023a13..0000000
--- a/compiler/src/main/java/promise/db/ompiler/RelationsGenerator.kt
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright 2017, Peter Vincent
- * Licensed under the Apache License, Version 2.0, Android Promise.
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package promise.db.ompiler
-
-import com.squareup.javapoet.MethodSpec
-import promise.db.HasMany
-import promise.db.HasOne
-import java.util.*
-import javax.annotation.processing.ProcessingEnvironment
-import javax.lang.model.element.Element
-import javax.tools.Diagnostic
-import kotlin.collections.ArrayList
-
-class RelationsGenerator(
-    private val processingEnvironment: ProcessingEnvironment
-    ,
-    private val setElements: List<Element>
-) : CodeGenerator<List<MethodSpec>?> {
-
-  override fun generate(): List<MethodSpec>? {
-    val funSpecs = ArrayList<MethodSpec>()
-    filterNotPrimitiveElements(setElements.filter {
-      it.kind.isField
-    }).also {
-      if (it.isEmpty()) return null
-    }.forEach {
-
-    }
-    return funSpecs
-  }
-
-  private fun getNameOfColumn(element: Element): String {
-    return element.simpleName.toString()
-  }
-
-  private fun filterNotPrimitiveElements(elements: List<Element>): List<Element> = elements.filter {
-    try {
-      it.getAnnotation(HasOne::class.java) != null ||
-          it.getAnnotation(HasMany::class.java) != null
-    } catch (e: Throwable) {
-      processingEnvironment.messager.printMessage(Diagnostic.Kind.ERROR,
-          "FilterPrimitiveElement ${it.kind.name}: ${Arrays.toString(e.stackTrace)}")
-      true
-    }
-  }
-}
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/db/ompiler/TableAnnotationGenerator.java b/compiler/src/main/java/promise/db/ompiler/TableAnnotationGenerator.java
index 6e9f3c3..2ae185a 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableAnnotationGenerator.java
+++ b/compiler/src/main/java/promise/db/ompiler/TableAnnotationGenerator.java
@@ -27,8 +27,7 @@
 
 import promise.db.Entity;
 import promise.db.Table;
-import promise.db.ompiler.CodeGenerator;
-import promise.db.ompiler.PersistableEntityUtilsKt;
+import promise.db.ompiler.utils.PersistableEntityUtilsKt;
 
 public class TableAnnotationGenerator implements CodeGenerator<AnnotationSpec> {
   private Element element;
diff --git a/compiler/src/main/java/promise/db/ompiler/TableColumnFieldsGenerator.kt b/compiler/src/main/java/promise/db/ompiler/TableColumnFieldsGenerator.kt
index 115a059..abbf6c5 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableColumnFieldsGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/TableColumnFieldsGenerator.kt
@@ -22,13 +22,15 @@ import promise.db.HasOne
 import promise.db.Ignore
 import promise.db.PrimaryKey
 import promise.db.PrimaryKeyAutoIncrement
-import java.util.*
+import promise.db.ompiler.utils.checkIfHasTypeConverter
+import promise.db.ompiler.utils.getNameOfColumn
+import promise.db.ompiler.utils.isElementAnnotatedAsRelation
+import promise.db.ompiler.utils.isPersistable
+import promise.db.ompiler.utils.isSameAs
+import promise.db.ompiler.utils.toTypeName
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
-import javax.tools.Diagnostic
-import kotlin.collections.ArrayList
-import kotlin.collections.HashMap
 
 /**
  * generates column fields for the entity
@@ -65,6 +67,9 @@ class TableColumnFieldsGenerator(
           val columnInitializer = getColumnInitializer(element, ClassName.get(String::class.java))
           val spec = FieldSpec.builder(parameterizedColumnTypeName, colVariableName)
               .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
+              .addJavadoc("""
+                Column field for ${element.simpleName}
+              """.trimIndent())
               .initializer(CodeBlock.of("""
               new Column<String>("$nameOfColumn", $columnInitializer, ${i + 1})
             """.trimIndent())
@@ -74,7 +79,7 @@ class TableColumnFieldsGenerator(
           val pair: Pair<Pair<String, Element>, String> = Pair(Pair(element.simpleName.toString(), element), colVariableName)
           genColValues.add(pair)
         }
-       }
+      }
       /**
        * for fields marked as relation, additional column needs to be added
        */
@@ -88,6 +93,9 @@ class TableColumnFieldsGenerator(
           val columnInitializer = getColumnInitializer(element, ClassName.get(Integer::class.java))
           val spec = FieldSpec.builder(parameterizedColumnTypeName, colVariableName)
               .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
+              .addJavadoc("""
+                Column field for ${element.simpleName}
+              """.trimIndent())
               .initializer(CodeBlock.of("""
               new Column<Integer>("$nameOfColumn", $columnInitializer, ${i + 1})
             """.trimIndent())
@@ -101,7 +109,7 @@ class TableColumnFieldsGenerator(
       /**
        * for normal persistable fields
        */
-      else if(element.isPersistable()) {
+      else if (element.isPersistable()) {
         val spec = processField(element, nameOfColumn, i)
         map[Pair(element, colVariableName)] = spec
         val pair: Pair<Pair<String, Element>, String> = Pair(Pair(element.simpleName.toString(), element), colVariableName)
@@ -125,6 +133,9 @@ class TableColumnFieldsGenerator(
     val columnInitializer = getColumnInitializer(element, variableClassType)
     return FieldSpec.builder(parameterizedColumnTypeName, colVariableName)
         .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
+        .addJavadoc("""
+                Column field for ${element.simpleName}
+              """.trimIndent())
         .initializer(CodeBlock.of("""
               new Column<${variableClassType}>("$nameOfColumn", $columnInitializer, ${i + 1})
             """.trimIndent())
@@ -159,8 +170,7 @@ class TableColumnFieldsGenerator(
       } else {
         str += ".NULLABLE()"
       }
-    }
-    else if (classTypeName.isSameAs(String::class.java)) {
+    } else if (classTypeName.isSameAs(String::class.java)) {
       if (element.getAnnotation(promise.db.VarChar::class.java) != null) {
         str += ".VARCHAR"
         val annotation = element.getAnnotation(promise.db.VarChar::class.java)
@@ -173,8 +183,7 @@ class TableColumnFieldsGenerator(
         } else {
           throw IllegalStateException("element ${element.simpleName} is annotated as varchar without length")
         }
-      }
-      else {
+      } else {
         if (element.getAnnotation(promise.db.Text::class.java) != null) {
           str += ".TEXT"
           val annotation = element.getAnnotation(promise.db.Text::class.java)
@@ -185,13 +194,11 @@ class TableColumnFieldsGenerator(
           } else {
             throw IllegalStateException("element ${element.simpleName} is annotated as varchar without length")
           }
-        }
-        else {
+        } else {
           str += ".TEXT.NULLABLE()"
         }
       }
-    }
-    else {
+    } else {
       if (element.getAnnotation(promise.db.VarChar::class.java) != null) {
         str += ".VARCHAR"
         val annotation = element.getAnnotation(promise.db.VarChar::class.java)
@@ -204,8 +211,7 @@ class TableColumnFieldsGenerator(
         } else {
           throw IllegalStateException("element ${element.simpleName} is annotated as varchar without length")
         }
-      }
-      else {
+      } else {
         if (element.getAnnotation(promise.db.Text::class.java) != null) {
           str += ".TEXT"
           val annotation = element.getAnnotation(promise.db.Text::class.java)
@@ -216,8 +222,7 @@ class TableColumnFieldsGenerator(
           } else {
             throw IllegalStateException("element ${element.simpleName} is annotated as varchar without length")
           }
-        }
-        else {
+        } else {
           str += ".TEXT.NULLABLE()"
         }
       }
@@ -226,6 +231,4 @@ class TableColumnFieldsGenerator(
   }
 
 
-
-
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/db/ompiler/TableDeserializerMethodGenerator.kt b/compiler/src/main/java/promise/db/ompiler/TableDeserializerMethodGenerator.kt
index e0580e6..e44d23d 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableDeserializerMethodGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/TableDeserializerMethodGenerator.kt
@@ -17,10 +17,18 @@ import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
 import com.squareup.javapoet.MethodSpec
 import com.squareup.javapoet.TypeName
+import promise.db.ompiler.utils.ConverterTypes
+import promise.db.ompiler.utils.JavaUtils
+import promise.db.ompiler.utils.camelCase
+import promise.db.ompiler.utils.capitalizeFirst
+import promise.db.ompiler.utils.checkIfHasTypeConverter
+import promise.db.ompiler.utils.getConverterCompatibleMethod
+import promise.db.ompiler.utils.isElementAnnotatedAsRelation
+import promise.db.ompiler.utils.isSameAs
+import promise.db.ompiler.utils.toTypeName
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
-import javax.tools.Diagnostic
 
 class TableDeserializerMethodGenerator(
     private val processingEnvironment: ProcessingEnvironment,
@@ -54,6 +62,7 @@ class TableDeserializerMethodGenerator(
         .addParameter(ClassName.get("android.database", "Cursor"), "e")
         .addAnnotation(Override::class.java)
         .addModifiers(Modifier.PUBLIC)
+        .addJavadoc("Deserializer converts from cursor to the entity")
         .returns(ClassName.get(typeDataTypePack, typeDataType))
         .addCode(codeBlock.build())
         .build()
@@ -81,8 +90,7 @@ class TableDeserializerMethodGenerator(
       if (executableFn != null) {
         codeBlock.addStatement("$objectName.set${varName.capitalizeFirst()}(typeConverter.${executableFn.simpleName}(e.${getCursorReturn(TypeName.get(String::class.java))}(${colName}.getIndex(e))))")
       }
-    }
-    else if (varType.isElementAnnotatedAsRelation()) {
+    } else if (varType.isElementAnnotatedAsRelation()) {
       val gen = """
         int personId = e.getInt(personColumn.getIndex(e));
       if (personId != 0) {
@@ -92,8 +100,7 @@ class TableDeserializerMethodGenerator(
       }
       """.trimIndent()
       codeBlock.add(JavaUtils.generateDeserializerRelationSetStatement(objectName, varType, colName))
-    }
-    else codeBlock.addStatement("$objectName.set${varName.capitalizeFirst()}(e.${getCursorReturn(varType.toTypeName())}(${colName}.getIndex(e)))")
+    } else codeBlock.addStatement("$objectName.set${varName.capitalizeFirst()}(e.${getCursorReturn(varType.toTypeName())}(${colName}.getIndex(e)))")
     //throw Exception("Could not generate deserializer method for entity")
   }
 
diff --git a/compiler/src/main/java/promise/db/ompiler/TableMigrationFieldGenerator.kt b/compiler/src/main/java/promise/db/ompiler/TableMigrationFieldGenerator.kt
index 69200c0..41ab689 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableMigrationFieldGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/TableMigrationFieldGenerator.kt
@@ -21,6 +21,7 @@ import org.jetbrains.annotations.NotNull
 import promise.db.Migrate
 import promise.db.MigrationOptions
 import promise.db.Migrations
+import promise.db.ompiler.utils.getNameOfColumn
 import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
 
@@ -57,6 +58,7 @@ class TableMigrationFieldGenerator(
       codeBlock.add("}\n")
     }
   }
+
   private fun buildMigration(
       codeBlock: CodeBlock.Builder,
       column: String,
@@ -83,7 +85,6 @@ class TableMigrationFieldGenerator(
     }
     if (migrateFields.isEmpty()) return null
     val codeBlock = CodeBlock.builder()
-        .addStatement("super.onUpgrade(x, v1, v2)")
 
     migrateFields.forEach {
       val migration = it.key.getAnnotation(Migrate::class.java)
@@ -107,6 +108,10 @@ class TableMigrationFieldGenerator(
         .addParameter(Integer::class.javaPrimitiveType, "v1")
         .addParameter(Integer::class.javaPrimitiveType, "v2")
         .addAnnotation(Override::class.java)
+        .addJavadoc("""
+          Migration callback, adds, deletes columns in this table
+          May also create indices
+        """.trimIndent())
         .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
         .addException(ClassName.get("promise.db", "TableError"))
         .addCode(codeBlock.build())
diff --git a/compiler/src/main/java/promise/db/ompiler/TableRegisteredColumnsMethodGenerator.kt b/compiler/src/main/java/promise/db/ompiler/TableRegisteredColumnsMethodGenerator.kt
index ec11918..71217d1 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableRegisteredColumnsMethodGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/TableRegisteredColumnsMethodGenerator.kt
@@ -52,6 +52,9 @@ class TableRegisteredColumnsMethodGenerator(
         .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
         .addAnnotation(Override::class.java)
         .addAnnotation(NotNull::class.java)
+        .addJavadoc("""
+          Registered columns for this table
+        """.trimIndent())
         .addCode(CodeBlock.of(stmt))
         .build()
 
diff --git a/compiler/src/main/java/promise/db/ompiler/TableRelationsGenerator.java b/compiler/src/main/java/promise/db/ompiler/TableRelationsGenerator.java
new file mode 100644
index 0000000..17ac144
--- /dev/null
+++ b/compiler/src/main/java/promise/db/ompiler/TableRelationsGenerator.java
@@ -0,0 +1,311 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db.ompiler;
+
+import com.squareup.javapoet.ArrayTypeName;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterSpec;
+import com.squareup.javapoet.ParameterizedTypeName;
+import com.squareup.javapoet.TypeName;
+import com.squareup.javapoet.TypeSpec;
+import com.squareup.javapoet.WildcardTypeName;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.ElementFilter;
+
+import kotlin.Pair;
+import promise.db.Entity;
+import promise.db.HasMany;
+import promise.db.HasOne;
+import promise.db.ompiler.utils.JavaUtils;
+import promise.db.ompiler.utils.PersistableEntityUtilsKt;
+import promise.db.ompiler.utils.Utils;
+import promise.db.ompiler.utils.UtilsKt;
+
+import static promise.db.ompiler.utils.PersistableEntityUtilsKt.asTableClassName;
+import static promise.db.ompiler.utils.PersistableEntityUtilsKt.camelCase;
+import static promise.db.ompiler.utils.PersistableEntityUtilsKt.capitalizeFirst;
+import static promise.db.ompiler.utils.PersistableEntityUtilsKt.getClassName;
+import static promise.db.ompiler.utils.PersistableEntityUtilsKt.pluralize;
+
+public class TableRelationsGenerator implements CodeGenerator<List<JavaFile.Builder>> {
+
+  private ProcessingEnvironment processingEnvironment;
+  private TypeElement element;
+  private List<VariableElement> relationElements;
+
+  private TypeSpec.Builder classBuilder;
+
+  /*
+   * Variable name for element
+   */
+  private String parentElementVarName;
+  /*
+   * pluralized version of parentElementVarName
+   */
+  private String parentElementVarNames;
+
+  private String getParentElementTableVarName;
+
+  public TableRelationsGenerator(ProcessingEnvironment processingEnvironment,
+                                 TypeElement element,
+                                 List<VariableElement> relationElements) {
+    this.processingEnvironment = processingEnvironment;
+    this.element = element;
+    this.relationElements = relationElements;
+    parentElementVarName = camelCase(element.getSimpleName().toString());
+    parentElementVarNames = pluralize(parentElementVarName);
+    getParentElementTableVarName = camelCase(getClassName(element));
+  }
+
+  @Override
+  public List<JavaFile.Builder> generate() throws Exception {
+    ArrayList<JavaFile.Builder> javaFiles = new ArrayList<>();
+    String className = element.getSimpleName().toString();
+    String pack = processingEnvironment.getElementUtils().getPackageOf(element).toString();
+    String fileName = className + "RelationsDao";
+    classBuilder = TypeSpec.classBuilder(fileName)
+        .addModifiers(Modifier.PUBLIC, Modifier.FINAL);
+    classBuilder.addField(FieldSpec.builder(
+        asTableClassName(element, processingEnvironment),
+        getParentElementTableVarName)
+        .addModifiers(Modifier.PRIVATE)
+        .build());
+    ArrayList<ParameterSpec> constructorParameters = new ArrayList<>();
+    ArrayList<Pair<String, String>> constructorInits = new ArrayList<>();
+    constructorParameters.add(ParameterSpec.builder(PersistableEntityUtilsKt.asTableClassName(element, processingEnvironment), getParentElementTableVarName).build());
+    relationElements.forEach(relationElement -> {
+      if (relationElement.getAnnotation(HasMany.class) != null) {
+        try {
+          Pair<String, String> pair = generateForHasManyRelation(relationElement, constructorParameters);
+          if (pair != null) constructorInits.add(pair);
+        } catch (Exception e) {
+          e.printStackTrace();
+        }
+      }
+      else if (relationElement.getAnnotation(HasOne.class) != null) {
+        generateForHasOneRelation(relationElement);
+      }
+    });
+    CodeBlock.Builder constructorBlock = CodeBlock.builder();
+    constructorBlock.addStatement("this." + getParentElementTableVarName + " = " + getParentElementTableVarName);
+    constructorInits.forEach(stringStringPair ->
+        constructorBlock.addStatement("this." + stringStringPair.getFirst() + " = " + stringStringPair.getSecond()));
+    classBuilder.addMethod(MethodSpec.constructorBuilder()
+        .addModifiers(Modifier.PUBLIC)
+        .addParameters(constructorParameters)
+        .addCode(constructorBlock.build())
+        .build());
+
+    javaFiles.add(JavaFile.builder(pack, classBuilder.build()));
+    javaFiles.add(Utils.INSTANCE.generateInstanceProviderHolder(ClassName.get(pack, fileName)));
+    return javaFiles;
+  }
+
+  /**
+   * generates fields and methods for HasMany relation of the given element
+   *
+   * @param hasManyRelationFieldElement element with HasMany relation
+   * @param constructorParameters
+   */
+  private Pair<String, String> generateForHasManyRelation(Element hasManyRelationFieldElement, ArrayList<ParameterSpec> constructorParameters) throws Exception {
+    if (JavaUtils.isCollectionType(processingEnvironment, (VariableElement) hasManyRelationFieldElement)) {
+      List<? extends TypeMirror> typeMirrors = JavaUtils.getParameterizedTypeMirrors((VariableElement) hasManyRelationFieldElement);
+      if (typeMirrors != null) {
+        /*
+         * Field name for the relation
+         */
+        String hasManyRelationFieldName = hasManyRelationFieldElement.getSimpleName().toString();
+        /*
+         * Element that this element is related to by HasMany relation
+         */
+        TypeElement relationElement = UtilsKt.asTypeElement(typeMirrors.get(0), processingEnvironment);
+        if (relationElement.getAnnotation(Entity.class) == null)
+          throw new Exception("Element related to " + element.getSimpleName() + " as HasMany in " + hasManyRelationFieldElement.getSimpleName() + " field is not marked as an Entity");
+        /*
+         * Table ClassName for relationElement
+         */
+        ClassName relationElementTableClassName = asTableClassName(relationElement, processingEnvironment);
+        /*
+         * Variable name for relationElementTableClassName
+         */
+        String relationElementTableVarName = camelCase(getClassName(relationElement));
+        /*
+         * Name of relationElement
+         */
+        String relationElementVarName = relationElement.getSimpleName().toString();
+        /*
+         * name of relation element for collection types
+         */
+        String relationElementVarNames = pluralize(relationElementVarName);
+
+        /*
+         * adding field for Table of child relation element
+         */
+
+        constructorParameters.add(ParameterSpec.builder(relationElementTableClassName, relationElementTableVarName).build());
+        classBuilder.addField(FieldSpec.builder(relationElementTableClassName, relationElementTableVarName)
+            .addModifiers(Modifier.PRIVATE)
+            .build());
+
+        classBuilder.addMethod(MethodSpec.methodBuilder("listWith" + capitalizeFirst(hasManyRelationFieldName))
+            .addModifiers(Modifier.PUBLIC)
+            .returns(ParameterizedTypeName.get(ClassName.get("promise.model", "IdentifiableList"),
+                WildcardTypeName.subtypeOf(
+                    ClassName.get(element.asType())
+                )
+            )).addCode(CodeBlock.builder()
+                .addStatement("IdentifiableList<? extends $T> " + parentElementVarNames + " = " + getParentElementTableVarName + ".findAll()", ClassName.get(element.asType()))
+                .beginControlFlow(parentElementVarNames + ".forEach(new $T<$T>()",
+                    ClassName.get("java.util.function", "Consumer"),
+                    ClassName.get(element.asType()))
+                .add("@Override\n")
+                .beginControlFlow("public void accept($T " + parentElementVarName + ")",
+                    ClassName.get(element.asType()))
+                .addStatement(parentElementVarName + ".set" + capitalizeFirst(hasManyRelationFieldName) + "(new $T<>(get" + capitalizeFirst(hasManyRelationFieldName) + "(" + parentElementVarName + ")))",
+                    ClassName.get("promise.model", "IdentifiableList"))
+                .endControlFlow()
+                .endControlFlow(")")
+                .addStatement("return " + parentElementVarNames)
+                .build())
+            .build());
+
+        classBuilder.addMethod(MethodSpec.methodBuilder("listWith" + capitalizeFirst(hasManyRelationFieldName))
+            .addParameter(ArrayTypeName.of(
+                ParameterizedTypeName.get(ClassName.get("promise.db", "Column"),
+                    WildcardTypeName.subtypeOf(TypeName.OBJECT))
+            ), "columns")
+            .addModifiers(Modifier.PUBLIC)
+            .returns(ParameterizedTypeName.get(ClassName.get("promise.model", "IdentifiableList"),
+                WildcardTypeName.subtypeOf(
+                    ClassName.get(element.asType())
+                )
+            )).addCode(CodeBlock.builder()
+                .addStatement("IdentifiableList<? extends $T> " + parentElementVarNames + " = " + getParentElementTableVarName + ".findAll(columns)", ClassName.get(element.asType()))
+                .beginControlFlow(parentElementVarNames + ".forEach(new $T<$T>()",
+                    ClassName.get("java.util.function", "Consumer"),
+                    ClassName.get(element.asType()))
+                .add("@Override\n")
+                .beginControlFlow("public void accept($T " + parentElementVarName + ")",
+                    ClassName.get(element.asType()))
+                .addStatement(parentElementVarName + ".set" + capitalizeFirst(hasManyRelationFieldName) + "(new $T<>(get" + capitalizeFirst(hasManyRelationFieldName) + "(" + parentElementVarName + ")))",
+                    ClassName.get("promise.model", "IdentifiableList"))
+                .endControlFlow()
+                .endControlFlow(")")
+                .addStatement("return " + parentElementVarNames)
+                .build())
+            .build());
+
+        VariableElement relationHasOneRelatedElement = null;
+        for (VariableElement elem : ElementFilter.fieldsIn(relationElement.getEnclosedElements()))
+          if (elem.getAnnotation(HasOne.class) != null && JavaUtils.isTypeEqual(elem.asType(), TypeName.get(element.asType())))
+            relationHasOneRelatedElement = elem;
+        if (relationHasOneRelatedElement == null)
+          throw new Exception(relationElement.getSimpleName() + "is marked as HasMany in  " + hasManyRelationFieldElement.getSimpleName() + " for " + element.getSimpleName() + " but it has no as HasOne relation field for " + element.getSimpleName());
+
+        classBuilder.addMethod(MethodSpec.methodBuilder("get" + capitalizeFirst(hasManyRelationFieldName))
+            .addParameter(TypeName.get(element.asType()), parentElementVarName)
+            .addModifiers(Modifier.PUBLIC)
+            .returns(ParameterizedTypeName.get(ClassName.get("promise.model", "IdentifiableList"),
+                WildcardTypeName.subtypeOf(
+                    ClassName.get(relationElement.asType())
+                )
+            ))
+            .addCode(CodeBlock.builder()
+                .addStatement("return " + relationElementTableVarName + ".findAll($T." + relationHasOneRelatedElement.getSimpleName() + "Column.with(" + parentElementVarName + ".getId()))", relationElementTableClassName)
+                .build())
+            .build());
+
+        classBuilder.addMethod(MethodSpec.methodBuilder("delete" + capitalizeFirst(hasManyRelationFieldName))
+            .returns(boolean.class)
+            .addModifiers(Modifier.PUBLIC)
+            .addParameter(TypeName.get(element.asType()), parentElementVarName)
+            .addCode(CodeBlock.builder()
+                .addStatement("return " + relationElementTableVarName + ".delete($T." + relationHasOneRelatedElement.getSimpleName() + "Column.with(" + parentElementVarName + ".getId()))", relationElementTableClassName)
+                .build())
+            .build());
+
+        classBuilder.addMethod(MethodSpec.methodBuilder("saveWith" + capitalizeFirst(hasManyRelationFieldName))
+            .addParameter(TypeName.get(element.asType()), parentElementVarName)
+            .addModifiers(Modifier.PUBLIC)
+            .returns(long.class)
+            .addCode(CodeBlock.builder()
+                .addStatement("long id = " + getParentElementTableVarName + ".save(" + parentElementVarName + ")")
+                .beginControlFlow(parentElementVarName + ".get" + capitalizeFirst(hasManyRelationFieldName) + "().forEach(new $T<$T>()",
+                    ClassName.get("java.util.function", "Consumer"),
+                    TypeName.get(relationElement.asType()))
+                .add("@Override\n")
+                .beginControlFlow("public void accept($T " + camelCase(relationElementVarName) + ")", TypeName.get(relationElement.asType()))
+                .addStatement("$T " + parentElementVarName + "1 = new $T()",
+                    TypeName.get(element.asType()),
+                    TypeName.get(element.asType()))
+                .addStatement(parentElementVarName + "1.setId((int) id)")
+                .addStatement(camelCase(relationElementVarName) + ".set" + capitalizeFirst(relationHasOneRelatedElement.getSimpleName().toString()) + "(" + parentElementVarName + "1)")
+                .endControlFlow()
+                .endControlFlow(")")
+                .addStatement(relationElementTableVarName + ".save(new $T<>(" + parentElementVarName + ".get" + capitalizeFirst(hasManyRelationFieldName) + "()))",
+                    ClassName.get("promise.model", "IdentifiableList"))
+                .addStatement("return id")
+                .build())
+            .build());
+
+        classBuilder.addMethod(MethodSpec.methodBuilder("saveWith" + capitalizeFirst(hasManyRelationFieldName))
+            .addParameter(ParameterizedTypeName.get(
+                ClassName.get("java.util", "List"),
+                WildcardTypeName.subtypeOf(TypeName.get(element.asType()))),
+                parentElementVarNames)
+            .addModifiers(Modifier.PUBLIC)
+            .returns(boolean.class)
+            .addCode(CodeBlock.builder()
+                .beginControlFlow(parentElementVarNames + ".forEach(new $T<$T>()",
+                    ClassName.get("java.util.function", "Consumer"),
+                    TypeName.get(element.asType()))
+                .add("@Override\n")
+                .beginControlFlow("public void accept($T " + parentElementVarName + ")", TypeName.get(element.asType()))
+                .addStatement("saveWith" + capitalizeFirst(hasManyRelationFieldName) + "(" + parentElementVarName + ")")
+                .endControlFlow()
+                .endControlFlow(")")
+                .addStatement("return true")
+                .build())
+            .build());
+
+        classBuilder.addMethod(MethodSpec.methodBuilder("updateWith" + capitalizeFirst(hasManyRelationFieldName))
+            .addModifiers(Modifier.PUBLIC)
+            .addParameter(TypeName.get(element.asType()), parentElementVarName)
+            .returns(boolean.class)
+            .addStatement("return (delete" + capitalizeFirst(hasManyRelationFieldName) + "(" + parentElementVarName + ") && saveWith" + capitalizeFirst(hasManyRelationFieldName) + "(" + parentElementVarName + ") > 0)")
+            .build());
+
+        return new Pair<>(relationElementTableVarName, relationElementTableVarName);
+      }
+    }
+    return null;
+  }
+
+  private void generateForHasOneRelation(Element hasOneRelationFieldElement) {
+
+  }
+}
diff --git a/compiler/src/main/java/promise/db/ompiler/TableSerializerMethodGenerator.kt b/compiler/src/main/java/promise/db/ompiler/TableSerializerMethodGenerator.kt
index 28f1b9e..1527c2a 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableSerializerMethodGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/TableSerializerMethodGenerator.kt
@@ -16,11 +16,17 @@ package promise.db.ompiler
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
 import com.squareup.javapoet.MethodSpec
+import promise.db.ompiler.utils.ConverterTypes
+import promise.db.ompiler.utils.JavaUtils
+import promise.db.ompiler.utils.capitalizeFirst
+import promise.db.ompiler.utils.checkIfHasTypeConverter
+import promise.db.ompiler.utils.getConverterCompatibleMethod
+import promise.db.ompiler.utils.isElementAnnotatedAsRelation
+import promise.db.ompiler.utils.isSameAs
+import promise.db.ompiler.utils.toTypeName
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
-import javax.lang.model.element.TypeElement
-import javax.tools.Diagnostic
 
 
 class TableSerializerMethodGenerator(
@@ -43,8 +49,9 @@ class TableSerializerMethodGenerator(
 
     return MethodSpec.methodBuilder("serialize")
         .addModifiers(Modifier.PUBLIC)
-        .addParameter(ClassName.get(typeDataTypePack, typeDataType),"t")
+        .addParameter(ClassName.get(typeDataTypePack, typeDataType), "t")
         .addAnnotation(Override::class.java)
+        .addJavadoc("Serializer converts from the entity to ContentValues")
         .returns(ClassName.get("android.content", "ContentValues"))
         .addCode(codeBlock.build())
         .build()
@@ -68,8 +75,7 @@ class TableSerializerMethodGenerator(
       if (executableFn != null) {
         codeBlock.addStatement("values.put(${columnName}.getName(), typeConverter.${executableFn.simpleName}(t.get${typeVariable.capitalizeFirst()}()))")
       }
-    }
-    else if (varTypeName.isElementAnnotatedAsRelation()) {
+    } else if (varTypeName.isElementAnnotatedAsRelation()) {
 //            processingEnvironment.messager.printMessage(Diagnostic.Kind.ERROR,
 //         "serializer Checking element: $varTypeName for typeName $varTypeName " )
       val gen = """
@@ -80,8 +86,7 @@ class TableSerializerMethodGenerator(
       """.trimIndent()
       codeBlock.add(JavaUtils.generateSerializerRelationPutStatement(varTypeName, columnName))
       //return "values.put(${columnName}.getName(), t.get${typeVariable.capitalizeFirst()}()); \n"
-    }
-    else codeBlock.addStatement("values.put(${columnName}.getName(), t.get${typeVariable.capitalizeFirst()}())")
+    } else codeBlock.addStatement("values.put(${columnName}.getName(), t.get${typeVariable.capitalizeFirst()}())")
     //throw Exception("Could not generate serializer method for entity")
   }
 
diff --git a/compiler/src/main/java/promise/db/ompiler/TypeConverterAnnotatedProcessor.kt b/compiler/src/main/java/promise/db/ompiler/TypeConverterAnnotatedProcessor.kt
new file mode 100644
index 0000000..06c58b0
--- /dev/null
+++ b/compiler/src/main/java/promise/db/ompiler/TypeConverterAnnotatedProcessor.kt
@@ -0,0 +1,110 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db.ompiler
+
+import com.squareup.javapoet.ClassName
+import com.squareup.javapoet.JavaFile
+import promise.db.TypeConverter
+import promise.db.ompiler.utils.Utils
+import java.util.*
+import javax.annotation.processing.ProcessingEnvironment
+import javax.annotation.processing.RoundEnvironment
+import javax.lang.model.element.TypeElement
+import javax.tools.Diagnostic
+
+
+class TypeConverterAnnotatedProcessor(private val processingEnv: ProcessingEnvironment) : AnnotatedClassProcessor() {
+
+  override fun process(environment: RoundEnvironment?): List<JavaFile.Builder?>? {
+    val typeConverters = environment?.getElementsAnnotatedWith(TypeConverter::class.java)
+    if (typeConverters != null) {
+      if (typeConverters.size > 1) processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "There can only be one typeConverter in the module")
+      else try {
+        typeConverter = typeConverters.firstOrNull() as TypeElement
+        return Collections.singletonList(processElement(typeConverter!!))
+      } catch (e: Throwable) {
+
+      }
+    }
+    return null
+  }
+
+  private fun processElement(element: TypeElement): JavaFile.Builder {
+    val className = element.simpleName.toString()
+   val pack = processingEnv.elementUtils.getPackageOf(element).toString()
+    return Utils.generateInstanceProviderHolder(ClassName.get(pack, className))
+//    val className = element.simpleName.toString()
+//    val pack = processingEnv.elementUtils.getPackageOf(element).toString()
+//
+//    val fileName = element.getTypeConverterClassName()
+//
+//    val varName = element.getVariableName()
+//
+//    val classBuilder = TypeSpec.classBuilder(fileName)
+//        .addJavadoc("""
+//          Class holder for instantiation of TypeConverter
+//        """.trimIndent())
+//        .addModifiers(Modifier.FINAL, Modifier.PUBLIC)
+//        .addSuperinterface(ParameterizedTypeName.get(
+//            ClassName.get("promise.commons", "InstanceProvider"),
+//            ClassName.get(pack, className)
+//        ))
+//        // field instance for the holder
+//        .addField(FieldSpec.builder(
+//            ClassName.get(pack, fileName),
+//            "instance"
+//        ).addModifiers(Modifier.PRIVATE, Modifier.STATIC)
+//            .build())
+//        // holder for type converter
+//        .addField(FieldSpec.builder(element.toTypeName(), varName,
+//            Modifier.FINAL, Modifier.PRIVATE)
+//            .addJavadoc("""
+//              holder instance for the TypeConverter
+//            """.trimIndent())
+//            .build())
+//        // constructor for the holder
+//        .addMethod(MethodSpec.constructorBuilder()
+//            .addModifiers(Modifier.PRIVATE)
+//            .addParameter(ClassName.get(pack, className), varName)
+//            .addStatement("this.$varName = $varName")
+//            .build())
+//        .addMethod(MethodSpec.methodBuilder("create")
+//            .returns(ClassName.get(pack, fileName))
+//            .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
+//            .addJavadoc("""
+//              Creates an instance of the holder with the converter
+//            """.trimIndent())
+//            .addParameter(
+//                ClassName.get(pack, className),
+//                varName)
+//            .addCode(CodeBlock.builder()
+//                .addStatement("if (instance == null) instance = new $fileName($varName)")
+//                .addStatement("return instance")
+//                .build())
+//            .build())
+//        .addMethod(MethodSpec.methodBuilder("get")
+//            .addAnnotation(Override::class.java)
+//            .returns(ClassName.get(pack, className))
+//            .addModifiers(Modifier.PUBLIC)
+//            .addCode("return $varName;")
+//            .build())
+//
+//    return JavaFile.builder(pack, classBuilder.build())
+  }
+
+  companion object {
+    var typeConverter: TypeElement? = null
+
+  }
+}
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/db/ompiler/TypeConverterProcessor.kt b/compiler/src/main/java/promise/db/ompiler/TypeConverterProcessor.kt
deleted file mode 100644
index d10ccc5..0000000
--- a/compiler/src/main/java/promise/db/ompiler/TypeConverterProcessor.kt
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
- * Copyright 2017, Peter Vincent
- * Licensed under the Apache License, Version 2.0, Android Promise.
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package promise.db.ompiler
-
-import com.squareup.javapoet.ClassName
-import com.squareup.javapoet.CodeBlock
-import com.squareup.javapoet.FieldSpec
-import com.squareup.javapoet.JavaFile
-import com.squareup.javapoet.MethodSpec
-import com.squareup.javapoet.ParameterizedTypeName
-import com.squareup.javapoet.TypeSpec
-import promise.db.TypeConverter
-import java.util.*
-import javax.annotation.processing.ProcessingEnvironment
-import javax.annotation.processing.RoundEnvironment
-import javax.lang.model.element.Modifier
-import javax.lang.model.element.TypeElement
-import javax.tools.Diagnostic
-
-fun TypeElement.getTypeConverterClassName(): String {
-  val className = this.simpleName.toString()
-  return "${className}InstanceProvider"
-}
-
-fun TypeElement.getVariableName(): String {
-  val className = this.simpleName.toString()
-  return className.camelCase();
-}
-
-class TypeConverterProcessor(private val processingEnv: ProcessingEnvironment) : ClassProcessor() {
-
-  override fun process(environment: RoundEnvironment?): List<JavaFile.Builder?>? {
-    val typeConverters = environment?.getElementsAnnotatedWith(TypeConverter::class.java)
-    if (typeConverters != null) {
-      if (typeConverters.size > 1) processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "There can only be one typeConverter in the module")
-      else try {
-        typeConverter = typeConverters.firstOrNull() as TypeElement
-        return Collections.singletonList(processElement(typeConverter!!))
-      } catch (e: Throwable) {
-
-      }
-    }
-    return null
-  }
-
-  private fun processElement(element: TypeElement): JavaFile.Builder {
-    val className = element.simpleName.toString()
-    val pack = processingEnv.elementUtils.getPackageOf(element).toString()
-
-    val fileName = element.getTypeConverterClassName()
-
-    val varName = element.getVariableName()
-
-    val classBuilder = TypeSpec.classBuilder(fileName)
-        .addJavadoc("""
-          Class holder for instantiation of TypeConverter
-        """.trimIndent())
-        .addModifiers(Modifier.FINAL, Modifier.PUBLIC)
-        .addSuperinterface(ParameterizedTypeName.get(
-            ClassName.get("promise.commons", "InstanceProvider"),
-            ClassName.get(pack, className)
-        ))
-        // field instance for the holder
-        .addField(FieldSpec.builder(
-            ClassName.get(pack, fileName),
-            "instance"
-        ).addModifiers(Modifier.PRIVATE, Modifier.STATIC)
-            .build())
-        // holder for type converter
-        .addField(FieldSpec.builder(element.toTypeName(), varName,
-            Modifier.FINAL, Modifier.PRIVATE)
-            .addJavadoc("""
-              holder instance for the TypeConverter
-            """.trimIndent())
-            .build())
-        // constructor for the holder
-        .addMethod(MethodSpec.constructorBuilder()
-            .addModifiers(Modifier.PRIVATE)
-            .addParameter(ClassName.get(pack, className), varName)
-            .addStatement("this.$varName = $varName")
-            .build())
-        .addMethod(MethodSpec.methodBuilder("create")
-            .returns(ClassName.get(pack, fileName))
-            .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
-            .addParameter(
-                ClassName.get(pack, className),
-                varName)
-            .addCode(CodeBlock.builder()
-                .addStatement("if (instance == null) instance = new $fileName($varName)")
-                .addStatement("return instance")
-                .build())
-            .build())
-        .addMethod(MethodSpec.methodBuilder("get")
-            .addAnnotation(Override::class.java)
-            .returns(ClassName.get(pack, className))
-            .addModifiers(Modifier.PUBLIC)
-            .addCode("return $varName;")
-            .build())
-
-
-    return JavaFile.builder(pack, classBuilder.build())
-  }
-
-  companion object {
-    var typeConverter: TypeElement? = null
-
-  }
-}
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/db/ompiler/JavaUtils.java b/compiler/src/main/java/promise/db/ompiler/utils/JavaUtils.java
similarity index 56%
rename from compiler/src/main/java/promise/db/ompiler/JavaUtils.java
rename to compiler/src/main/java/promise/db/ompiler/utils/JavaUtils.java
index c67dfb3..ea5f7d6 100644
--- a/compiler/src/main/java/promise/db/ompiler/JavaUtils.java
+++ b/compiler/src/main/java/promise/db/ompiler/utils/JavaUtils.java
@@ -11,15 +11,17 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler;
+package promise.db.ompiler.utils;
 
 import com.squareup.javapoet.ClassName;
 import com.squareup.javapoet.CodeBlock;
 import com.squareup.javapoet.FieldSpec;
 import com.squareup.javapoet.MethodSpec;
 import com.squareup.javapoet.TypeName;
-import com.sun.tools.javac.jvm.Code;
 
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -28,11 +30,17 @@
 import javax.lang.model.element.Element;
 import javax.lang.model.element.Modifier;
 import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
 import javax.lang.model.type.DeclaredType;
 import javax.lang.model.type.TypeKind;
 import javax.lang.model.type.TypeMirror;
+import javax.lang.model.type.WildcardType;
 
 public class JavaUtils {
+
+  // code generation participants
+
+  // end of code generation participants
   private static final Map<Class<?>, Class<?>> PRIMITIVES_TO_WRAPPERS
       = new HashMap<Class<?>, Class<?>>() {{
     put(boolean.class, Boolean.class);
@@ -46,12 +54,16 @@ public class JavaUtils {
     put(void.class, Void.class);
   }};
 
+  /**
+   * @param element
+   * @return
+   */
   public static FieldSpec generateEntityTableLogField(Element element) {
     return FieldSpec.builder(
         String.class, "TAG")
         .addModifiers(Modifier.STATIC, Modifier.PRIVATE, Modifier.FINAL)
-        .initializer("$T.makeTag(" +element.getSimpleName() +".class)",
-            ClassName.get("promise.commons.data.log","LogUtil" ))
+        .initializer("$T.makeTag(" + element.getSimpleName() + ".class)",
+            ClassName.get("promise.commons.data.log", "LogUtil"))
         .build();
   }
 
@@ -62,7 +74,7 @@ public static void generateAddConverterStatementInDatabaseConstructorMethod(
     String pack = processingEnvironment.getElementUtils().getPackageOf(converter).toString();
     constructorMethod.addStatement("this.typeConverter = $T.provider($T.create(new $T())).get()",
         ClassName.get("promise.commons", "SingletonInstanceProvider"),
-        ClassName.get(pack, TypeConverterProcessorKt.getTypeConverterClassName(converter)),
+        ClassName.get(pack, UtilsKt.getInstanceProviderClassName(converter.getSimpleName().toString())),
         UtilsKt.toTypeName(converter));
   }
 
@@ -73,33 +85,29 @@ public static void generateIfStatementObtainClassString(
     String pack = processingEnv.getElementUtils().getPackageOf(entity).toString();
     if (PersistableEntityUtilsKt.checkIfAnyElementNeedsTypeConverter(entity)) {
       String tableVarName = PersistableEntityUtilsKt.camelCase(PersistableEntityUtilsKt.getClassName(entity));
-      String stmt = "if (entityClass == Exam.class) {\n" +
-          "      ExamsTable examsTable = getDatabaseInstance().obtain(ExamsTable.class);\n" +
-          "      examsTable.setTypeConverter(typeConverter);\n" +
-          "      return (FastTable<T>) examsTable;\n" +
-          "    }";
+
       codeBlock.beginControlFlow("if (entityClass == $T.class)", ClassName.get(pack, entity.getSimpleName().toString()));
-      codeBlock.addStatement("$T "+tableVarName+" = getDatabaseInstance().obtain($T.class)",
+      codeBlock.addStatement("$T " + tableVarName + " = getDatabaseInstance().obtain($T.class)",
           ClassName.get(pack, PersistableEntityUtilsKt.getClassName(entity)),
           ClassName.get(pack, PersistableEntityUtilsKt.getClassName(entity)));
       codeBlock.addStatement(tableVarName + ".setTypeConverter(typeConverter)");
-      codeBlock.addStatement("return (FastTable<T>) "+tableVarName);
+      codeBlock.addStatement("return (FastTable<T>) " + tableVarName);
       codeBlock.endControlFlow();
-    }
-    else codeBlock.addStatement("if (entityClass == $T.class) return getDatabaseInstance().obtain($T.class)",
-        ClassName.get(pack, entity.getSimpleName().toString()),
-        ClassName.get(pack, PersistableEntityUtilsKt.getClassName(entity)));
+    } else
+      codeBlock.addStatement("if (entityClass == $T.class) return getDatabaseInstance().obtain($T.class)",
+          ClassName.get(pack, entity.getSimpleName().toString()),
+          ClassName.get(pack, PersistableEntityUtilsKt.getClassName(entity)));
   }
 
   public static CodeBlock generateSerializerRelationPutStatement(Element element, String colName) {
-    CodeBlock.Builder codeBlock =  CodeBlock.builder();
+    CodeBlock.Builder codeBlock = CodeBlock.builder();
     String variableName = PersistableEntityUtilsKt.camelCase(element.getSimpleName().toString());
-    codeBlock.addStatement("$T "+ variableName+ " = t.get"+PersistableEntityUtilsKt.capitalizeFirst(element.getSimpleName().toString())+"()", TypeName.get(element.asType()));
-    codeBlock.beginControlFlow("if("+variableName+" != null)");
-    codeBlock.addStatement("values.put("+colName+".getName(), "+variableName+".getId())");
+    codeBlock.addStatement("$T " + variableName + " = t.get" + PersistableEntityUtilsKt.capitalizeFirst(element.getSimpleName().toString()) + "()", TypeName.get(element.asType()));
+    codeBlock.beginControlFlow("if(" + variableName + " != null)");
+    codeBlock.addStatement("values.put(" + colName + ".getName(), " + variableName + ".getId())");
     codeBlock.endControlFlow();
     codeBlock.beginControlFlow("else");
-    codeBlock.addStatement("values.put("+colName+".getName(), 0)");
+    codeBlock.addStatement("values.put(" + colName + ".getName(), 0)");
     codeBlock.endControlFlow();
     return codeBlock.build();
   }
@@ -115,16 +123,16 @@ public static CodeBlock generateDeserializerRelationSetStatement(
         "        person.setId(personId);\n" +
         "        dog.setPerson(person);\n" +
         "      }";
-    CodeBlock.Builder codeBlock =  CodeBlock.builder();
+    CodeBlock.Builder codeBlock = CodeBlock.builder();
     String variableName = PersistableEntityUtilsKt.camelCase(element.getSimpleName().toString());
     String variableNameId = variableName + "Id";
-    codeBlock.addStatement("int "+ variableNameId+ " = e.getInt("+colName+".getIndex(e))");
-    codeBlock.beginControlFlow("if("+variableNameId+" != 0)");
-    codeBlock.addStatement("$T "+variableName+ " = new $T()",
+    codeBlock.addStatement("int " + variableNameId + " = e.getInt(" + colName + ".getIndex(e))");
+    codeBlock.beginControlFlow("if(" + variableNameId + " != 0)");
+    codeBlock.addStatement("$T " + variableName + " = new $T()",
         TypeName.get(element.asType()),
         TypeName.get(element.asType()));
-    codeBlock.addStatement(variableName + ".setId("+variableNameId+")");
-    codeBlock.addStatement(entitySetName+".set"+PersistableEntityUtilsKt.capitalizeFirst(element.getSimpleName().toString())+"("+variableName+")");
+    codeBlock.addStatement(variableName + ".setId(" + variableNameId + ")");
+    codeBlock.addStatement(entitySetName + ".set" + PersistableEntityUtilsKt.capitalizeFirst(element.getSimpleName().toString()) + "(" + variableName + ")");
     codeBlock.endControlFlow();
     return codeBlock.build();
   }
@@ -133,7 +141,7 @@ public static void generateCatchSQliteExceptionBlockForDeserializer(CodeBlock.Bu
     codeBlock.beginControlFlow("catch($T ex)",
         ClassName.get("android.database", "CursorIndexOutOfBoundsException"));
     codeBlock.addStatement("LogUtil.e(TAG, \"deserialize\", ex)");
-    codeBlock.addStatement("return new "+typeDataType+"()");
+    codeBlock.addStatement("return new " + typeDataType + "()");
   }
 
   public static void generateDatabaseMigrationOverrideControlBlock(CodeBlock.Builder codeBlock) {
@@ -147,7 +155,13 @@ public static <T> Class<T> wrap(Class<T> c) {
     return c.isPrimitive() ? (Class<T>) PRIMITIVES_TO_WRAPPERS.get(c) : c;
   }
 
-
+  /**
+   * gets the super class for type element
+   *
+   * @param typeElement to be checked for super class
+   * @return superclass or null
+   */
+  @Nullable
   public static TypeElement getSuperClass(TypeElement typeElement) {
     TypeMirror type = typeElement.getSuperclass();
     if (type.getKind() == TypeKind.NONE) {
@@ -156,61 +170,81 @@ public static TypeElement getSuperClass(TypeElement typeElement) {
     return (TypeElement) ((DeclaredType) type).asElement();
   }
 
-  static boolean isTypeEqual(TypeMirror typeMirror, TypeName otherType) {
+  /**
+   * checks if typemirror is equal to a typename
+   *
+   * @param typeMirror
+   * @param otherType
+   * @return
+   */
+  public static boolean isTypeEqual(TypeMirror typeMirror, TypeName otherType) {
     if (typeMirror.getKind() == TypeKind.NONE || otherType == TypeName.VOID ||
-    typeMirror.getKind() == TypeKind.VOID) {
+        typeMirror.getKind() == TypeKind.VOID) {
       return false;
     }
     return otherType.toString().equals(TypeName.get(typeMirror).toString());
   }
 
-  static boolean isSubtypeOfType(TypeMirror typeMirror, TypeName otherType) {
-    if (typeMirror.getKind() == TypeKind.NONE) {
-      return false;
-    }
-    if (isTypeEqual(typeMirror, otherType)) {
-      return true;
-    }
-    if (typeMirror.getKind() != TypeKind.DECLARED) {
-      return false;
-    }
+  /**
+   * checks if type mirror is a sub type of other type
+   *
+   * @param typeMirror
+   * @param otherType
+   * @return
+   */
+  public static boolean isSubTypeOfType(TypeMirror typeMirror, TypeName otherType) {
+    if (typeMirror.getKind() == TypeKind.NONE) return false;
+    if (isTypeEqual(typeMirror, otherType)) return true;
+    if (typeMirror.getKind() != TypeKind.DECLARED) return false;
     DeclaredType declaredType = (DeclaredType) typeMirror;
     List<? extends TypeMirror> typeArguments = declaredType.getTypeArguments();
     if (typeArguments.size() > 0) {
       StringBuilder typeString = new StringBuilder(declaredType.asElement().toString());
       typeString.append('<');
       for (int i = 0; i < typeArguments.size(); i++) {
-        if (i > 0) {
-          typeString.append(',');
-        }
+        if (i > 0) typeString.append(',');
         typeString.append('?');
       }
       typeString.append('>');
-      if (typeString.toString().equals(otherType.toString())) {
-        return true;
-      }
+      if (typeString.toString().equals(otherType.toString())) return true;
     }
     Element element = declaredType.asElement();
-    if (!(element instanceof TypeElement)) {
-      return false;
-    }
+    if (!(element instanceof TypeElement)) return false;
     TypeElement typeElement = (TypeElement) element;
     TypeMirror superType = typeElement.getSuperclass();
-    if (isSubtypeOfType(superType, otherType)) {
-      return true;
-    }
-    for (TypeMirror interfaceType : typeElement.getInterfaces()) {
-      if (isSubtypeOfType(interfaceType, otherType)) {
-        return true;
-      }
-    }
+    if (isSubTypeOfType(superType, otherType)) return true;
+    for (TypeMirror interfaceType : typeElement.getInterfaces())
+      if (isSubTypeOfType(interfaceType, otherType)) return true;
     return false;
   }
 
-  public static boolean extendsClass(
-      TypeElement myTypeElement,
-      TypeMirror desiredInterface) {
-    return myTypeElement.getSuperclass().toString().equals(desiredInterface.toString());
+  public static DeclaredType getDeclaredType(ProcessingEnvironment processingEnvironment, TypeElement typeElement) {
+    return processingEnvironment.getTypeUtils().getDeclaredType(typeElement);
+  }
 
+  public static boolean isSubTypeOfDeclaredType(ProcessingEnvironment processingEnvironment, Element typeElement, DeclaredType declaredType) {
+    return processingEnvironment.getTypeUtils().isAssignable(typeElement.asType(), declaredType);
+  }
+
+  public static DeclaredType toWildCardType(ProcessingEnvironment processingEnvironment, TypeElement typeElement, int wildTimes) {
+    WildcardType WILDCARD_TYPE_NULL = processingEnvironment.getTypeUtils().getWildcardType(null, null);
+    TypeMirror[] mirrors = new TypeMirror[wildTimes];
+    for (int i = 0; i < wildTimes; i++) mirrors[i] = WILDCARD_TYPE_NULL;
+    return processingEnvironment.getTypeUtils().getDeclaredType(typeElement, mirrors);
+  }
+
+  public static boolean isCollectionType(ProcessingEnvironment processingEnvironment, VariableElement variableElement) {
+    DeclaredType collectionType = toWildCardType(processingEnvironment,
+        processingEnvironment.getElementUtils().getTypeElement(Collection.class.getName()),
+        1);
+    return isSubTypeOfDeclaredType(processingEnvironment, variableElement, collectionType);
+  }
+
+  public static List<? extends TypeMirror> getParameterizedTypeMirrors(VariableElement variableElement) {
+    if (variableElement.asType() instanceof DeclaredType) {
+      DeclaredType declaredType = (DeclaredType) variableElement.asType();
+      return declaredType.getTypeArguments();
+    }
+    return null;
   }
 }
diff --git a/compiler/src/main/java/promise/db/ompiler/PersistableEntityUtils.kt b/compiler/src/main/java/promise/db/ompiler/utils/PersistableEntityUtils.kt
similarity index 89%
rename from compiler/src/main/java/promise/db/ompiler/PersistableEntityUtils.kt
rename to compiler/src/main/java/promise/db/ompiler/utils/PersistableEntityUtils.kt
index 039bce0..2bb4b06 100644
--- a/compiler/src/main/java/promise/db/ompiler/PersistableEntityUtils.kt
+++ b/compiler/src/main/java/promise/db/ompiler/utils/PersistableEntityUtils.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler
+package promise.db.ompiler.utils
 
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.TypeName
@@ -25,8 +25,8 @@ import promise.db.HasOne
 import promise.db.Index
 import promise.db.Text
 import promise.db.VarChar
+import promise.db.ompiler.TypeConverterAnnotatedProcessor
 import java.io.IOException
-import java.util.*
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.ExecutableElement
@@ -34,7 +34,6 @@ import javax.lang.model.element.TypeElement
 import javax.lang.model.type.TypeKind
 import javax.lang.model.type.TypeMirror
 import javax.lang.model.util.ElementFilter
-import javax.tools.Diagnostic
 
 /**
  * gets the className for type element
@@ -101,7 +100,7 @@ fun TypeElement.getTableForeignKeys(processingEnv: ProcessingEnvironment): Array
         val entityClass = ((annotationValue as Attribute.Class).classType as TypeMirror).asTypeElement(processingEnv)
         val refColName = Utils.getAnnotationValue(foreignKeyAnnotationMirror, "referencedEntityColumnName")
         mapOf(Pair("columnName", it.getNameOfColumn()),
-            Pair("referencedColumnName", if (refColName != null ) refColName.value as String else "id"),
+            Pair("referencedColumnName", if (refColName != null) refColName.value as String else "id"),
             Pair("referencedTableName", entityClass.getTableName()))
       }
   if (fields.isNullOrEmpty()) return null
@@ -146,11 +145,9 @@ fun Element.getNameOfColumn(): String {
   } else if (this.toTypeName().isSameAs(String::class.java) &&
       this.getAnnotation(promise.db.VarChar::class.java) != null) {
     name = this.getAnnotation(promise.db.VarChar::class.java).columnName
-  }
-  else if (this.getAnnotation(Text::class.java) != null) {
+  } else if (this.getAnnotation(Text::class.java) != null) {
     name = this.getAnnotation(Text::class.java).columnName
-  }
-  else if (this.getAnnotation(VarChar::class.java) != null) {
+  } else if (this.getAnnotation(VarChar::class.java) != null) {
     name = this.getAnnotation(VarChar::class.java).columnName
   }
   if (name != null && name.isNotEmpty()) return name
@@ -171,15 +168,15 @@ fun TypeElement.checkIfAnyElementNeedsTypeConverter(): Boolean = ElementFilter.f
 
 fun Element.checkIfHasTypeConverter(): Boolean {
   //return true
-  if (TypeConverterProcessor.typeConverter != null)
+  if (TypeConverterAnnotatedProcessor.typeConverter != null)
     return this.getConverterCompatibleMethod(ConverterTypes.SERIALIZER) != null &&
-      this.getConverterCompatibleMethod(ConverterTypes.DESERIALIZER) != null
+        this.getConverterCompatibleMethod(ConverterTypes.DESERIALIZER) != null
   return false
 }
 
 fun Element.checkIfHasTypeConverter(processingEnv: ProcessingEnvironment): Boolean {
   //return true
-  if (TypeConverterProcessor.typeConverter != null)
+  if (TypeConverterAnnotatedProcessor.typeConverter != null)
     return this.getConverterCompatibleMethod(ConverterTypes.SERIALIZER, processingEnv) != null &&
         this.getConverterCompatibleMethod(ConverterTypes.DESERIALIZER, processingEnv) != null
   return false
@@ -191,13 +188,13 @@ enum class ConverterTypes {
 }
 
 fun Element.getConverterCompatibleMethod(converterTypes: ConverterTypes): ExecutableElement? {
-  if (TypeConverterProcessor.typeConverter != null) {
+  if (TypeConverterAnnotatedProcessor.typeConverter != null) {
     val methods =
-        ElementFilter.methodsIn(TypeConverterProcessor.typeConverter!!.enclosedElements)
+        ElementFilter.methodsIn(TypeConverterAnnotatedProcessor.typeConverter!!.enclosedElements)
             .filter { it.parameters.size == 1 }
     return methods.find {
       if (this.asType().kind == TypeKind.VOID) return@find false
-      when(converterTypes) {
+      when (converterTypes) {
         ConverterTypes.DESERIALIZER -> {
 
           JavaUtils.isTypeEqual(it.parameters[0].asType(), TypeName.get(String::class.java)) &&
@@ -209,17 +206,17 @@ fun Element.getConverterCompatibleMethod(converterTypes: ConverterTypes): Execut
         }
       }
     }
-  }
-    else return null
+  } else return null
 }
 
 
 fun Element.getConverterCompatibleMethod(converterTypes: ConverterTypes, processingEnv: ProcessingEnvironment): ExecutableElement? {
-  if (TypeConverterProcessor.typeConverter != null) {
+  if (TypeConverterAnnotatedProcessor.typeConverter != null) {
     val methods =
-        ElementFilter.methodsIn(TypeConverterProcessor.typeConverter!!.enclosedElements)
+        ElementFilter.methodsIn(TypeConverterAnnotatedProcessor.typeConverter!!.enclosedElements)
             .filter {
-              it.parameters.size == 1 }
+              it.parameters.size == 1
+            }
     return methods.find {
       if (this.asType().kind == TypeKind.VOID) return@find false
 //      processingEnv.messager.printMessage(Diagnostic.Kind.NOTE, "Type converter: " +
@@ -227,7 +224,7 @@ fun Element.getConverterCompatibleMethod(converterTypes: ConverterTypes, process
 //          " returnType: ${TypeName.get(it.returnType)}" +
 //          " parameter: ${TypeName.get(it.parameters[0].asType())}" +
 //          " elementType ${TypeName.get(this.asType())}")
-      when(converterTypes) {
+      when (converterTypes) {
         ConverterTypes.DESERIALIZER -> {
 
           JavaUtils.isTypeEqual(it.parameters[0].asType(), TypeName.get(String::class.java)) &&
@@ -239,16 +236,16 @@ fun Element.getConverterCompatibleMethod(converterTypes: ConverterTypes, process
         }
       }
     }
-  }
-  else return null
+  } else return null
 }
+
 fun Element.isElementAnnotatedAsRelation(): Boolean {
   //return false
   return this.getAnnotation(HasMany::class.java) != null ||
-     this.getAnnotation(HasOne::class.java) != null
+      this.getAnnotation(HasOne::class.java) != null
 }
 
- fun Element.isPersistable(): Boolean = try {
+fun Element.isPersistable(): Boolean = try {
   this.toTypeName().isSameAs(Integer::class.java) ||
       this.toTypeName().isSameAs(String::class.java) ||
       this.toTypeName().isSameAs(Float::class.java) ||
diff --git a/compiler/src/main/java/promise/db/ompiler/Utils.kt b/compiler/src/main/java/promise/db/ompiler/utils/Utils.kt
similarity index 65%
rename from compiler/src/main/java/promise/db/ompiler/Utils.kt
rename to compiler/src/main/java/promise/db/ompiler/utils/Utils.kt
index 29bfa37..caeddc2 100644
--- a/compiler/src/main/java/promise/db/ompiler/Utils.kt
+++ b/compiler/src/main/java/promise/db/ompiler/utils/Utils.kt
@@ -11,9 +11,16 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler
+package promise.db.ompiler.utils
 
+import com.squareup.javapoet.ClassName
+import com.squareup.javapoet.CodeBlock
+import com.squareup.javapoet.FieldSpec
+import com.squareup.javapoet.JavaFile
+import com.squareup.javapoet.MethodSpec
+import com.squareup.javapoet.ParameterizedTypeName
 import com.squareup.javapoet.TypeName
+import com.squareup.javapoet.TypeSpec
 import java.io.PrintWriter
 import java.io.StringWriter
 import java.net.UnknownHostException
@@ -22,13 +29,13 @@ import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.AnnotationMirror
 import javax.lang.model.element.AnnotationValue
 import javax.lang.model.element.Element
+import javax.lang.model.element.ExecutableElement
+import javax.lang.model.element.Modifier
 import javax.lang.model.element.TypeElement
 import javax.lang.model.element.VariableElement
-import javax.lang.model.type.DeclaredType
 import javax.lang.model.type.MirroredTypeException
 import javax.lang.model.type.TypeKind
 import javax.lang.model.type.TypeMirror
-import javax.lang.model.util.ElementFilter
 import javax.lang.model.util.Types
 import javax.tools.Diagnostic
 import kotlin.reflect.KClass
@@ -82,9 +89,22 @@ fun TypeMirror.asTypeElement(processingEnv: ProcessingEnvironment): TypeElement
   }) as TypeElement
 }
 
+fun String.getInstanceProviderClassName(): String {
+  return "${this}InstanceProvider"
+}
 
 object Utils {
 
+  fun getAnnotationMirror(typeElement: ExecutableElement, clazz: Class<*>): AnnotationMirror? {
+    val clazzName = clazz.name
+    for (m in typeElement.annotationMirrors) {
+      if (m.annotationType.toString() == clazzName) {
+        return m
+      }
+    }
+    return null
+  }
+
   fun getAnnotationMirror(typeElement: TypeElement, clazz: Class<*>): AnnotationMirror? {
     val clazzName = clazz.name
     for (m in typeElement.annotationMirrors) {
@@ -178,4 +198,74 @@ object Utils {
     if (`object` is DoubleArray) return Arrays.toString(`object` as DoubleArray?)
     return if (`object` is Array<*>) Arrays.deepToString(`object` as Array<Any?>?) else "Couldn't find a correct type for the object"
   }
+
+  /**
+   * generates provider for element Typename
+   */
+  fun generateInstanceProviderHolder(
+      /**
+       * Typename for this provider
+       */
+      element: ClassName
+      ): JavaFile.Builder {
+
+    val className = element.simpleName()
+
+    val pack = element.packageName()
+
+    val varName = className.camelCase()
+
+    val fileName = className.getInstanceProviderClassName()
+
+    val classBuilder = TypeSpec.classBuilder(fileName)
+        .addJavadoc("""
+          Class holder for instantiation of TypeConverter
+        """.trimIndent())
+        .addModifiers(Modifier.FINAL, Modifier.PUBLIC)
+        .addSuperinterface(ParameterizedTypeName.get(
+            ClassName.get("promise.commons", "InstanceProvider"),
+            element
+        ))
+        // field instance for the holder
+        .addField(FieldSpec.builder(
+            ClassName.get(pack, fileName),
+            "instance"
+        ).addModifiers(Modifier.PRIVATE, Modifier.STATIC)
+            .build())
+        // holder for type converter
+        .addField(FieldSpec.builder(element, varName,
+            Modifier.FINAL, Modifier.PRIVATE)
+            .addJavadoc("""
+              holder instance for the TypeConverter
+            """.trimIndent())
+            .build())
+        // constructor for the holder
+        .addMethod(MethodSpec.constructorBuilder()
+            .addModifiers(Modifier.PRIVATE)
+            .addParameter(ClassName.get(pack, className), varName)
+            .addStatement("this.$varName = $varName")
+            .build())
+        .addMethod(MethodSpec.methodBuilder("create")
+            .returns(ClassName.get(pack, fileName))
+            .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
+            .addJavadoc("""
+              Creates an instance of the holder with the converter
+            """.trimIndent())
+            .addParameter(
+                ClassName.get(pack, className),
+                varName)
+            .addCode(CodeBlock.builder()
+                .addStatement("if (instance == null) instance = new $fileName($varName)")
+                .addStatement("return instance")
+                .build())
+            .build())
+        .addMethod(MethodSpec.methodBuilder("get")
+            .addAnnotation(Override::class.java)
+            .returns(ClassName.get(pack, className))
+            .addModifiers(Modifier.PUBLIC)
+            .addCode("return $varName;")
+            .build())
+
+    return JavaFile.builder(pack, classBuilder.build())
+  }
 }
\ No newline at end of file
diff --git a/compiler/src/test/java/promise/db/ompiler/ExampleUnitTest.kt b/compiler/src/test/java/promise/db/ompiler/ExampleUnitTest.kt
index 4d0e01c..b688fe8 100644
--- a/compiler/src/test/java/promise/db/ompiler/ExampleUnitTest.kt
+++ b/compiler/src/test/java/promise/db/ompiler/ExampleUnitTest.kt
@@ -13,10 +13,9 @@
 
 package promise.db.ompiler
 
+import org.junit.Assert.assertEquals
 import org.junit.Test
 
-import org.junit.Assert.*
-
 /**
  * Example local unit test, which will execute on the development machine (host).
  *
diff --git a/compiler/src/test/java/promise/db/ompiler/PersistableEntityUtilsKtTest.kt b/compiler/src/test/java/promise/db/ompiler/PersistableEntityUtilsKtTest.kt
index c7dd218..00475a4 100644
--- a/compiler/src/test/java/promise/db/ompiler/PersistableEntityUtilsKtTest.kt
+++ b/compiler/src/test/java/promise/db/ompiler/PersistableEntityUtilsKtTest.kt
@@ -16,8 +16,6 @@ package promise.db.ompiler
 import org.junit.After
 import org.junit.Before
 
-import org.junit.Assert.*
-
 class PersistableEntityUtilsKtTest {
 
   @Before
diff --git a/database/src/androidTest/java/promise/db/ExampleInstrumentedTest.java b/database/src/androidTest/java/promise/db/ExampleInstrumentedTest.java
index a964d55..73bb615 100644
--- a/database/src/androidTest/java/promise/db/ExampleInstrumentedTest.java
+++ b/database/src/androidTest/java/promise/db/ExampleInstrumentedTest.java
@@ -21,7 +21,7 @@
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 /**
  * Instrumented test, which will execute on an Android device.
diff --git a/database/src/main/AndroidManifest.xml b/database/src/main/AndroidManifest.xml
index 2f2a28c..aaaea4c 100644
--- a/database/src/main/AndroidManifest.xml
+++ b/database/src/main/AndroidManifest.xml
@@ -11,5 +11,4 @@
   ~ limitations under the License.
   -->
 
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="promise.db" />
+<manifest package="promise.db" />
diff --git a/database/src/main/java/promise/db/ActiveRecord.kt b/database/src/main/java/promise/db/ActiveRecord.kt
index f028d40..0a7935c 100644
--- a/database/src/main/java/promise/db/ActiveRecord.kt
+++ b/database/src/main/java/promise/db/ActiveRecord.kt
@@ -17,12 +17,11 @@ import android.os.Parcel
 import promise.commons.model.Identifiable
 import promise.commons.util.Conditions
 import promise.model.TimeStamped
-import java.lang.Exception
 
 /**
  *
  */
-abstract class ActiveRecord<T: Identifiable<Int>>() : TimeStamped() {
+abstract class ActiveRecord<T : Identifiable<Int>>() : TimeStamped() {
   /**
    *
    */
@@ -31,7 +30,7 @@ abstract class ActiveRecord<T: Identifiable<Int>>() : TimeStamped() {
   /**
    *
    */
-  constructor(parcel: Parcel?): this() {
+  constructor(parcel: Parcel?) : this() {
     super.readFromParcel(parcel)
   }
 
diff --git a/database/src/main/java/promise/db/Column.java b/database/src/main/java/promise/db/Column.java
index 30a7753..d68d6f2 100644
--- a/database/src/main/java/promise/db/Column.java
+++ b/database/src/main/java/promise/db/Column.java
@@ -28,9 +28,11 @@ public final class Column<T> {
   private String operand = Op.EQUALS().s;
   private T value;
   private int index;
+
   public Column(String name, Type type) {
     this(name, type, 0);
   }
+
   public Column(String name, Type type, int index) {
     this(name, type.s, index);
   }
diff --git a/database/src/main/java/promise/db/Crud.kt b/database/src/main/java/promise/db/Crud.kt
index 8c466d9..5074ec8 100644
--- a/database/src/main/java/promise/db/Crud.kt
+++ b/database/src/main/java/promise/db/Crud.kt
@@ -12,7 +12,6 @@
  */
 package promise.db
 
-import android.database.Cursor
 import promise.commons.model.Identifiable
 import promise.commons.model.List
 import promise.model.IdentifiableList
@@ -20,9 +19,8 @@ import promise.model.IdentifiableList
 /**
  *
  */
-internal interface Crud<X> {
+interface Crud<X> {
 
-  fun querySql(sql: String): Cursor
 
   /**
    *
diff --git a/database/src/main/java/promise/db/FastDatabase.kt b/database/src/main/java/promise/db/FastDatabase.kt
index fd6742e..40a67cb 100644
--- a/database/src/main/java/promise/db/FastDatabase.kt
+++ b/database/src/main/java/promise/db/FastDatabase.kt
@@ -10,430 +10,47 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package promise.db
 
-import android.annotation.TargetApi
 import android.database.Cursor
 import android.database.DatabaseErrorHandler
 import android.database.sqlite.SQLiteDatabase
-import android.os.Build
 import androidx.collection.ArrayMap
-import promise.commons.data.log.LogUtil
 import promise.commons.makeInstance
-import promise.commons.model.Identifiable
 import promise.commons.model.List
 import promise.commons.util.ClassUtil
-import promise.commons.util.Conditions
-import promise.model.IdentifiableList
-import java.util.*
-
-/**
- *
- */
 
-open class FastDatabase internal constructor(
+abstract class FastDatabase internal constructor(
     name: String?,
     factory: SQLiteDatabase.CursorFactory?,
     version: Int,
-    errorHandler: DatabaseErrorHandler)
-  : FastDatabaseOpenHelper(name, factory, version, errorHandler),
-    Crud<SQLiteDatabase> {
-
-  private val cacheMap: ArrayMap<String, Any> = ArrayMap()
-
-  private var migration: Migration? = null
-
-  private var databaseCreationCallback: DatabaseCreationCallback? = null
-
-  /**
-   * @param name
-   * @param version
-   * @param cursorListener
-   * @param listener
-   */
-  @TargetApi(Build.VERSION_CODES.HONEYCOMB)
-  private constructor(name: String?,
-                      version: Int,
-                      cursorListener: DatabaseCursorFactory.Listener?,
-                      listener: Corrupt?) : this(
-      name,
-      DatabaseCursorFactory(cursorListener),
-      version,
-      DatabaseErrorHandler {
-        assert(listener != null)
-        listener!!.onCorrupt()
-      })
-
-  constructor(name: String?, version: Int) : this(name, version, null, null)
-
-  /**
-   * @param db
-   */
-  final override fun onCreate(db: SQLiteDatabase) {
-    if (databaseCreationCallback != null) {
-      databaseCreationCallback!!.beforeCreate(db)
-      create(db)
-      databaseCreationCallback!!.afterCreate(db)
-    } else create(db)
-  }
-
-  /**
-   * @param database
-   * @param oldVersion
-   * @param newVersion
-   */
-  final override fun onUpgrade(database: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
-    LogUtil.d(TAG, "onUpgrade", oldVersion, newVersion)
-    if (newVersion - oldVersion == 1)
-      onUpgradeDatabase(database, oldVersion, newVersion)
-    else {
-      var i = oldVersion
-      while (i < newVersion) {
-        onUpgradeDatabase(database, i, i + 1)
-        i++
-      }
-    }
-    upgradeTables(database, oldVersion, newVersion)
-  }
-
-  /**
-   * @param database
-   * @param oldVersion
-   * @param newVersion
-   * @return
-   */
-  private fun onUpgradeDatabase(database: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
-    if (migration != null) migration!!.onMigrate(this, database, oldVersion, newVersion)
-  }
+    errorHandler: DatabaseErrorHandler) : FastDatabaseOpenHelper(name, factory, version, errorHandler), Crud<SQLiteDatabase> {
 
-  /**
-   * @return
-   */
-  fun name(): String = this.databaseName
+  abstract fun add(database: SQLiteDatabase, vararg tables: TableCrud<*, in SQLiteDatabase>): Boolean
 
-  private var tables: List<out FastTable<*>>? = null
-
-  /**
-   * @return
-   */
-  protected fun tables(): List<TableCrud<*, in SQLiteDatabase>> =
-      Conditions.checkNotNull(tables, "tables not found for this database")
-          as List<TableCrud<*, in SQLiteDatabase>>
+  abstract fun <T : TableCrud<*, in SQLiteDatabase>> obtain(tableClass: Class<out TableCrud<*, in SQLiteDatabase>>): T
 
   /**
    *
    */
-  fun <T : FastTable<*>> obtain(tableClass: Class<out FastTable<*>>): T {
-    fun <T : FastTable<*>> makeTable(tableClass: Class<out FastTable<*>>): T {
-      if (ClassUtil.hasAnnotation(tableClass, Table::class.java)) {
-        val table = tableClass.getAnnotation(Table::class.java)!!
-        if (cacheMap.containsKey(table.tableName)) return cacheMap[table.tableName] as T
-        val tableObject = makeInstance(tableClass.kotlin, arrayOf(this)) as T
-        tableObject.setNameOfTable(table.tableName)
-        tableObject.setArgs(ArrayMap<String, Any>().apply {
-          put(INDEXES, table.indices)
-          put(FOREIGN_kEYS, table.foreignKeys)
-          put(COMPOUND_INDEXES, table.compoundIndexes)
-        })
-        cacheMap[table.tableName] = tableObject
-        return tableObject
-      }
-      throw IllegalArgumentException("The class must be annotated with @Table")
-    }
-    return makeTable(tableClass)
-  }
-
-  internal fun <T : FastTable<*>> setTables(tablesClasses: List<out Class<out FastTable<*>>>) {
-    this.tables = tablesClasses.map {
-      return@map obtain<T>(it)
-    }
-  }
-
-  internal fun setMigration(migration: Migration?) {
-    this.migration = migration
-  }
-
-  fun setDatabaseCreationCallback(creationCallback: DatabaseCreationCallback?): FastDatabase {
-    this.databaseCreationCallback = creationCallback
-    return this
-  }
-
-  /**
-   * @param database
-   */
-  private fun create(database: SQLiteDatabase) {
-    var created = true
-    for (table in Conditions.checkNotNull(tables())) created = try {
-      created && create(table, database)
-    } catch (dbError: DBError) {
-      LogUtil.e(TAG, dbError)
-      return
-    }
-  }
-
-  /**
-   * @param database
-   * @param v1
-   * @param v2
-   */
-  private fun upgradeTables(database: SQLiteDatabase, v1: Int, v2: Int) {
-    for (table in Conditions.checkNotNull(tables())) try {
-      if (v2 - v1 == 1)
-        checkTableExist(table).onUpgrade(database, v1, v2)
-      else {
-        var i = v1
-        while (i < v2) {
-          checkTableExist(table).onUpgrade(database, i, i + 1)
-          i++
-        }
-      }
-    } catch (tableError: TableError) {
-      LogUtil.e(TAG, tableError)
-    }
-  }
-
-  /**
-   * @param database
-   * @param tableCruds
-   * @return
-   */
-  @SafeVarargs
-  fun add(database: SQLiteDatabase, vararg tableCruds: TableCrud<*, in SQLiteDatabase>): Boolean {
-    var created = true
-    for (table in tableCruds) {
-      created = try {
-        created && create(table, database)
-      } catch (dbError: DBError) {
-        LogUtil.e(TAG, dbError)
-        return false
-      }
-    }
-    return created
-  }
-
-  /**
-   * @param database
-   * @return
-   */
-  private fun drop(database: SQLiteDatabase): Boolean {
-    /*for (Map.Entry<IndexCreated, Table<, SQLiteDatabase>> entry :
-        indexCreatedTableHashMap.entrySet()) {
-      try {
-        dropped = dropped && drop(checkTableExist(entry.getValue()), database);
-      } catch (DBError dbError) {
-        dbError.printStackTrace();
-        return false;
-      }
-    }*/return true
-  }
-
-  /**
-   * @param tableCrud
-   * @param database
-   * @return
-   * @throws DBError
-   */
-  @Throws(DBError::class)
-  private fun create(tableCrud: TableCrud<*, in SQLiteDatabase>, database: SQLiteDatabase): Boolean {
-    try {
-      tableCrud.onCreate(database)
-    } catch (e: TableError) {
-      throw DBError(e)
-    }
-    return true
-  }
-
-  /**
-   * @param tableCrud
-   * @param database
-   * @return
-   * @throws DBError
-   */
-  @Throws(DBError::class)
-  private fun drop(tableCrud: TableCrud<*, in SQLiteDatabase>, database: SQLiteDatabase): Boolean {
-    try {
-      checkTableExist(tableCrud).onDrop(database)
-    } catch (e: TableError) {
-      throw DBError(e)
-    }
-    return true
-  }
-
-  override fun querySql(sql: String): Cursor {
-    LogUtil.d(TAG, "query: $sql")
-    return readableDatabase.rawQuery(sql, null)
-  }
-
-  /**
-   * @param builder
-   * @return
-   */
-  fun query(builder: QueryBuilder): Cursor {
-    val sql = builder.build()
-    val params = builder.buildParameters()
-    LogUtil.d(TAG, "query: $sql", " params: " + Arrays.toString(params))
-    return readableDatabase.rawQuery(sql, params)
-  }
-
-  /**
-   * @param tableCrud
-   * @param <T>
-   * @return
-  </T> */
-  override fun <T : Identifiable<Int>> find(tableCrud: TableCrud<T, in SQLiteDatabase>): TableCrud.Extras<T> =
-      checkTableExist(tableCrud).onFind(readableDatabase)
-
-  /**
-   * @param tableCrud
-   * @param <T>
-   * @return
-  </T> */
-  override fun <T : Identifiable<Int>> findAll(tableCrud: TableCrud<T, in SQLiteDatabase>): IdentifiableList<out T> =
-      checkTableExist(tableCrud).onFindAll(readableDatabase, true)
-
-  /**
-   * @param t
-   * @param tableCrud
-   * @param <T>
-   * @return
-  </T> */
-  override fun <T : Identifiable<Int>> update(t: T, tableCrud: TableCrud<T, in SQLiteDatabase>): Boolean =
-      checkTableExist(tableCrud).onUpdate(t, writableDatabase)
-
-  /**
-   * @param t
-   * @param tableCrud
-   * @param column
-   * @param <T>
-   * @return
-  </T> */
-  override fun <T : Identifiable<Int>> update(t: T, tableCrud: TableCrud<T, in SQLiteDatabase>, column: Column<*>): Boolean =
-      try {
-        checkTableExist(tableCrud).onUpdate(t, writableDatabase, column)
-      } catch (tableError: TableError) {
-        LogUtil.e(TAG, "update error", tableError)
-        false
-      }
-
-  /**
-   * @param tableCrud
-   * @param columns
-   * @param <T>
-   * @return
-  </T> */
-  override fun <T : Identifiable<Int>> findAll(tableCrud: TableCrud<T, in SQLiteDatabase>,
-                                               vararg columns: Column<*>): IdentifiableList<out T> =
-      checkTableExist(tableCrud).onFindAll(readableDatabase, *columns)
-
-  /**
-   * @param tableCrud
-   * @param t
-   * @param <T>
-   * @return
-  </T> */
-  override fun <T : Identifiable<Int>> delete(tableCrud: TableCrud<T, in SQLiteDatabase>, t: T): Boolean =
-      checkTableExist(tableCrud).onDelete(t, writableDatabase)
-
-  /**
-   * @param tableCrud
-   * @param column
-   * @return
-   */
-  override fun delete(tableCrud: TableCrud<*, in SQLiteDatabase>, column: Column<*>): Boolean =
-      checkTableExist(tableCrud).onDelete(writableDatabase, column)
+  abstract fun querySql(sql: String): Cursor
 
   /**
-   * @param tableCrud
-   * @return
-   */
-  override fun delete(tableCrud: TableCrud<*, in SQLiteDatabase>): Boolean =
-      checkTableExist(tableCrud).onDelete(writableDatabase)
-
-  /**
-   * @param tableCruds
-   * @return
-   */
-  @SafeVarargs
-  fun delete(vararg tableCruds: TableCrud<*, in SQLiteDatabase>): Boolean {
-    var delete = true
-    for (table in tableCruds) delete = delete && delete(table)
-    return delete
-  }
-
-  /**
-   * @param tableCrud
-   * @param column
-   * @param list
-   * @param <T>
-   * @return
-  </T> */
-  override fun <T> delete(tableCrud: TableCrud<*, in SQLiteDatabase>, column: Column<T>, list: List<out T>): Boolean =
-      checkTableExist(tableCrud).onDelete(writableDatabase, column, list)
-
-  /**
-   * @param t
-   * @param tableCrud
-   * @param <T>
-   * @return
-  </T> */
-  override fun <T : Identifiable<Int>> save(t: T, tableCrud: TableCrud<T, in SQLiteDatabase>): Long =
-      checkTableExist(tableCrud).onSave(t, writableDatabase)
-
-  /**
-   * @param list
-   * @param tableCrud
-   * @param <T>
-   * @return
-  </T> */
-  override fun <T : Identifiable<Int>> save(list: IdentifiableList<out T>, tableCrud: TableCrud<T, in SQLiteDatabase>): Boolean =
-      checkTableExist(tableCrud).onSave(list, writableDatabase)
-
-  /**
-   * @return
+   *
    */
-  override fun deleteAll(): Boolean = synchronized(FastDatabase::class.java) {
-    var deleted = true
-    try {
-      writableDatabase.execSQL("PRAGMA foreign_keys = FALSE");
-      transact {
-        for (table in Conditions.checkNotNull(tables())) deleted = deleted && delete(checkTableExist(table))
-      }
-      writableDatabase.execSQL("PRAGMA foreign_keys = TRUE");
-    } catch (e: Exception) { }
-    return deleted
-  }
+  abstract fun query(queryBuilder: QueryBuilder): Cursor
 
   /**
-   * @param tableCrud
-   * @return
+   *
    */
-  override fun getLastId(tableCrud: TableCrud<*, in SQLiteDatabase>): Int =
-      checkTableExist(tableCrud).onGetLastId(readableDatabase)
-
-  inline fun transact(block: FastDatabase.() -> Unit) = synchronized(this) {
-    val db = writableDatabase
-    try {
-      db.beginTransaction()
-      block.invoke(this)
-      db.setTransactionSuccessful()
-    } finally {
-      db.endTransaction()
-    }
-  }
-
-  /**
-   * @param tableCrud
-   * @param <T>
-   * @return
-  </T> */
-  private fun <T : Identifiable<Int>> checkTableExist(tableCrud: TableCrud<T, in SQLiteDatabase>): TableCrud<T, in SQLiteDatabase> =
-      Conditions.checkNotNull(tableCrud)
+  abstract fun writableDatabase(): SQLiteDatabase
 
   companion object {
-
     private val dbCache: ArrayMap<String, FastDatabase> = ArrayMap()
 
     private val lock = Any()
+
     /**
      *
      */
@@ -441,19 +58,23 @@ open class FastDatabase internal constructor(
 
     @JvmOverloads
     @JvmStatic
-    fun createDatabase(dbClass: Class<*>, name: String, migration: Migration? = null): FastDatabase {
+    fun createDatabase(dbClass: Class<*>,
+                       name: String,
+                       migration: Migration? = null,
+                       databaseCreationCallback: DatabaseCreationCallback? = null): FastDatabase {
       fun makeDatabase(dbClass: Class<*>): FastDatabase {
         if (ClassUtil.hasAnnotation(dbClass, Database::class.java)) {
           val database = dbClass.getAnnotation(Database::class.java)!!
           if (dbCache.containsKey(name)) return dbCache[name] as FastDatabase
-          val databaseObject = makeInstance(FastDatabase::class,
-              arrayOf(name, database.version)) as FastDatabase
+          val databaseObject = makeInstance(FastDatabaseImpl::class,
+              arrayOf(name, database.version)) as FastDatabaseImpl
           val classList: List<Class<out FastTable<*>>> = List()
           database.tables.forEach {
             classList.add(it.java)
           }
           databaseObject.setTables<FastTable<*>>(classList)
           databaseObject.setMigration(migration)
+          databaseObject.setDatabaseCreationCallback(databaseCreationCallback)
           dbCache[name] = databaseObject
           return databaseObject
         }
@@ -464,18 +85,22 @@ open class FastDatabase internal constructor(
       }
     }
 
+    @JvmOverloads
     @JvmStatic
-    fun createInMemoryDatabase(dbClass: Class<*>): FastDatabase {
+    fun createInMemoryDatabase(
+        dbClass: Class<*>,
+        databaseCreationCallback: DatabaseCreationCallback? = null): FastDatabase {
       fun makeDatabase(dbClass: Class<*>): FastDatabase {
         if (ClassUtil.hasAnnotation(dbClass, Database::class.java)) {
           val database = dbClass.getAnnotation(Database::class.java)!!
-          val databaseObject = makeInstance(FastDatabase::class,
-              arrayOf(null, database.version)) as FastDatabase
+          val databaseObject = makeInstance(FastDatabaseImpl::class,
+              arrayOf(null, database.version)) as FastDatabaseImpl
           val classList: List<Class<out FastTable<*>>> = List()
           database.tables.forEach {
             classList.add(it.java)
           }
           databaseObject.setTables<FastTable<*>>(classList)
+          databaseObject.setDatabaseCreationCallback(databaseCreationCallback)
           return databaseObject
         }
         throw IllegalArgumentException("The class must be annotated with @Database")
@@ -490,8 +115,8 @@ open class FastDatabase internal constructor(
     fun createReactiveDatabase(dbClass: Class<*>,
                                name: String,
                                migration: Migration? = null,
-                               databaseCreationCallback: DatabaseCreationCallback? = null): ReactiveFastDatabase {
-      fun makeDatabase(dbClass: Class<*>): ReactiveFastDatabase {
+                               databaseCreationCallback: DatabaseCreationCallback? = null): FastDatabase {
+      fun makeDatabase(dbClass: Class<*>): FastDatabase {
         if (ClassUtil.hasAnnotation(dbClass, Database::class.java)) {
           val database = dbClass.getAnnotation(Database::class.java)!!
           if (dbCache.containsKey(name)) return dbCache[name] as ReactiveFastDatabase
@@ -517,8 +142,8 @@ open class FastDatabase internal constructor(
     @JvmOverloads
     @JvmStatic
     fun createInMemoryReactiveDatabase(dbClass: Class<*>,
-                                       databaseCreationCallback: DatabaseCreationCallback? = null): ReactiveFastDatabase {
-      fun makeDatabase(dbClass: Class<*>): ReactiveFastDatabase {
+                                       databaseCreationCallback: DatabaseCreationCallback? = null): FastDatabase {
+      fun makeDatabase(dbClass: Class<*>): FastDatabase {
         if (ClassUtil.hasAnnotation(dbClass, Database::class.java)) {
           val database = dbClass.getAnnotation(Database::class.java)!!
           val databaseObject = makeInstance(ReactiveFastDatabase::class,
@@ -537,12 +162,5 @@ open class FastDatabase internal constructor(
         makeDatabase(dbClass)
       }
     }
-
-    /*private static Map<IndexCreated, Table<, SQLiteDatabase>> indexCreatedTableHashMap;*/
-    private val TAG: String = LogUtil.makeTag(FastDatabase::class.java)
-  }
-
-  init {
-    LogUtil.d(TAG, "fast db init")
   }
 }
\ No newline at end of file
diff --git a/database/src/main/java/promise/db/FastDatabaseImpl.kt b/database/src/main/java/promise/db/FastDatabaseImpl.kt
new file mode 100644
index 0000000..8342f4b
--- /dev/null
+++ b/database/src/main/java/promise/db/FastDatabaseImpl.kt
@@ -0,0 +1,443 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package promise.db
+
+import android.annotation.TargetApi
+import android.database.Cursor
+import android.database.DatabaseErrorHandler
+import android.database.sqlite.SQLiteDatabase
+import android.os.Build
+import androidx.collection.ArrayMap
+import promise.commons.createInstance
+import promise.commons.data.log.LogUtil
+import promise.commons.model.Identifiable
+import promise.commons.model.List
+import promise.commons.util.ClassUtil
+import promise.commons.util.Conditions
+import promise.model.IdentifiableList
+import java.util.*
+
+/**
+ *
+ */
+
+open class FastDatabaseImpl internal constructor(
+    name: String?,
+    factory: SQLiteDatabase.CursorFactory?,
+    version: Int,
+    errorHandler: DatabaseErrorHandler)
+  : FastDatabase(name, factory, version, errorHandler) {
+
+  private val cacheMap: ArrayMap<String, Any> = ArrayMap()
+
+  private var migration: Migration? = null
+
+  private var databaseCreationCallback: DatabaseCreationCallback? = null
+
+  /**
+   * @param name
+   * @param version
+   * @param cursorListener
+   * @param listener
+   */
+  @TargetApi(Build.VERSION_CODES.HONEYCOMB)
+  private constructor(name: String?,
+                      version: Int,
+                      cursorListener: DatabaseCursorFactory.Listener?,
+                      listener: Corrupt?) : this(
+      name,
+      DatabaseCursorFactory(cursorListener),
+      version,
+      DatabaseErrorHandler {
+        assert(listener != null)
+        listener!!.onCorrupt()
+      })
+
+  constructor(name: String?, version: Int) : this(name, version, null, null)
+
+  /**
+   * @param db
+   */
+  final override fun onCreate(db: SQLiteDatabase) {
+    if (databaseCreationCallback != null) {
+      databaseCreationCallback!!.beforeCreate(db)
+      create(db)
+      databaseCreationCallback!!.afterCreate(db)
+    } else create(db)
+  }
+
+  /**
+   * @param database
+   * @param oldVersion
+   * @param newVersion
+   */
+  final override fun onUpgrade(database: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
+    LogUtil.d(TAG, "onUpgrade", oldVersion, newVersion)
+    if (newVersion - oldVersion == 1)
+      onUpgradeDatabase(database, oldVersion, newVersion)
+    else {
+      var i = oldVersion
+      while (i < newVersion) {
+        onUpgradeDatabase(database, i, i + 1)
+        i++
+      }
+    }
+    upgradeTables(database, oldVersion, newVersion)
+  }
+
+  /**
+   * @param database
+   * @param oldVersion
+   * @param newVersion
+   * @return
+   */
+  private fun onUpgradeDatabase(database: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
+    if (migration != null) migration!!.onMigrate(this, database, oldVersion, newVersion)
+  }
+
+  /**
+   * @return
+   */
+  fun name(): String = this.databaseName
+
+  private var tables: List<out FastTable<*>>? = null
+
+  /**
+   * @return
+   */
+  protected fun tables(): List<TableCrud<*, in SQLiteDatabase>> =
+      Conditions.checkNotNull(tables, "tables not found for this database")
+          as List<TableCrud<*, in SQLiteDatabase>>
+
+  /**
+   *
+   */
+  override fun <T : TableCrud<*, in SQLiteDatabase>> obtain(tableClass: Class<out TableCrud<*, in SQLiteDatabase>>): T {
+    fun <T : TableCrud<*, in SQLiteDatabase>> makeTable(tableClass: Class<out TableCrud<*, in SQLiteDatabase>>): T {
+      if (ClassUtil.hasAnnotation(tableClass, Table::class.java)) {
+        val table = tableClass.getAnnotation(Table::class.java)!!
+        if (cacheMap.containsKey(table.tableName)) return cacheMap[table.tableName] as T
+        val tableObject: FastTable<*> = createInstance<FastTable<*>>(tableClass.kotlin, arrayOf(this))
+        tableObject.setNameOfTable(table.tableName)
+        tableObject.setArgs(ArrayMap<String, Any>().apply {
+          put(INDEXES, table.indices)
+          put(FOREIGN_kEYS, table.foreignKeys)
+          put(COMPOUND_INDEXES, table.compoundIndexes)
+        })
+        cacheMap[table.tableName] = tableObject
+        return tableObject as T
+      }
+      throw IllegalArgumentException("The class must be annotated with @Table")
+    }
+    return makeTable(tableClass)
+  }
+
+  internal fun <T : FastTable<*>> setTables(tablesClasses: List<out Class<out FastTable<*>>>) {
+    this.tables = tablesClasses.map {
+      return@map obtain<T>(it)
+    }
+  }
+
+  internal fun setMigration(migration: Migration?) {
+    this.migration = migration
+  }
+
+  fun setDatabaseCreationCallback(creationCallback: DatabaseCreationCallback?): FastDatabaseImpl {
+    this.databaseCreationCallback = creationCallback
+    return this
+  }
+
+  /**
+   * @param database
+   */
+  private fun create(database: SQLiteDatabase) {
+    var created = true
+    for (table in Conditions.checkNotNull(tables())) created = try {
+      created && create(table, database)
+    } catch (dbError: DBError) {
+      LogUtil.e(TAG, dbError)
+      return
+    }
+  }
+
+  /**
+   * @param database
+   * @param v1
+   * @param v2
+   */
+  private fun upgradeTables(database: SQLiteDatabase, v1: Int, v2: Int) {
+    for (table in Conditions.checkNotNull(tables())) try {
+      if (v2 - v1 == 1)
+        checkTableExist(table).onUpgrade(database, v1, v2)
+      else {
+        var i = v1
+        while (i < v2) {
+          checkTableExist(table).onUpgrade(database, i, i + 1)
+          i++
+        }
+      }
+    } catch (tableError: TableError) {
+      LogUtil.e(TAG, tableError)
+    }
+  }
+
+  /**
+   * @param database
+   * @param tables
+   * @return
+   */
+  @SafeVarargs
+  override fun add(database: SQLiteDatabase, vararg tables: TableCrud<*, in SQLiteDatabase>): Boolean {
+    var created = true
+    for (table in tables) {
+      created = try {
+        created && create(table, database)
+      } catch (dbError: DBError) {
+        LogUtil.e(TAG, dbError)
+        return false
+      }
+    }
+    return created
+  }
+
+  /**
+   * @param database
+   * @return
+   */
+  private fun drop(database: SQLiteDatabase): Boolean {
+    /*for (Map.Entry<IndexCreated, Table<, SQLiteDatabase>> entry :
+        indexCreatedTableHashMap.entrySet()) {
+      try {
+        dropped = dropped && drop(checkTableExist(entry.getValue()), database);
+      } catch (DBError dbError) {
+        dbError.printStackTrace();
+        return false;
+      }
+    }*/return true
+  }
+
+  /**
+   * @param tableCrud
+   * @param database
+   * @return
+   * @throws DBError
+   */
+  @Throws(DBError::class)
+  private fun create(tableCrud: TableCrud<*, in SQLiteDatabase>, database: SQLiteDatabase): Boolean {
+    try {
+      tableCrud.onCreate(database)
+    } catch (e: TableError) {
+      throw DBError(e)
+    }
+    return true
+  }
+
+  /**
+   * @param tableCrud
+   * @param database
+   * @return
+   * @throws DBError
+   */
+  @Throws(DBError::class)
+  private fun drop(tableCrud: TableCrud<*, in SQLiteDatabase>, database: SQLiteDatabase): Boolean {
+    try {
+      checkTableExist(tableCrud).onDrop(database)
+    } catch (e: TableError) {
+      throw DBError(e)
+    }
+    return true
+  }
+
+  override fun writableDatabase(): SQLiteDatabase {
+    return writableDatabase
+  }
+
+  override fun querySql(sql: String): Cursor {
+    LogUtil.d(TAG, "query: $sql")
+    return readableDatabase.rawQuery(sql, null)
+  }
+
+  /**
+   * @param queryBuilder
+   * @return
+   */
+  override fun query(queryBuilder: QueryBuilder): Cursor {
+    val sql = queryBuilder.build()
+    val params = queryBuilder.buildParameters()
+    LogUtil.d(TAG, "query: $sql", " params: " + Arrays.toString(params))
+    return readableDatabase.rawQuery(sql, params)
+  }
+
+  /**
+   * @param tableCrud
+   * @param <T>
+   * @return
+  </T> */
+  override fun <T : Identifiable<Int>> find(tableCrud: TableCrud<T, in SQLiteDatabase>): TableCrud.Extras<T> =
+      checkTableExist(tableCrud).onFind(readableDatabase)
+
+  /**
+   * @param tableCrud
+   * @param <T>
+   * @return
+  </T> */
+  override fun <T : Identifiable<Int>> findAll(tableCrud: TableCrud<T, in SQLiteDatabase>): IdentifiableList<out T> =
+      checkTableExist(tableCrud).onFindAll(readableDatabase, true)
+
+  /**
+   * @param t
+   * @param tableCrud
+   * @param <T>
+   * @return
+  </T> */
+  override fun <T : Identifiable<Int>> update(t: T, tableCrud: TableCrud<T, in SQLiteDatabase>): Boolean =
+      checkTableExist(tableCrud).onUpdate(t, writableDatabase)
+
+  /**
+   * @param t
+   * @param tableCrud
+   * @param column
+   * @param <T>
+   * @return
+  </T> */
+  override fun <T : Identifiable<Int>> update(t: T, tableCrud: TableCrud<T, in SQLiteDatabase>, column: Column<*>): Boolean =
+      try {
+        checkTableExist(tableCrud).onUpdate(t, writableDatabase, column)
+      } catch (tableError: TableError) {
+        LogUtil.e(TAG, "update error", tableError)
+        false
+      }
+
+  /**
+   * @param tableCrud
+   * @param columns
+   * @param <T>
+   * @return
+  </T> */
+  override fun <T : Identifiable<Int>> findAll(tableCrud: TableCrud<T, in SQLiteDatabase>,
+                                               vararg columns: Column<*>): IdentifiableList<out T> =
+      checkTableExist(tableCrud).onFindAll(readableDatabase, *columns)
+
+  /**
+   * @param tableCrud
+   * @param t
+   * @param <T>
+   * @return
+  </T> */
+  override fun <T : Identifiable<Int>> delete(tableCrud: TableCrud<T, in SQLiteDatabase>, t: T): Boolean =
+      checkTableExist(tableCrud).onDelete(t, writableDatabase)
+
+  /**
+   * @param tableCrud
+   * @param column
+   * @return
+   */
+  override fun delete(tableCrud: TableCrud<*, in SQLiteDatabase>, column: Column<*>): Boolean =
+      checkTableExist(tableCrud).onDelete(writableDatabase, column)
+
+  /**
+   * @param tableCrud
+   * @return
+   */
+  override fun delete(tableCrud: TableCrud<*, in SQLiteDatabase>): Boolean =
+      checkTableExist(tableCrud).onDelete(writableDatabase)
+
+  /**
+   * @param tableCruds
+   * @return
+   */
+  @SafeVarargs
+  fun delete(vararg tableCruds: TableCrud<*, in SQLiteDatabase>): Boolean {
+    var delete = true
+    for (table in tableCruds) delete = delete && delete(table)
+    return delete
+  }
+
+  /**
+   * @param tableCrud
+   * @param column
+   * @param list
+   * @param <T>
+   * @return
+  </T> */
+  override fun <T> delete(tableCrud: TableCrud<*, in SQLiteDatabase>, column: Column<T>, list: List<out T>): Boolean =
+      checkTableExist(tableCrud).onDelete(writableDatabase, column, list)
+
+  /**
+   * @param t
+   * @param tableCrud
+   * @param <T>
+   * @return
+  </T> */
+  override fun <T : Identifiable<Int>> save(t: T, tableCrud: TableCrud<T, in SQLiteDatabase>): Long =
+      checkTableExist(tableCrud).onSave(t, writableDatabase)
+
+  /**
+   * @param list
+   * @param tableCrud
+   * @param <T>
+   * @return
+  </T> */
+  override fun <T : Identifiable<Int>> save(list: IdentifiableList<out T>, tableCrud: TableCrud<T, in SQLiteDatabase>): Boolean =
+      checkTableExist(tableCrud).onSave(list, writableDatabase)
+
+  /**
+   * @return
+   */
+  override fun deleteAll(): Boolean = synchronized(FastDatabaseImpl::class.java) {
+    var deleted = true
+    try {
+      writableDatabase.execSQL("PRAGMA foreign_keys = FALSE");
+      transact {
+        for (table in Conditions.checkNotNull(tables())) deleted = deleted && delete(checkTableExist(table))
+      }
+      writableDatabase.execSQL("PRAGMA foreign_keys = TRUE");
+    } catch (e: Exception) {
+    }
+    return deleted
+  }
+
+  /**
+   * @param tableCrud
+   * @return
+   */
+  override fun getLastId(tableCrud: TableCrud<*, in SQLiteDatabase>): Int =
+      checkTableExist(tableCrud).onGetLastId(readableDatabase)
+
+  inline fun transact(block: FastDatabaseImpl.() -> Unit) = synchronized(this) {
+    val db = writableDatabase
+    try {
+      db.beginTransaction()
+      block.invoke(this)
+      db.setTransactionSuccessful()
+    } finally {
+      db.endTransaction()
+    }
+  }
+
+  /**
+   * @param tableCrud
+   * @param <T>
+   * @return
+  </T> */
+  private fun <T : Identifiable<Int>> checkTableExist(tableCrud: TableCrud<T, in SQLiteDatabase>): TableCrud<T, in SQLiteDatabase> =
+      Conditions.checkNotNull(tableCrud)
+
+  companion object {
+    private val TAG: String = LogUtil.makeTag(FastDatabase::class.java)
+  }
+
+  init {
+    LogUtil.d(TAG, "fast db init")
+  }
+}
\ No newline at end of file
diff --git a/database/src/main/java/promise/db/FastDatabaseOpenHelper.java b/database/src/main/java/promise/db/FastDatabaseOpenHelper.java
index d2d7eb7..a118add 100644
--- a/database/src/main/java/promise/db/FastDatabaseOpenHelper.java
+++ b/database/src/main/java/promise/db/FastDatabaseOpenHelper.java
@@ -13,7 +13,6 @@
 
 package promise.db;
 
-import android.content.Context;
 import android.database.DatabaseErrorHandler;
 import android.database.sqlite.SQLiteDatabase;
 import android.database.sqlite.SQLiteOpenHelper;
@@ -23,17 +22,13 @@
 
 import promise.commons.AndroidPromise;
 
-
 public abstract class FastDatabaseOpenHelper extends SQLiteOpenHelper {
 
-  private Context context;
-
   public FastDatabaseOpenHelper(@Nullable String name,
                                 @Nullable SQLiteDatabase.CursorFactory factory,
                                 int version,
                                 @Nullable DatabaseErrorHandler errorHandler) {
     super(AndroidPromise.instance().context(), name, factory, version, errorHandler);
-    this.context = AndroidPromise.instance().context();
   }
 
   @Override
diff --git a/database/src/main/java/promise/db/FastTable.kt b/database/src/main/java/promise/db/FastTable.kt
index c7dc809..42aa8da 100644
--- a/database/src/main/java/promise/db/FastTable.kt
+++ b/database/src/main/java/promise/db/FastTable.kt
@@ -28,8 +28,8 @@ import promise.commons.model.List.fromArray
 import promise.commons.util.Conditions
 import promise.commons.util.DoubleConverter
 import promise.db.criteria.Criteria
-import promise.db.projection.Projection
 import promise.db.model.ITimeStamped
+import promise.db.projection.Projection
 import promise.model.IdentifiableList
 import java.util.*
 
@@ -174,8 +174,7 @@ abstract class FastTable<T : Identifiable<Int>>
     indexSql = "$indexSql);"
     return if (compoundIndex.unique) {
       "CREATE UNIQUE INDEX IF NOT EXISTS idx_$columnNames ON $nameOfTable $indexSql"
-    }
-    else "CREATE INDEX IF NOT EXISTS idx_$columnNames ON $nameOfTable $indexSql"
+    } else "CREATE INDEX IF NOT EXISTS idx_$columnNames ON $nameOfTable $indexSql"
   }
 
   private fun generateIndexQuery(index: Table.Index): String {
@@ -393,12 +392,12 @@ abstract class FastTable<T : Identifiable<Int>>
   /**
    *
    */
-  override  fun query(queryBuilder: QueryBuilder): Cursor = database.query(queryBuilder)
+  override fun query(queryBuilder: QueryBuilder): Cursor = database.query(queryBuilder)
 
   /**
    *
    */
-  override  fun queryAsync(queryBuilder: QueryBuilder): Single<Cursor> =
+  override fun queryAsync(queryBuilder: QueryBuilder): Single<Cursor> =
       reactiveDatabase.queryAsync(queryBuilder)
 
   /**
@@ -409,41 +408,41 @@ abstract class FastTable<T : Identifiable<Int>>
   /**
    * @return
    */
-  override  fun findById(idLong: Long): T? = database.find(this).where(id.with(idLong.toInt())).first()
+  override fun findById(idLong: Long): T? = database.find(this).where(id.with(idLong.toInt())).first()
 
   /**
    * @return
    */
-  override  fun findOne(vararg columns: Column<*>): T? = database.find(this).where(*columns).first()
+  override fun findOne(vararg columns: Column<*>): T? = database.find(this).where(*columns).first()
 
   /**
    * @return
    * @throws TableError
    */
   @Throws(TableError::class)
-  override  fun findAsync(): ReactiveTable.Extras<T> = reactiveDatabase.readAsync(this)
+  override fun findAsync(): ReactiveTable.Extras<T> = reactiveDatabase.readAsync(this)
 
   /**
    * @return
    */
-  override  fun findAll(): IdentifiableList<out T> = database.findAll(this)
+  override fun findAll(): IdentifiableList<out T> = database.findAll(this)
 
   /**
    * @return
    */
-  override  fun findAllAsync(): Maybe<IdentifiableList<out T>> = reactiveDatabase.readAllAsync(this)
+  override fun findAllAsync(): Maybe<IdentifiableList<out T>> = reactiveDatabase.readAllAsync(this)
 
   /**
    * @param column
    * @return
    */
-  override  fun findAll(vararg column: Column<*>): IdentifiableList<out T> = database.findAll(this, *column)
+  override fun findAll(vararg column: Column<*>): IdentifiableList<out T> = database.findAll(this, *column)
 
   /**
    * @param column
    * @return
    */
-  override  fun findAllAsync(vararg column: Column<*>): Maybe<IdentifiableList<out T>> =
+  override fun findAllAsync(vararg column: Column<*>): Maybe<IdentifiableList<out T>> =
       reactiveDatabase.readAllAsync(this, *column)
 
   /**
@@ -456,19 +455,19 @@ abstract class FastTable<T : Identifiable<Int>>
    * @param column
    * @return
    */
-  override  fun deleteAsync(column: Column<*>): Maybe<Boolean> = reactiveDatabase.deleteAsync(this, column)
+  override fun deleteAsync(column: Column<*>): Maybe<Boolean> = reactiveDatabase.deleteAsync(this, column)
 
   /**
    * @param t
    * @return
    */
-  override  fun delete(t: T): Boolean = database.delete(this, t)
+  override fun delete(t: T): Boolean = database.delete(this, t)
 
   /**
    * @param t
    * @return
    */
-  override  fun deleteAsync(t: T): Maybe<Boolean> = reactiveDatabase.deleteAsync(this, t)
+  override fun deleteAsync(t: T): Maybe<Boolean> = reactiveDatabase.deleteAsync(this, t)
 
   /**
    * @param column
@@ -485,23 +484,23 @@ abstract class FastTable<T : Identifiable<Int>>
    * @param <C>
    * @return
   </C> */
-  override  fun <C> deleteAsync(column: Column<C>, list: List<out C>): Maybe<Boolean> =
+  override fun <C> deleteAsync(column: Column<C>, list: List<out C>): Maybe<Boolean> =
       reactiveDatabase.deleteAsync(this, column, list)
 
   /**
    * @return
    */
-  override  fun clear(): Boolean = database.delete(this)
+  override fun clear(): Boolean = database.delete(this)
 
   /**
    * @return
    */
-  override  fun clearAsync(): Maybe<Boolean> = reactiveDatabase.deleteAsync(this)
+  override fun clearAsync(): Maybe<Boolean> = reactiveDatabase.deleteAsync(this)
 
   /**
    * @return
    */
-  override  val lastId: Int
+  override val lastId: Int
     get() = database.getLastId(this)
 
   /**
@@ -530,7 +529,7 @@ abstract class FastTable<T : Identifiable<Int>>
    * @param x readable sql database
    * @return an extras instance for more concise reads
    */
-   override fun onFind(x: SQLiteDatabase): TableCrud.Extras<T> =
+  override fun onFind(x: SQLiteDatabase): TableCrud.Extras<T> =
       object : QueryExtras<T>(x) {
         /**
          *
diff --git a/database/src/main/java/promise/db/PromiseDatabase.java b/database/src/main/java/promise/db/PromiseDatabase.java
index a0f6463..a1e423f 100644
--- a/database/src/main/java/promise/db/PromiseDatabase.java
+++ b/database/src/main/java/promise/db/PromiseDatabase.java
@@ -27,8 +27,9 @@ public interface PromiseDatabase {
 
   /**
    * returns the table associated with the entity class
+   *
    * @param entityClass class of the entity persisted
-   * @param <T> entity
+   * @param <T>         entity
    * @return FastTable of the entity
    * @throws IllegalArgumentException if entity is not registered with the database
    */
diff --git a/database/src/main/java/promise/db/ReactiveCrud.kt b/database/src/main/java/promise/db/ReactiveCrud.kt
index d968455..82b5f24 100644
--- a/database/src/main/java/promise/db/ReactiveCrud.kt
+++ b/database/src/main/java/promise/db/ReactiveCrud.kt
@@ -12,6 +12,7 @@
  */
 package promise.db
 
+import android.database.Cursor
 import io.reactivex.Maybe
 import io.reactivex.Single
 import promise.commons.model.Identifiable
@@ -21,7 +22,10 @@ import promise.model.IdentifiableList
 /**
  *
  */
-internal interface ReactiveCrud<X> {
+interface ReactiveCrud<X> : Crud<X> {
+
+  fun queryAsync(queryBuilder: QueryBuilder): Single<Cursor>
+
   /**
    *
    */
diff --git a/database/src/main/java/promise/db/ReactiveFastDatabase.kt b/database/src/main/java/promise/db/ReactiveFastDatabase.kt
index cfb8ed6..37349ce 100644
--- a/database/src/main/java/promise/db/ReactiveFastDatabase.kt
+++ b/database/src/main/java/promise/db/ReactiveFastDatabase.kt
@@ -35,7 +35,7 @@ class ReactiveFastDatabase private constructor(
     factory: SQLiteDatabase.CursorFactory?,
     version: Int,
     errorHandler: DatabaseErrorHandler) :
-    FastDatabase(name, factory, version, errorHandler),
+    FastDatabaseImpl(name, factory, version, errorHandler),
     ReactiveCrud<SQLiteDatabase> {
   private val TAG: String = LogUtil.makeTag(ReactiveFastDatabase::class.java)
 
@@ -74,10 +74,10 @@ class ReactiveFastDatabase private constructor(
       Single.fromCallable { tableCrud.onDrop(database) }
 
   /**
-   * @param builder
+   * @param queryBuilder
    * @return
    */
-  fun queryAsync(builder: QueryBuilder): Single<Cursor> = Single.fromCallable { query(builder) }
+  override fun queryAsync(queryBuilder: QueryBuilder): Single<Cursor> = Single.fromCallable { query(queryBuilder) }
 
   /**
    * @param tableCrud
@@ -190,7 +190,7 @@ class ReactiveFastDatabase private constructor(
       Maybe.zip(tables().map { tableCrud: TableCrud<*, in SQLiteDatabase> -> this.deleteAsync(tableCrud) }
       ) { objects: Array<Any> ->
         List.fromArray<Any>(*objects).allMatch { aBoolean: Any ->
-          aBoolean is Boolean &&  aBoolean
+          aBoolean is Boolean && aBoolean
         }
       }
 
@@ -269,7 +269,7 @@ class ReactiveFastDatabase private constructor(
      * @return
      */
     @SafeVarargs
-    override fun  notIn(column: Column<Number>, vararg bounds: Number): Maybe<IdentifiableList<out T>> =
+    override fun notIn(column: Column<Number>, vararg bounds: Number): Maybe<IdentifiableList<out T>> =
         Maybe.fromCallable { tableCrud.onFind(database).notIn(column, *bounds) }
 
     /**
diff --git a/database/src/main/java/promise/db/TableCrud.kt b/database/src/main/java/promise/db/TableCrud.kt
index bd2f094..09b3b23 100644
--- a/database/src/main/java/promise/db/TableCrud.kt
+++ b/database/src/main/java/promise/db/TableCrud.kt
@@ -150,6 +150,7 @@ interface TableCrud<T : Identifiable<Int>, X> : DoubleConverter<T, Cursor, Conte
   fun onDrop(x: X): Boolean
 
   fun onGetLastId(x: X): Int
+
   /**
    * @return tableName of this table
    */
diff --git a/database/src/main/java/promise/db/from/From.java b/database/src/main/java/promise/db/from/From.java
index fe08656..27eeb96 100644
--- a/database/src/main/java/promise/db/from/From.java
+++ b/database/src/main/java/promise/db/from/From.java
@@ -15,8 +15,8 @@
 
 import promise.commons.model.List;
 import promise.db.Column;
-import promise.db.TableCrud;
 import promise.db.QueryBuilder;
+import promise.db.TableCrud;
 import promise.db.criteria.Criteria;
 import promise.db.projection.Projection;
 
diff --git a/database/src/main/java/promise/db/projection/Projection.java b/database/src/main/java/promise/db/projection/Projection.java
index f566d6f..d4adfd8 100644
--- a/database/src/main/java/promise/db/projection/Projection.java
+++ b/database/src/main/java/promise/db/projection/Projection.java
@@ -15,8 +15,8 @@
 
 import promise.commons.model.List;
 import promise.db.Column;
-import promise.db.TableCrud;
 import promise.db.QueryBuilder;
+import promise.db.TableCrud;
 
 public abstract class Projection {
   // Simple column
diff --git a/database/src/main/java/promise/model/IdentifiableList.java b/database/src/main/java/promise/model/IdentifiableList.java
index f414853..ce3561f 100644
--- a/database/src/main/java/promise/model/IdentifiableList.java
+++ b/database/src/main/java/promise/model/IdentifiableList.java
@@ -73,7 +73,8 @@ public boolean remove(T t) {
     if (t instanceof ActiveRecord<?>) {
       try {
         ((ActiveRecord) t).delete();
-      } catch (Exception ignored) {}
+      } catch (Exception ignored) {
+      }
     }
     super.remove(getIndex(t));
     return true;
@@ -83,7 +84,8 @@ public void delete(T t) {
     if (t instanceof ActiveRecord<?>) {
       try {
         ((ActiveRecord) t).delete();
-      } catch (Exception ignored) {}
+      } catch (Exception ignored) {
+      }
     }
     removeWithID(t.getId());
   }
@@ -92,7 +94,8 @@ public void update(T t) {
     if (t instanceof ActiveRecord<?>) {
       try {
         ((ActiveRecord) t).update();
-      } catch (Exception ignored) {}
+      } catch (Exception ignored) {
+      }
     }
     super.set(getIndex(t), t);
   }
@@ -109,4 +112,5 @@ public IdentifiableList<T> sortWithID() {
             o1.getId() > o2.getId() ? -1 : 0);
     return this;
   }
+
 }
diff --git a/database/src/test/java/promise/db/ExampleUnitTest.java b/database/src/test/java/promise/db/ExampleUnitTest.java
index b0610e1..983ea92 100644
--- a/database/src/test/java/promise/db/ExampleUnitTest.java
+++ b/database/src/test/java/promise/db/ExampleUnitTest.java
@@ -15,7 +15,7 @@
 
 import org.junit.Test;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 /**
  * Example local unit test, which will execute on the development machine (host).

From 538e142b52e8aed71211d843c6356aa1176de6f3 Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Tue, 4 Aug 2020 21:05:38 +0300
Subject: [PATCH 06/34] code refactor

---
 .../DatabaseAbstractMethodsGenerator.kt       |  5 --
 .../db/ompiler/DatabaseAnnotationGenerator.kt | 10 +---
 .../db/ompiler/EntityAnnotatedProcessor.kt    |  2 +-
 .../db/ompiler/TableColumnFieldsGenerator.kt  |  2 +-
 .../ompiler/TableSerializerMethodGenerator.kt | 24 +-------
 .../TypeConverterAnnotatedProcessor.kt        | 60 -------------------
 .../promise/db/ompiler/utils/JavaUtils.java   | 56 -----------------
 .../ompiler/utils/PersistableEntityUtils.kt   | 46 +-------------
 .../java/promise/db/ompiler/utils/Utils.kt    | 35 -----------
 9 files changed, 7 insertions(+), 233 deletions(-)

diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseAbstractMethodsGenerator.kt b/compiler/src/main/java/promise/db/ompiler/DatabaseAbstractMethodsGenerator.kt
index bbe26d3..f3132e2 100644
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseAbstractMethodsGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/DatabaseAbstractMethodsGenerator.kt
@@ -33,7 +33,6 @@ import javax.lang.model.type.TypeKind
 import javax.lang.model.util.ElementFilter
 import javax.tools.Diagnostic
 
-
 class DatabaseAbstractMethodsGenerator(
     private val element: TypeElement,
     private val processingEnv: ProcessingEnvironment) : CodeGenerator<List<MethodSpec>?> {
@@ -101,10 +100,6 @@ class DatabaseAbstractMethodsGenerator(
         .addCode(codeBlock.build())
         .build())
 
-    val retutnType = """
-      TableCrud<T, ? super SQLiteDatabase> 
-    """.trimIndent()
-
     return funSpecs
   }
 
diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseAnnotationGenerator.kt b/compiler/src/main/java/promise/db/ompiler/DatabaseAnnotationGenerator.kt
index 06b5d3b..b520392 100644
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseAnnotationGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/DatabaseAnnotationGenerator.kt
@@ -25,18 +25,10 @@ import javax.lang.model.element.Element
 import javax.lang.model.element.TypeElement
 import javax.tools.Diagnostic
 
-
 class DatabaseAnnotationGenerator(
     private val processingEnv: ProcessingEnvironment,
     private val element: Element) : CodeGenerator<AnnotationSpec> {
-  /*
-  @Database(
-    tables = [
-      PersonFastTable::class
-    ],
-    version = 2
-)
-   */
+
   override fun generate(): AnnotationSpec {
     if (element is TypeElement) {
       var stmt = " {\n"
diff --git a/compiler/src/main/java/promise/db/ompiler/EntityAnnotatedProcessor.kt b/compiler/src/main/java/promise/db/ompiler/EntityAnnotatedProcessor.kt
index 064ebff..7784b3f 100644
--- a/compiler/src/main/java/promise/db/ompiler/EntityAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/db/ompiler/EntityAnnotatedProcessor.kt
@@ -148,7 +148,7 @@ class EntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment)
     classBuilder.addMethod(columnRegSpecGenerator.generate())
 
     // serializer generator
-    val serializerGenerator = TableSerializerMethodGenerator(processingEnv, pack, className, tableColumnPropsGenerator.genColValues)
+    val serializerGenerator = TableSerializerMethodGenerator(pack, className, tableColumnPropsGenerator.genColValues)
     classBuilder.addMethod(serializerGenerator.generate())
 
     // deserializer generator
diff --git a/compiler/src/main/java/promise/db/ompiler/TableColumnFieldsGenerator.kt b/compiler/src/main/java/promise/db/ompiler/TableColumnFieldsGenerator.kt
index abbf6c5..c00e73f 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableColumnFieldsGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/TableColumnFieldsGenerator.kt
@@ -60,7 +60,7 @@ class TableColumnFieldsGenerator(
        * For fields that need type converter
        */
       if (!element.isPersistable() && !element.isElementAnnotatedAsRelation()) {
-        if (element.checkIfHasTypeConverter(processingEnvironment)) {
+        if (element.checkIfHasTypeConverter()) {
           val parameterizedColumnTypeName = ParameterizedTypeName.get(
               ClassName.get("promise.db", "Column"),
               TypeName.get(String::class.java))
diff --git a/compiler/src/main/java/promise/db/ompiler/TableSerializerMethodGenerator.kt b/compiler/src/main/java/promise/db/ompiler/TableSerializerMethodGenerator.kt
index 1527c2a..b15f244 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableSerializerMethodGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/TableSerializerMethodGenerator.kt
@@ -24,18 +24,15 @@ import promise.db.ompiler.utils.getConverterCompatibleMethod
 import promise.db.ompiler.utils.isElementAnnotatedAsRelation
 import promise.db.ompiler.utils.isSameAs
 import promise.db.ompiler.utils.toTypeName
-import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
 
 
 class TableSerializerMethodGenerator(
-    private val processingEnvironment: ProcessingEnvironment,
     private val typeDataTypePack: String,
     private val typeDataType: String,
     private val columns: List<Pair<Pair<String, Element>, String>>) : CodeGenerator<MethodSpec> {
 
-
   override fun generate(): MethodSpec {
 
     val codeBlock = CodeBlock.builder()
@@ -57,10 +54,6 @@ class TableSerializerMethodGenerator(
         .build()
   }
 
-  /**
-   * values.put(nameColumn.getName(), t.getName());
-   * values.put(isAdultColumn.getName(), person.isAdult() ? 1 : 0);
-   */
   private fun generatePutStatement(
       codeBlock: CodeBlock.Builder,
       typeVariable: String, columnName: String, varTypeName: Element) {
@@ -68,27 +61,12 @@ class TableSerializerMethodGenerator(
       codeBlock.addStatement("values.put(${columnName}.getName(), t.is${typeVariable.capitalizeFirst()}() ? 1 : 0)")
       return
     }
-
     if (varTypeName.checkIfHasTypeConverter()) {
-
       val executableFn = varTypeName.getConverterCompatibleMethod(ConverterTypes.SERIALIZER)
-      if (executableFn != null) {
+      if (executableFn != null)
         codeBlock.addStatement("values.put(${columnName}.getName(), typeConverter.${executableFn.simpleName}(t.get${typeVariable.capitalizeFirst()}()))")
-      }
     } else if (varTypeName.isElementAnnotatedAsRelation()) {
-//            processingEnvironment.messager.printMessage(Diagnostic.Kind.ERROR,
-//         "serializer Checking element: $varTypeName for typeName $varTypeName " )
-      val gen = """
-         Person person = t.getPerson();
-          if (person != null) {
-            values.put(personColumn.getName(), person.getId());
-          }    
-      """.trimIndent()
       codeBlock.add(JavaUtils.generateSerializerRelationPutStatement(varTypeName, columnName))
-      //return "values.put(${columnName}.getName(), t.get${typeVariable.capitalizeFirst()}()); \n"
     } else codeBlock.addStatement("values.put(${columnName}.getName(), t.get${typeVariable.capitalizeFirst()}())")
-    //throw Exception("Could not generate serializer method for entity")
   }
-
-
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/db/ompiler/TypeConverterAnnotatedProcessor.kt b/compiler/src/main/java/promise/db/ompiler/TypeConverterAnnotatedProcessor.kt
index 06c58b0..0e04252 100644
--- a/compiler/src/main/java/promise/db/ompiler/TypeConverterAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/db/ompiler/TypeConverterAnnotatedProcessor.kt
@@ -23,7 +23,6 @@ import javax.annotation.processing.RoundEnvironment
 import javax.lang.model.element.TypeElement
 import javax.tools.Diagnostic
 
-
 class TypeConverterAnnotatedProcessor(private val processingEnv: ProcessingEnvironment) : AnnotatedClassProcessor() {
 
   override fun process(environment: RoundEnvironment?): List<JavaFile.Builder?>? {
@@ -34,7 +33,6 @@ class TypeConverterAnnotatedProcessor(private val processingEnv: ProcessingEnvir
         typeConverter = typeConverters.firstOrNull() as TypeElement
         return Collections.singletonList(processElement(typeConverter!!))
       } catch (e: Throwable) {
-
       }
     }
     return null
@@ -44,67 +42,9 @@ class TypeConverterAnnotatedProcessor(private val processingEnv: ProcessingEnvir
     val className = element.simpleName.toString()
    val pack = processingEnv.elementUtils.getPackageOf(element).toString()
     return Utils.generateInstanceProviderHolder(ClassName.get(pack, className))
-//    val className = element.simpleName.toString()
-//    val pack = processingEnv.elementUtils.getPackageOf(element).toString()
-//
-//    val fileName = element.getTypeConverterClassName()
-//
-//    val varName = element.getVariableName()
-//
-//    val classBuilder = TypeSpec.classBuilder(fileName)
-//        .addJavadoc("""
-//          Class holder for instantiation of TypeConverter
-//        """.trimIndent())
-//        .addModifiers(Modifier.FINAL, Modifier.PUBLIC)
-//        .addSuperinterface(ParameterizedTypeName.get(
-//            ClassName.get("promise.commons", "InstanceProvider"),
-//            ClassName.get(pack, className)
-//        ))
-//        // field instance for the holder
-//        .addField(FieldSpec.builder(
-//            ClassName.get(pack, fileName),
-//            "instance"
-//        ).addModifiers(Modifier.PRIVATE, Modifier.STATIC)
-//            .build())
-//        // holder for type converter
-//        .addField(FieldSpec.builder(element.toTypeName(), varName,
-//            Modifier.FINAL, Modifier.PRIVATE)
-//            .addJavadoc("""
-//              holder instance for the TypeConverter
-//            """.trimIndent())
-//            .build())
-//        // constructor for the holder
-//        .addMethod(MethodSpec.constructorBuilder()
-//            .addModifiers(Modifier.PRIVATE)
-//            .addParameter(ClassName.get(pack, className), varName)
-//            .addStatement("this.$varName = $varName")
-//            .build())
-//        .addMethod(MethodSpec.methodBuilder("create")
-//            .returns(ClassName.get(pack, fileName))
-//            .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
-//            .addJavadoc("""
-//              Creates an instance of the holder with the converter
-//            """.trimIndent())
-//            .addParameter(
-//                ClassName.get(pack, className),
-//                varName)
-//            .addCode(CodeBlock.builder()
-//                .addStatement("if (instance == null) instance = new $fileName($varName)")
-//                .addStatement("return instance")
-//                .build())
-//            .build())
-//        .addMethod(MethodSpec.methodBuilder("get")
-//            .addAnnotation(Override::class.java)
-//            .returns(ClassName.get(pack, className))
-//            .addModifiers(Modifier.PUBLIC)
-//            .addCode("return $varName;")
-//            .build())
-//
-//    return JavaFile.builder(pack, classBuilder.build())
   }
 
   companion object {
     var typeConverter: TypeElement? = null
-
   }
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/db/ompiler/utils/JavaUtils.java b/compiler/src/main/java/promise/db/ompiler/utils/JavaUtils.java
index ea5f7d6..5b364bb 100644
--- a/compiler/src/main/java/promise/db/ompiler/utils/JavaUtils.java
+++ b/compiler/src/main/java/promise/db/ompiler/utils/JavaUtils.java
@@ -85,7 +85,6 @@ public static void generateIfStatementObtainClassString(
     String pack = processingEnv.getElementUtils().getPackageOf(entity).toString();
     if (PersistableEntityUtilsKt.checkIfAnyElementNeedsTypeConverter(entity)) {
       String tableVarName = PersistableEntityUtilsKt.camelCase(PersistableEntityUtilsKt.getClassName(entity));
-
       codeBlock.beginControlFlow("if (entityClass == $T.class)", ClassName.get(pack, entity.getSimpleName().toString()));
       codeBlock.addStatement("$T " + tableVarName + " = getDatabaseInstance().obtain($T.class)",
           ClassName.get(pack, PersistableEntityUtilsKt.getClassName(entity)),
@@ -116,13 +115,6 @@ public static CodeBlock generateDeserializerRelationSetStatement(
       String entitySetName,
       Element element,
       String colName) {
-    String gen = "" +
-        " int personId = e.getInt(personColumn.getIndex(e));\n" +
-        "      if (personId != 0) {\n" +
-        "        Person person = new Person();\n" +
-        "        person.setId(personId);\n" +
-        "        dog.setPerson(person);\n" +
-        "      }";
     CodeBlock.Builder codeBlock = CodeBlock.builder();
     String variableName = PersistableEntityUtilsKt.camelCase(element.getSimpleName().toString());
     String variableNameId = variableName + "Id";
@@ -155,21 +147,6 @@ public static <T> Class<T> wrap(Class<T> c) {
     return c.isPrimitive() ? (Class<T>) PRIMITIVES_TO_WRAPPERS.get(c) : c;
   }
 
-  /**
-   * gets the super class for type element
-   *
-   * @param typeElement to be checked for super class
-   * @return superclass or null
-   */
-  @Nullable
-  public static TypeElement getSuperClass(TypeElement typeElement) {
-    TypeMirror type = typeElement.getSuperclass();
-    if (type.getKind() == TypeKind.NONE) {
-      return null;
-    }
-    return (TypeElement) ((DeclaredType) type).asElement();
-  }
-
   /**
    * checks if typemirror is equal to a typename
    *
@@ -185,39 +162,6 @@ public static boolean isTypeEqual(TypeMirror typeMirror, TypeName otherType) {
     return otherType.toString().equals(TypeName.get(typeMirror).toString());
   }
 
-  /**
-   * checks if type mirror is a sub type of other type
-   *
-   * @param typeMirror
-   * @param otherType
-   * @return
-   */
-  public static boolean isSubTypeOfType(TypeMirror typeMirror, TypeName otherType) {
-    if (typeMirror.getKind() == TypeKind.NONE) return false;
-    if (isTypeEqual(typeMirror, otherType)) return true;
-    if (typeMirror.getKind() != TypeKind.DECLARED) return false;
-    DeclaredType declaredType = (DeclaredType) typeMirror;
-    List<? extends TypeMirror> typeArguments = declaredType.getTypeArguments();
-    if (typeArguments.size() > 0) {
-      StringBuilder typeString = new StringBuilder(declaredType.asElement().toString());
-      typeString.append('<');
-      for (int i = 0; i < typeArguments.size(); i++) {
-        if (i > 0) typeString.append(',');
-        typeString.append('?');
-      }
-      typeString.append('>');
-      if (typeString.toString().equals(otherType.toString())) return true;
-    }
-    Element element = declaredType.asElement();
-    if (!(element instanceof TypeElement)) return false;
-    TypeElement typeElement = (TypeElement) element;
-    TypeMirror superType = typeElement.getSuperclass();
-    if (isSubTypeOfType(superType, otherType)) return true;
-    for (TypeMirror interfaceType : typeElement.getInterfaces())
-      if (isSubTypeOfType(interfaceType, otherType)) return true;
-    return false;
-  }
-
   public static DeclaredType getDeclaredType(ProcessingEnvironment processingEnvironment, TypeElement typeElement) {
     return processingEnvironment.getTypeUtils().getDeclaredType(typeElement);
   }
diff --git a/compiler/src/main/java/promise/db/ompiler/utils/PersistableEntityUtils.kt b/compiler/src/main/java/promise/db/ompiler/utils/PersistableEntityUtils.kt
index 2bb4b06..0a7be40 100644
--- a/compiler/src/main/java/promise/db/ompiler/utils/PersistableEntityUtils.kt
+++ b/compiler/src/main/java/promise/db/ompiler/utils/PersistableEntityUtils.kt
@@ -133,8 +133,6 @@ fun TypeElement.getDatabaseVersion(): Int {
  * gets name of column for a field in entity class
  */
 fun Element.getNameOfColumn(): String {
-  //processingEnvironment.messager.printMessage(Diagnostic.Kind.ERROR, "elemtype: "+element.toTypeName().toString()+"\n")
-  //processingEnvironment.messager.printMessage(Diagnostic.Kind.ERROR, "class type: "+Int::class.java.name+"\n")
   var name: String? = null
   if ((this.toTypeName().isSameAs(Integer::class.java) ||
           this.toTypeName().isSameAs(Float::class.java) ||
@@ -143,8 +141,8 @@ fun Element.getNameOfColumn(): String {
       this.getAnnotation(promise.db.Number::class.java) != null) {
     name = this.getAnnotation(promise.db.Number::class.java).columnName
   } else if (this.toTypeName().isSameAs(String::class.java) &&
-      this.getAnnotation(promise.db.VarChar::class.java) != null) {
-    name = this.getAnnotation(promise.db.VarChar::class.java).columnName
+      this.getAnnotation(VarChar::class.java) != null) {
+    name = this.getAnnotation(VarChar::class.java).columnName
   } else if (this.getAnnotation(Text::class.java) != null) {
     name = this.getAnnotation(Text::class.java).columnName
   } else if (this.getAnnotation(VarChar::class.java) != null) {
@@ -167,21 +165,12 @@ fun TypeElement.checkIfAnyElementNeedsTypeConverter(): Boolean = ElementFilter.f
 }
 
 fun Element.checkIfHasTypeConverter(): Boolean {
-  //return true
   if (TypeConverterAnnotatedProcessor.typeConverter != null)
     return this.getConverterCompatibleMethod(ConverterTypes.SERIALIZER) != null &&
         this.getConverterCompatibleMethod(ConverterTypes.DESERIALIZER) != null
   return false
 }
 
-fun Element.checkIfHasTypeConverter(processingEnv: ProcessingEnvironment): Boolean {
-  //return true
-  if (TypeConverterAnnotatedProcessor.typeConverter != null)
-    return this.getConverterCompatibleMethod(ConverterTypes.SERIALIZER, processingEnv) != null &&
-        this.getConverterCompatibleMethod(ConverterTypes.DESERIALIZER, processingEnv) != null
-  return false
-}
-
 enum class ConverterTypes {
   DESERIALIZER,
   SERIALIZER
@@ -210,37 +199,8 @@ fun Element.getConverterCompatibleMethod(converterTypes: ConverterTypes): Execut
 }
 
 
-fun Element.getConverterCompatibleMethod(converterTypes: ConverterTypes, processingEnv: ProcessingEnvironment): ExecutableElement? {
-  if (TypeConverterAnnotatedProcessor.typeConverter != null) {
-    val methods =
-        ElementFilter.methodsIn(TypeConverterAnnotatedProcessor.typeConverter!!.enclosedElements)
-            .filter {
-              it.parameters.size == 1
-            }
-    return methods.find {
-      if (this.asType().kind == TypeKind.VOID) return@find false
-//      processingEnv.messager.printMessage(Diagnostic.Kind.NOTE, "Type converter: " +
-//          " method: ${it}, " +
-//          " returnType: ${TypeName.get(it.returnType)}" +
-//          " parameter: ${TypeName.get(it.parameters[0].asType())}" +
-//          " elementType ${TypeName.get(this.asType())}")
-      when (converterTypes) {
-        ConverterTypes.DESERIALIZER -> {
-
-          JavaUtils.isTypeEqual(it.parameters[0].asType(), TypeName.get(String::class.java)) &&
-              JavaUtils.isTypeEqual(it.returnType, TypeName.get(this.asType()))
-        }
-        ConverterTypes.SERIALIZER -> {
-          JavaUtils.isTypeEqual(it.parameters[0].asType(), TypeName.get(this.asType())) &&
-              JavaUtils.isTypeEqual(it.returnType, TypeName.get(String::class.java))
-        }
-      }
-    }
-  } else return null
-}
-
 fun Element.isElementAnnotatedAsRelation(): Boolean {
-  //return false
+
   return this.getAnnotation(HasMany::class.java) != null ||
       this.getAnnotation(HasOne::class.java) != null
 }
diff --git a/compiler/src/main/java/promise/db/ompiler/utils/Utils.kt b/compiler/src/main/java/promise/db/ompiler/utils/Utils.kt
index caeddc2..5275f75 100644
--- a/compiler/src/main/java/promise/db/ompiler/utils/Utils.kt
+++ b/compiler/src/main/java/promise/db/ompiler/utils/Utils.kt
@@ -73,13 +73,6 @@ fun VariableElement.getClass(): KClass<*> {
   }
 }
 
-fun getAnnotationMirror(element: Element, annotationClass: Class<out Annotation?>): Optional<out AnnotationMirror?>? {
-  val annotationClassName = annotationClass.name
-  return element.annotationMirrors.stream()
-      .filter { m: AnnotationMirror? -> m!!.annotationType.toString() == annotationClassName }
-      .findFirst()
-}
-
 fun TypeMirror.asTypeElement(processingEnv: ProcessingEnvironment): TypeElement {
   val typeUtils: Types = processingEnv.typeUtils
   return (try {
@@ -134,34 +127,6 @@ object Utils {
     return null
   }
 
-  /**
-   * Returns true if a and b are equal, including if they are both null.
-   *
-   * *Note: In platform versions 1.1 and earlier, this method only worked well if
-   * both the arguments were instances of String.*
-   *
-   * @param a first CharSequence to check
-   * @param b second CharSequence to check
-   * @return true if a and b are equal
-   *
-   *
-   * NOTE: Logic slightly change due to strict policy on CI -
-   * "Inner assignments should be avoided"
-   */
-
-
-  fun notEquals(a: CharSequence?, b: CharSequence?): Boolean {
-    if (a === b) return false
-    if (a != null && b != null) {
-      val length = a.length
-      if (length == b.length) return if (a is String && b is String) a != b else {
-        for (i in 0 until length) if (a[i] != b[i]) return true
-        false
-      }
-    }
-    return true
-  }
-
   /**
    * Copied from "android.util.Log.getStackTraceString()" in order to avoid usage of Android stack
    * in unit tests.

From 944c2fb0ae6fa6254d16617f8b9009e333d81300 Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Wed, 5 Aug 2020 21:06:55 +0300
Subject: [PATCH 07/34] has one relations

---
 compiler/build.gradle                         |   4 -
 .../DatabaseAbstractMethodsGenerator.kt       |   4 +-
 .../db/ompiler/DatabaseAnnotationGenerator.kt |   4 +-
 .../DatabaseEntityAnnotatedProcessor.kt       |  31 +-
 .../ompiler/DatabaseStaticMethodsGenerator.kt |  51 +-
 .../db/ompiler/EntityAnnotatedProcessor.kt    |  16 +-
 .../db/ompiler/PromiseDatabaseCompiler.kt     |  20 +-
 .../db/ompiler/RelationsDaoGenerator.java     | 575 ++++++++++++++++++
 .../db/ompiler/RelationsDaoProcessor.kt       |  45 ++
 .../db/ompiler/TableRelationsGenerator.java   | 311 ----------
 .../promise/db/ompiler/utils/JavaUtils.java   |  56 +-
 .../ompiler/utils/PersistableEntityUtils.kt   |   4 +-
 .../main/java/promise/db/PromiseDatabase.java |  15 +-
 13 files changed, 736 insertions(+), 400 deletions(-)
 create mode 100644 compiler/src/main/java/promise/db/ompiler/RelationsDaoGenerator.java
 create mode 100644 compiler/src/main/java/promise/db/ompiler/RelationsDaoProcessor.kt
 delete mode 100644 compiler/src/main/java/promise/db/ompiler/TableRelationsGenerator.java

diff --git a/compiler/build.gradle b/compiler/build.gradle
index 6a3f654..54634b5 100644
--- a/compiler/build.gradle
+++ b/compiler/build.gradle
@@ -20,8 +20,6 @@ apply plugin: 'maven'
 
 dependencies {
     compileOnly project(path: ':commons')
-    //compileOnly files(Jvm.current().getJre().homeDir.getAbsolutePath()+'/lib/rt.jar')
-    //compileOnly files("${System.properties['java.home']}/../lib/tools.jar")
     compileOnly files(Jvm.current().getToolsJar())
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
 
@@ -33,7 +31,5 @@ dependencies {
     compileOnly "com.google.auto.service:auto-service:1.0-rc4"
     kapt "com.google.auto.service:auto-service:1.0-rc4"
 
-    api "net.ltgt.gradle.incap:incap:0.2"
-    compileOnly "net.ltgt.gradle.incap:incap-processor:0.2"
     testImplementation 'junit:junit:4.13'
 }
diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseAbstractMethodsGenerator.kt b/compiler/src/main/java/promise/db/ompiler/DatabaseAbstractMethodsGenerator.kt
index f3132e2..8c006d7 100644
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseAbstractMethodsGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/DatabaseAbstractMethodsGenerator.kt
@@ -22,7 +22,7 @@ import com.squareup.javapoet.WildcardTypeName
 import org.jetbrains.annotations.NotNull
 import promise.db.ompiler.utils.JavaUtils
 import promise.db.ompiler.utils.asTypeElement
-import promise.db.ompiler.utils.getClassName
+import promise.db.ompiler.utils.getTableClassNameString
 import promise.db.ompiler.utils.getTableEntities
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
@@ -109,7 +109,7 @@ class DatabaseAbstractMethodsGenerator(
     if (entities.isEmpty()) entities = element.getTableEntities(processingEnv)
     var pack = ""
     entities.forEach {
-      if (returnTypeName == it.getClassName()) {
+      if (returnTypeName == it.getTableClassNameString()) {
         pack = processingEnv.elementUtils.getPackageOf(it).toString()
       }
     }
diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseAnnotationGenerator.kt b/compiler/src/main/java/promise/db/ompiler/DatabaseAnnotationGenerator.kt
index b520392..6aadbda 100644
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseAnnotationGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/DatabaseAnnotationGenerator.kt
@@ -17,7 +17,7 @@ import com.squareup.javapoet.AnnotationSpec
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
 import promise.db.ompiler.utils.Utils
-import promise.db.ompiler.utils.getClassName
+import promise.db.ompiler.utils.getTableClassNameString
 import promise.db.ompiler.utils.getDatabaseVersion
 import promise.db.ompiler.utils.getTableEntities
 import javax.annotation.processing.ProcessingEnvironment
@@ -41,7 +41,7 @@ class DatabaseAnnotationGenerator(
       val version = element.getDatabaseVersion()
       try {
         entities?.forEachIndexed { index, entityClass ->
-          val className = entityClass.getClassName()
+          val className = entityClass.getTableClassNameString()
           //fileBuilder.addImport(pack, className)
           stmt += "$className.class"
           if (index != entities.size - 1) {
diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseEntityAnnotatedProcessor.kt b/compiler/src/main/java/promise/db/ompiler/DatabaseEntityAnnotatedProcessor.kt
index 57aa15d..90498d4 100644
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseEntityAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/db/ompiler/DatabaseEntityAnnotatedProcessor.kt
@@ -19,6 +19,9 @@ import com.squareup.javapoet.MethodSpec
 import com.squareup.javapoet.TypeSpec
 import promise.db.DatabaseEntity
 import promise.db.ompiler.utils.JavaUtils
+import promise.db.ompiler.utils.asTableClassName
+import promise.db.ompiler.utils.getTableClassNameString
+import promise.db.ompiler.utils.getTableEntities
 import javax.annotation.processing.ProcessingEnvironment
 import javax.annotation.processing.RoundEnvironment
 import javax.lang.model.element.Element
@@ -54,9 +57,9 @@ class DatabaseEntityAnnotatedProcessor(private val processingEnv: ProcessingEnvi
     val className = element.simpleName.toString()
     val pack = processingEnv.elementUtils.getPackageOf(element).toString()
 
-    val fileName = "${className}_Impl"
+    val fileName = "${className}Impl"
 
-    val tableAnnotationSpec = DatabaseAnnotationGenerator(processingEnv, element).generate()
+    val databaseAnnotationSpec = DatabaseAnnotationGenerator(processingEnv, element).generate()
 
     val classBuilder = TypeSpec.classBuilder(fileName)
 
@@ -64,19 +67,37 @@ class DatabaseEntityAnnotatedProcessor(private val processingEnv: ProcessingEnvi
         .addParameter(ClassName.get("promise.db", "FastDatabase"),
             "fastDatabase")
         .addModifiers(Modifier.PRIVATE)
-        .addStatement("super()")
-        .addStatement("this.instance = fastDatabase")
+        .addStatement("super(fastDatabase)")
     if (TypeConverterAnnotatedProcessor.typeConverter != null) {
       constructorMethod.addJavadoc("""
         Initializes the TypeConverter as singleton
       """.trimIndent())
       JavaUtils.generateAddConverterStatementInDatabaseConstructorMethod(processingEnv, constructorMethod, TypeConverterAnnotatedProcessor.typeConverter!!)
     }
+
+    if (RelationsDaoGenerator.relationsMap.isNotEmpty()) {
+      classBuilder.addMethods(RelationsDaoGenerator.relationsMap.map {
+        MethodSpec.methodBuilder("get"+ it.key.simpleName())
+            .addModifiers(Modifier.PUBLIC)
+            .returns(it.key)
+            .addCode(JavaUtils.generateGetRelationDaoCodeBlock(it).build())
+            .build()
+      })
+    }
+
     classBuilder.superclass(ClassName.get(pack, className))
-        .addAnnotation(tableAnnotationSpec)
+        .addAnnotation(databaseAnnotationSpec)
         .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
         .addMethod(constructorMethod.build())
 
+    (element as TypeElement).getTableEntities(processingEnv).forEach {
+      classBuilder.addMethod(MethodSpec.methodBuilder("get"+it.getTableClassNameString())
+          .addModifiers(Modifier.PUBLIC)
+          .returns(it.asTableClassName(processingEnv))
+          .addCode(JavaUtils.generateGetTableStatement(processingEnv, it))
+          .build())
+    }
+
     DatabaseStaticMethodsGenerator(classBuilder, element, processingEnv).generate()
 
     val abstractFuncsBuilder = DatabaseAbstractMethodsGenerator((element as TypeElement), processingEnv)
diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseStaticMethodsGenerator.kt b/compiler/src/main/java/promise/db/ompiler/DatabaseStaticMethodsGenerator.kt
index a34b092..49fb15e 100644
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseStaticMethodsGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/DatabaseStaticMethodsGenerator.kt
@@ -21,7 +21,7 @@ import com.squareup.javapoet.TypeSpec
 import promise.db.AddedEntity
 import promise.db.ompiler.utils.JavaUtils
 import promise.db.ompiler.utils.Utils
-import promise.db.ompiler.utils.getClassName
+import promise.db.ompiler.utils.getTableClassNameString
 import promise.db.ompiler.utils.getTableEntities
 import promise.db.ompiler.utils.toTypeName
 import javax.annotation.processing.ProcessingEnvironment
@@ -37,15 +37,9 @@ class DatabaseStaticMethodsGenerator(
 
   override fun generate(): String {
     val className = element.simpleName.toString()
-    val classnameImpl = "${className}_Impl"
+    val classnameImpl = "${className}Impl"
     val pack = processingEnv.elementUtils.getPackageOf(element).toString()
 
-    try {
-      //fileSpec.addImport("android.database.sqlite", "SQLiteDatabase")
-    } catch (e: Throwable) {
-      processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "Add Import: ${Utils.getStackTraceString(e)}")
-    }
-
     val entities = (element as TypeElement).getTableEntities(processingEnv)
         .filter {
           it.getAnnotation(AddedEntity::class.java) != null
@@ -58,7 +52,7 @@ class DatabaseStaticMethodsGenerator(
       entities.forEach {
         val migrationAnnotation = it.getAnnotation(AddedEntity::class.java)
         migrationCodeBlock.beginControlFlow("if (oldVersion == ${migrationAnnotation.fromVersion} && newVersion == ${migrationAnnotation.toVersion})")
-        migrationCodeBlock.addStatement("database.add(sqLiteDatabase, database.obtain(${it.getClassName()}.class))")
+        migrationCodeBlock.addStatement("database.add(sqLiteDatabase, database.obtain(${it.getTableClassNameString()}.class))")
         migrationCodeBlock.endControlFlow()
       }
       migrationCodeBlock.endControlFlow()
@@ -75,15 +69,6 @@ class DatabaseStaticMethodsGenerator(
         .build()
 
     typeSpec.addMethod(migrationPropSpec)
-    // adding db instance var
-    // private static volatile FastDatabase instance = null;
-    typeSpec.addField(FieldSpec.builder(ClassName.get("promise.db", "FastDatabase"), "instance")
-        .initializer("null")
-        .addModifiers(Modifier.PRIVATE)
-        .addJavadoc("""
-          Database instance
-        """.trimIndent())
-        .build())
 
     if (TypeConverterAnnotatedProcessor.typeConverter != null) {
       typeSpec.addField(FieldSpec.builder(
@@ -115,7 +100,7 @@ class DatabaseStaticMethodsGenerator(
     typeSpec.addMethod(MethodSpec.methodBuilder("createDatabase")
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
         .addParameter(ClassName.get(String::class.java), "name")
-        .returns(ClassName.get(pack, className))
+        .returns(ClassName.get(pack, classnameImpl))
         .addJavadoc("""
           Creates the simplest database with name specified
           @Param name the name of the database
@@ -132,7 +117,7 @@ class DatabaseStaticMethodsGenerator(
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
         .addParameter(ClassName.get(String::class.java), "name")
         .addParameter(ClassName.get("promise.db", "DatabaseCreationCallback"), "databaseCreationCallback")
-        .returns(ClassName.get(pack, className))
+        .returns(ClassName.get(pack, classnameImpl))
         .addJavadoc("""
           Creates the simplest database with name specified with callback
           Callback can be used to pre populate database with records or
@@ -155,7 +140,7 @@ class DatabaseStaticMethodsGenerator(
     //    }
     typeSpec.addMethod(MethodSpec.methodBuilder("createInMemoryDatabase")
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
-        .returns(ClassName.get(pack, className))
+        .returns(ClassName.get(pack, classnameImpl))
         .addJavadoc("""
           Creates an in memory database, useful for tests
         """.trimIndent())
@@ -169,7 +154,7 @@ class DatabaseStaticMethodsGenerator(
     typeSpec.addMethod(MethodSpec.methodBuilder("createInMemoryDatabase")
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
         .addParameter(ClassName.get("promise.db", "DatabaseCreationCallback"), "databaseCreationCallback")
-        .returns(ClassName.get(pack, className))
+        .returns(ClassName.get(pack, classnameImpl))
         .addJavadoc("""
           Creates an in memory database, useful for tests
           Callback can be used to pre populate database with records or
@@ -191,7 +176,7 @@ class DatabaseStaticMethodsGenerator(
     //    }
     typeSpec.addMethod(MethodSpec.methodBuilder("createReactiveInMemoryDatabase")
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
-        .returns(ClassName.get(pack, className))
+        .returns(ClassName.get(pack, classnameImpl))
         .addJavadoc("""
           Creates an in memory database, enables calling rx DML functions in the tables
         """.trimIndent())
@@ -205,7 +190,7 @@ class DatabaseStaticMethodsGenerator(
     typeSpec.addMethod(MethodSpec.methodBuilder("createReactiveInMemoryDatabase")
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
         .addParameter(ClassName.get("promise.db", "DatabaseCreationCallback"), "databaseCreationCallback")
-        .returns(ClassName.get(pack, className))
+        .returns(ClassName.get(pack, classnameImpl))
         .addJavadoc("""
           Creates an in memory database, enables calling rx DML functions in the tables
           Callback can be used to pre populate database with records or
@@ -229,7 +214,7 @@ class DatabaseStaticMethodsGenerator(
     typeSpec.addMethod(MethodSpec.methodBuilder("createReactiveDatabase")
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
         .addParameter(ClassName.get(String::class.java), "name")
-        .returns(ClassName.get(pack, className))
+        .returns(ClassName.get(pack, classnameImpl))
         .addJavadoc("""
           Creates database, that enables calling rx DML functions in the tables
           @Param name name of the database 
@@ -246,7 +231,7 @@ class DatabaseStaticMethodsGenerator(
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
         .addParameter(ClassName.get(String::class.java), "name")
         .addParameter(ClassName.get("promise.db", "DatabaseCreationCallback"), "databaseCreationCallback")
-        .returns(ClassName.get(pack, className))
+        .returns(ClassName.get(pack, classnameImpl))
         .addJavadoc("""
           Creates database, that enables calling rx DML functions in the tables
           Callback can be used to pre populate database with records or
@@ -260,20 +245,6 @@ class DatabaseStaticMethodsGenerator(
           return new $classnameImpl(FastDatabase.createReactiveDatabase($classnameImpl.class, name, getMigration(), databaseCreationCallback));
         """.trimIndent()))
         .build())
-    //    @JvmStatic
-    //    fun getDatabaseInstance(): FastDatabase {
-    //      if (instance == null) throw IllegalStateException("Database not initialized or created yet")
-    //      return instance!!
-    //    }
-    typeSpec.addMethod(MethodSpec.methodBuilder("getDatabaseInstance")
-        .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
-        .addAnnotation(Override::class.java)
-        .returns(ClassName.get("promise.db", "FastDatabase"))
-        .addCode(CodeBlock.of("""
-          if (instance == null) throw new IllegalStateException("Database not initialized or created yet");
-          return instance;
-        """.trimIndent()))
-        .build())
 
     return "created"
   }
diff --git a/compiler/src/main/java/promise/db/ompiler/EntityAnnotatedProcessor.kt b/compiler/src/main/java/promise/db/ompiler/EntityAnnotatedProcessor.kt
index 7784b3f..147b9bb 100644
--- a/compiler/src/main/java/promise/db/ompiler/EntityAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/db/ompiler/EntityAnnotatedProcessor.kt
@@ -26,15 +26,13 @@ import org.jetbrains.annotations.NotNull
 import promise.db.Entity
 import promise.db.ompiler.utils.JavaUtils
 import promise.db.ompiler.utils.checkIfAnyElementNeedsTypeConverter
-import promise.db.ompiler.utils.getClassName
-import promise.db.ompiler.utils.isElementAnnotatedAsRelation
+import promise.db.ompiler.utils.getTableClassNameString
 import javax.annotation.processing.ProcessingEnvironment
 import javax.annotation.processing.RoundEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.ElementKind
 import javax.lang.model.element.Modifier
 import javax.lang.model.element.TypeElement
-import javax.lang.model.util.ElementFilter
 import javax.tools.Diagnostic
 
 class EntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment) : AnnotatedClassProcessor() {
@@ -51,7 +49,6 @@ class EntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment)
             processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "The Entity class ${element.simpleName} must implement Identifiable")
           } else {
             javaFiles.add(processAnnotation(element))
-            javaFiles.addAll(processElementDaos(element))
           }
           //processAnnotation(element)
         }
@@ -63,7 +60,7 @@ class EntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment)
     val className = element.simpleName.toString()
     val pack = processingEnv.elementUtils.getPackageOf(element).toString()
 
-    val fileName = element.getClassName()
+    val fileName = element.getTableClassNameString()
 
     val tableAnnotationSpec = TableAnnotationGenerator(element, processingEnv).generate()
 
@@ -168,13 +165,4 @@ class EntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment)
     return JavaFile.builder(pack, classBuilder.build())
   }
 
-  private fun processElementDaos(element: Element): List<JavaFile.Builder?> {
-    val javaFiles = ArrayList<JavaFile.Builder?>()
-    val fields = ElementFilter.fieldsIn(element.enclosedElements).filter {
-      it.isElementAnnotatedAsRelation()
-    }
-    if (fields.isNotEmpty()) javaFiles.addAll(TableRelationsGenerator(processingEnv, element as TypeElement, fields).generate())
-
-    return javaFiles
-  }
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt b/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt
index b29fab1..65508ce 100644
--- a/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt
+++ b/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt
@@ -15,8 +15,6 @@ package promise.db.ompiler
 
 import com.google.auto.service.AutoService
 import com.squareup.javapoet.JavaFile
-import net.ltgt.gradle.incap.IncrementalAnnotationProcessor
-import net.ltgt.gradle.incap.IncrementalAnnotationProcessorType
 import promise.db.DatabaseEntity
 import promise.db.Entity
 import promise.db.TypeConverter
@@ -33,7 +31,6 @@ import javax.tools.Diagnostic
 import kotlin.collections.ArrayList
 
 @AutoService(Processor::class) // For registering the service
-@IncrementalAnnotationProcessor(IncrementalAnnotationProcessorType.DYNAMIC)
 @SupportedSourceVersion(SourceVersion.RELEASE_8) // to support Java 8
 @SupportedOptions(PromiseDatabaseCompiler.KAPT_JAVA_GENERATED_OPTION_NAME)
 class PromiseDatabaseCompiler : AbstractProcessor() {
@@ -42,9 +39,9 @@ class PromiseDatabaseCompiler : AbstractProcessor() {
     try {
       val javaFiles: ArrayList<JavaFile.Builder> = ArrayList()
       val processors: ArrayList<AnnotatedClassProcessor> = ArrayList()
-
       processors.add(TypeConverterAnnotatedProcessor(processingEnv))
       processors.add(EntityAnnotatedProcessor(processingEnv))
+      processors.add(RelationsDaoProcessor(processingEnv))
       processors.add(DatabaseEntityAnnotatedProcessor(processingEnv))
 
       processors.forEach {
@@ -79,13 +76,14 @@ class PromiseDatabaseCompiler : AbstractProcessor() {
       }
       return true
     } catch (e: Throwable) {
-      val stringBuilder = StringBuilder()
-      stringBuilder.append(Utils.getStackTraceString(e))
-      stringBuilder.append("\n")
-      stringBuilder.append("Trace: ").append(Arrays.toString(e.stackTrace))
-      processingEnv.messager.printMessage(Diagnostic.Kind.ERROR,
-          "EntityProcessor: $stringBuilder ")
-      // "EntityProcessor Trace: ${Arrays.toString(e.stackTrace)}")
+      e.printStackTrace()
+//      val stringBuilder = StringBuilder()
+//      stringBuilder.append(Utils.getStackTraceString(e))
+//      stringBuilder.append("\n")
+//      stringBuilder.append("Trace: ").append(Arrays.toString(e.stackTrace))
+//      processingEnv.messager.printMessage(Diagnostic.Kind.ERROR,
+//          "EntityProcessor: $stringBuilder ")
+//      // "EntityProcessor Trace: ${Arrays.toString(e.stackTrace)}")
       return false
     }
   }
diff --git a/compiler/src/main/java/promise/db/ompiler/RelationsDaoGenerator.java b/compiler/src/main/java/promise/db/ompiler/RelationsDaoGenerator.java
new file mode 100644
index 0000000..cfdfaba
--- /dev/null
+++ b/compiler/src/main/java/promise/db/ompiler/RelationsDaoGenerator.java
@@ -0,0 +1,575 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db.ompiler;
+
+import com.squareup.javapoet.ArrayTypeName;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterSpec;
+import com.squareup.javapoet.ParameterizedTypeName;
+import com.squareup.javapoet.TypeName;
+import com.squareup.javapoet.TypeSpec;
+import com.squareup.javapoet.WildcardTypeName;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.ElementFilter;
+
+import kotlin.Pair;
+import promise.db.Entity;
+import promise.db.HasMany;
+import promise.db.HasOne;
+import promise.db.ompiler.utils.JavaUtils;
+import promise.db.ompiler.utils.PersistableEntityUtilsKt;
+import promise.db.ompiler.utils.Utils;
+import promise.db.ompiler.utils.UtilsKt;
+
+import static promise.db.ompiler.utils.PersistableEntityUtilsKt.asTableClassName;
+import static promise.db.ompiler.utils.PersistableEntityUtilsKt.camelCase;
+import static promise.db.ompiler.utils.PersistableEntityUtilsKt.capitalizeFirst;
+import static promise.db.ompiler.utils.PersistableEntityUtilsKt.getTableClassNameString;
+import static promise.db.ompiler.utils.PersistableEntityUtilsKt.pluralize;
+
+public class RelationsDaoGenerator implements CodeGenerator<List<JavaFile.Builder>> {
+
+  public static HashMap<ClassName, HashMap<ClassName, Element>> relationsMap = new HashMap<>();
+  private ProcessingEnvironment processingEnvironment;
+  private TypeElement element;
+  private List<VariableElement> relationElements;
+  private TypeSpec.Builder classBuilder;
+  /*
+   * Variable name for element
+   */
+  private String parentElementVarName;
+  /*
+   * pluralized version of parentElementVarName
+   */
+  private String parentElementVarNames;
+  private String getParentElementTableVarName;
+
+  public RelationsDaoGenerator(ProcessingEnvironment processingEnvironment,
+                               TypeElement element,
+                               List<VariableElement> relationElements) {
+    this.processingEnvironment = processingEnvironment;
+    this.element = element;
+    this.relationElements = relationElements;
+    parentElementVarName = camelCase(element.getSimpleName().toString());
+    parentElementVarNames = pluralize(parentElementVarName);
+    getParentElementTableVarName = camelCase(getTableClassNameString(element));
+  }
+
+  @Override
+  public List<JavaFile.Builder> generate() throws Exception {
+    ArrayList<JavaFile.Builder> javaFiles = new ArrayList<>();
+    String className = element.getSimpleName().toString();
+    String pack = processingEnvironment.getElementUtils().getPackageOf(element).toString();
+    String fileName = className + "RelationsDao";
+    classBuilder = TypeSpec.classBuilder(fileName)
+        .addModifiers(Modifier.PUBLIC, Modifier.FINAL);
+    classBuilder.addField(FieldSpec.builder(
+        asTableClassName(element, processingEnvironment),
+        getParentElementTableVarName)
+        .addModifiers(Modifier.PRIVATE)
+        .build());
+    ArrayList<ParameterSpec> constructorParameters = new ArrayList<>();
+    HashMap<ClassName, Element> tableAndRelationElements = new HashMap<>();
+    ClassName parentRelationTableClassName = PersistableEntityUtilsKt.asTableClassName(element, processingEnvironment);
+    constructorParameters.add(ParameterSpec.builder(parentRelationTableClassName, getParentElementTableVarName).build());
+    tableAndRelationElements.put(parentRelationTableClassName, element);
+    relationElements.forEach(relationElement -> {
+      if (relationElement.getAnnotation(HasMany.class) != null) try {
+        Pair<ClassName, Element> pair = generateForHasManyRelation(relationElement, constructorParameters);
+        if (pair != null) tableAndRelationElements.put(pair.getFirst(), pair.getSecond());
+      } catch (Exception e) {
+        e.printStackTrace();
+      }
+      else if (relationElement.getAnnotation(HasOne.class) != null) try {
+        Pair<ClassName, Element> pair = generateForHasOneRelation(relationElement, constructorParameters);
+        if (pair != null) tableAndRelationElements.put(pair.getFirst(), pair.getSecond());
+      } catch (Exception e) {
+        e.printStackTrace();
+      }
+    });
+    CodeBlock.Builder constructorBlock = CodeBlock.builder();
+    constructorParameters.forEach(parameterSpec ->
+        constructorBlock.addStatement("this." + parameterSpec.name + " = " + parameterSpec.name));
+    classBuilder.addMethod(MethodSpec.constructorBuilder()
+        .addModifiers(Modifier.PRIVATE)
+        .addParameters(constructorParameters)
+        .addCode(constructorBlock.build())
+        .build());
+
+    generateRelationsDaoBuilder(constructorParameters, pack, fileName);
+    javaFiles.add(JavaFile.builder(pack, classBuilder.build()));
+    javaFiles.add(Utils.INSTANCE.generateInstanceProviderHolder(ClassName.get(pack, fileName)));
+    relationsMap.put(ClassName.get(pack, fileName), tableAndRelationElements);
+    return javaFiles;
+  }
+
+
+  /**
+   * generates fields and methods for HasMany relation of the given element
+   *
+   * @param hasManyRelationFieldElement element with HasMany relation
+   * @param constructorParameters
+   */
+  private Pair<ClassName, Element> generateForHasManyRelation(Element hasManyRelationFieldElement, ArrayList<ParameterSpec> constructorParameters) throws Exception {
+    if (JavaUtils.isCollectionType(processingEnvironment, (VariableElement) hasManyRelationFieldElement)) {
+      List<? extends TypeMirror> typeMirrors = JavaUtils.getParameterizedTypeMirrors((VariableElement) hasManyRelationFieldElement);
+      if (typeMirrors != null) {
+        /*
+         * Field name for the relation
+         */
+        String hasManyRelationFieldName = hasManyRelationFieldElement.getSimpleName().toString();
+        /*
+         * Element that this element is related to by HasMany relation
+         */
+        TypeElement relationElement = UtilsKt.asTypeElement(typeMirrors.get(0), processingEnvironment);
+        if (relationElement.getAnnotation(Entity.class) == null)
+          throw new Exception("Element related to " + element.getSimpleName() + " as HasMany in " + hasManyRelationFieldElement.getSimpleName() + " field is not marked as an Entity");
+
+        VariableElement relationHasOneRelatedElement = null;
+        for (VariableElement elem : ElementFilter.fieldsIn(relationElement.getEnclosedElements()))
+          if (elem.getAnnotation(HasOne.class) != null && JavaUtils.isTypeEqual(elem.asType(), TypeName.get(element.asType())))
+            relationHasOneRelatedElement = elem;
+        if (relationHasOneRelatedElement == null)
+          throw new Exception(relationElement.getSimpleName() + " is marked as HasMany in  " + hasManyRelationFieldElement.getSimpleName() + " field for " + element.getSimpleName() + " but it is not marked as HasOne relation field in " + element.getSimpleName());
+        /*
+         * Table ClassName for relationElement
+         */
+        ClassName relationElementTableClassName = asTableClassName(relationElement, processingEnvironment);
+        /*
+         * Variable name for relationElementTableClassName
+         */
+        String relationElementTableVarName = camelCase(getTableClassNameString(relationElement));
+        /*
+         * Name of relationElement
+         */
+        String relationElementVarName = relationElement.getSimpleName().toString();
+        /*
+         * name of relation element for collection types
+         */
+        String relationElementVarNames = pluralize(relationElementVarName);
+
+        /*
+         * adding field for Table of child relation element
+         */
+
+        constructorParameters.add(ParameterSpec.builder(relationElementTableClassName, relationElementTableVarName).build());
+        classBuilder.addField(FieldSpec.builder(relationElementTableClassName, relationElementTableVarName)
+            .addModifiers(Modifier.PRIVATE)
+            .build());
+
+        classBuilder.addMethod(MethodSpec.methodBuilder("paginateWith" + capitalizeFirst(hasManyRelationFieldName))
+            .addModifiers(Modifier.PUBLIC)
+            .addParameter(int.class, "skip")
+            .addParameter(int.class, "limit")
+            .returns(ParameterizedTypeName.get(ClassName.get("promise.model", "IdentifiableList"),
+                WildcardTypeName.subtypeOf(
+                    ClassName.get(element.asType())
+                )
+            )).addCode(CodeBlock.builder()
+                .addStatement("IdentifiableList<? extends $T> " + parentElementVarNames + " = " + getParentElementTableVarName + ".find().paginateDescending(skip, limit)", ClassName.get(element.asType()))
+                .beginControlFlow(parentElementVarNames + ".forEach(new $T<$T>()",
+                    ClassName.get("java.util.function", "Consumer"),
+                    ClassName.get(element.asType()))
+                .add("@Override\n")
+                .beginControlFlow("public void accept($T " + parentElementVarName + ")",
+                    ClassName.get(element.asType()))
+                .addStatement(parentElementVarName + ".set" + capitalizeFirst(hasManyRelationFieldName) + "(new $T<>(get" + capitalizeFirst(hasManyRelationFieldName) + "(" + parentElementVarName + ")))",
+                    ClassName.get("promise.model", "IdentifiableList"))
+                .endControlFlow()
+                .endControlFlow(")")
+                .addStatement("return " + parentElementVarNames)
+                .build())
+            .build());
+
+        classBuilder.addMethod(MethodSpec.methodBuilder("listWith" + capitalizeFirst(hasManyRelationFieldName))
+            .addModifiers(Modifier.PUBLIC)
+            .returns(ParameterizedTypeName.get(ClassName.get("promise.model", "IdentifiableList"),
+                WildcardTypeName.subtypeOf(
+                    ClassName.get(element.asType())
+                )
+            )).addCode(CodeBlock.builder()
+                .addStatement("IdentifiableList<? extends $T> " + parentElementVarNames + " = " + getParentElementTableVarName + ".findAll()", ClassName.get(element.asType()))
+                .beginControlFlow(parentElementVarNames + ".forEach(new $T<$T>()",
+                    ClassName.get("java.util.function", "Consumer"),
+                    ClassName.get(element.asType()))
+                .add("@Override\n")
+                .beginControlFlow("public void accept($T " + parentElementVarName + ")",
+                    ClassName.get(element.asType()))
+                .addStatement(parentElementVarName + ".set" + capitalizeFirst(hasManyRelationFieldName) + "(new $T<>(get" + capitalizeFirst(hasManyRelationFieldName) + "(" + parentElementVarName + ")))",
+                    ClassName.get("promise.model", "IdentifiableList"))
+                .endControlFlow()
+                .endControlFlow(")")
+                .addStatement("return " + parentElementVarNames)
+                .build())
+            .build());
+
+        classBuilder.addMethod(MethodSpec.methodBuilder("listWith" + capitalizeFirst(hasManyRelationFieldName))
+            .addParameter(ArrayTypeName.of(
+                ParameterizedTypeName.get(ClassName.get("promise.db", "Column"),
+                    WildcardTypeName.subtypeOf(TypeName.OBJECT))
+            ), "columns")
+            .addModifiers(Modifier.PUBLIC)
+            .returns(ParameterizedTypeName.get(ClassName.get("promise.model", "IdentifiableList"),
+                WildcardTypeName.subtypeOf(
+                    ClassName.get(element.asType())
+                )
+            )).addCode(CodeBlock.builder()
+                .addStatement("IdentifiableList<? extends $T> " + parentElementVarNames + " = " + getParentElementTableVarName + ".findAll(columns)", ClassName.get(element.asType()))
+                .beginControlFlow(parentElementVarNames + ".forEach(new $T<$T>()",
+                    ClassName.get("java.util.function", "Consumer"),
+                    ClassName.get(element.asType()))
+                .add("@Override\n")
+                .beginControlFlow("public void accept($T " + parentElementVarName + ")",
+                    ClassName.get(element.asType()))
+                .addStatement(parentElementVarName + ".set" + capitalizeFirst(hasManyRelationFieldName) + "(new $T<>(get" + capitalizeFirst(hasManyRelationFieldName) + "(" + parentElementVarName + ")))",
+                    ClassName.get("promise.model", "IdentifiableList"))
+                .endControlFlow()
+                .endControlFlow(")")
+                .addStatement("return " + parentElementVarNames)
+                .build())
+            .build());
+
+        classBuilder.addMethod(MethodSpec.methodBuilder("get" + capitalizeFirst(hasManyRelationFieldName))
+            .addParameter(TypeName.get(element.asType()), parentElementVarName)
+            .addModifiers(Modifier.PUBLIC)
+            .returns(ParameterizedTypeName.get(ClassName.get("promise.model", "IdentifiableList"),
+                WildcardTypeName.subtypeOf(
+                    ClassName.get(relationElement.asType())
+                )
+            ))
+            .addCode(CodeBlock.builder()
+                .addStatement("return " + relationElementTableVarName + ".findAll($T." + relationHasOneRelatedElement.getSimpleName() + "Column.with(" + parentElementVarName + ".getId()))", relationElementTableClassName)
+                .build())
+            .build());
+
+        classBuilder.addMethod(MethodSpec.methodBuilder("delete" + capitalizeFirst(hasManyRelationFieldName))
+            .returns(boolean.class)
+            .addModifiers(Modifier.PUBLIC)
+            .addParameter(TypeName.get(element.asType()), parentElementVarName)
+            .addCode(CodeBlock.builder()
+                .addStatement("return " + relationElementTableVarName + ".delete($T." + relationHasOneRelatedElement.getSimpleName() + "Column.with(" + parentElementVarName + ".getId()))", relationElementTableClassName)
+                .build())
+            .build());
+
+        classBuilder.addMethod(MethodSpec.methodBuilder("saveWith" + capitalizeFirst(hasManyRelationFieldName))
+            .addParameter(TypeName.get(element.asType()), parentElementVarName)
+            .addModifiers(Modifier.PUBLIC)
+            .returns(long.class)
+            .addCode(CodeBlock.builder()
+                .addStatement("long id = " + getParentElementTableVarName + ".save(" + parentElementVarName + ")")
+                .beginControlFlow(parentElementVarName + ".get" + capitalizeFirst(hasManyRelationFieldName) + "().forEach(new $T<$T>()",
+                    ClassName.get("java.util.function", "Consumer"),
+                    TypeName.get(relationElement.asType()))
+                .add("@Override\n")
+                .beginControlFlow("public void accept($T " + camelCase(relationElementVarName) + ")", TypeName.get(relationElement.asType()))
+                .addStatement("$T " + parentElementVarName + "1 = new $T()",
+                    TypeName.get(element.asType()),
+                    TypeName.get(element.asType()))
+                .addStatement(parentElementVarName + "1.setId((int) id)")
+                .addStatement(camelCase(relationElementVarName) + ".set" + capitalizeFirst(relationHasOneRelatedElement.getSimpleName().toString()) + "(" + parentElementVarName + "1)")
+                .endControlFlow()
+                .endControlFlow(")")
+                .addStatement(relationElementTableVarName + ".save(new $T<>(" + parentElementVarName + ".get" + capitalizeFirst(hasManyRelationFieldName) + "()))",
+                    ClassName.get("promise.model", "IdentifiableList"))
+                .addStatement("return id")
+                .build())
+            .build());
+
+        classBuilder.addMethod(MethodSpec.methodBuilder("saveWith" + capitalizeFirst(hasManyRelationFieldName))
+            .addParameter(ParameterizedTypeName.get(
+                ClassName.get("java.util", "List"),
+                WildcardTypeName.subtypeOf(TypeName.get(element.asType()))),
+                parentElementVarNames)
+            .addModifiers(Modifier.PUBLIC)
+            .returns(boolean.class)
+            .addCode(CodeBlock.builder()
+                .beginControlFlow(parentElementVarNames + ".forEach(new $T<$T>()",
+                    ClassName.get("java.util.function", "Consumer"),
+                    TypeName.get(element.asType()))
+                .add("@Override\n")
+                .beginControlFlow("public void accept($T " + parentElementVarName + ")", TypeName.get(element.asType()))
+                .addStatement("saveWith" + capitalizeFirst(hasManyRelationFieldName) + "(" + parentElementVarName + ")")
+                .endControlFlow()
+                .endControlFlow(")")
+                .addStatement("return true")
+                .build())
+            .build());
+
+        classBuilder.addMethod(MethodSpec.methodBuilder("updateWith" + capitalizeFirst(hasManyRelationFieldName))
+            .addModifiers(Modifier.PUBLIC)
+            .addParameter(TypeName.get(element.asType()), parentElementVarName)
+            .returns(boolean.class)
+            .addStatement("return (delete" + capitalizeFirst(hasManyRelationFieldName) + "(" + parentElementVarName + ") && saveWith" + capitalizeFirst(hasManyRelationFieldName) + "(" + parentElementVarName + ") > 0)")
+            .build());
+
+        return new Pair<>(relationElementTableClassName, relationElement);
+      }
+    } else
+      throw new Exception(hasManyRelationFieldElement.getSimpleName() + " in " + element.getSimpleName() + " is marked as HasMany but is not a collection type");
+    return null;
+  }
+
+  private Pair<ClassName, Element> generateForHasOneRelation(Element hasOneRelationFieldElement, ArrayList<ParameterSpec> constructorParameters) throws Exception {
+    if (!JavaUtils.isCollectionType(processingEnvironment, (VariableElement) hasOneRelationFieldElement)) {
+      TypeMirror typeMirror = JavaUtils.getTypeMirror((VariableElement) hasOneRelationFieldElement);
+      if (typeMirror != null) {
+        /*
+         * Field name for the relation
+         */
+        String hasOneRelationFieldName = hasOneRelationFieldElement.getSimpleName().toString();
+        /*
+         * Element that this element is related to by HasOne relation
+         */
+        TypeElement relationElement = UtilsKt.asTypeElement(typeMirror, processingEnvironment);
+//        Element bx = processingEnvironment.getTypeUtils().asElement(hasOneRelationFieldElement.asType());
+//        if (!(bx instanceof TypeElement) ||
+//            !(bx instanceof DeclaredType)) {
+//          throw new Exception("Element related to " + element.getSimpleName() + " as HasOne in " + hasOneRelationFieldName+ " field is not a declared type");
+//        }
+//        TypeElement relationElement = (TypeElement) bx;
+
+        if (relationElement.getAnnotation(Entity.class) == null)
+          throw new Exception("Element related to " + element.getSimpleName() + " as HasOne in " + hasOneRelationFieldName + " field is not marked as an Entity");
+        /*
+         * Table ClassName for relationElement
+         */
+        ClassName relationElementTableClassName = asTableClassName(relationElement, processingEnvironment);
+        /*
+         * Variable name for relationElementTableClassName
+         */
+        String relationElementTableVarName = camelCase(getTableClassNameString(relationElement));
+        /*
+         * Name of relationElement
+         */
+        String relationElementVarName = relationElement.getSimpleName().toString();
+        /*
+         * name of relation element for collection types
+         */
+        String relationElementVarNames = pluralize(relationElementVarName);
+
+        /*
+         * adding field for Table of child relation element
+         */
+
+        constructorParameters.add(ParameterSpec.builder(relationElementTableClassName, relationElementTableVarName).build());
+        classBuilder.addField(FieldSpec.builder(relationElementTableClassName, relationElementTableVarName)
+            .addModifiers(Modifier.PRIVATE)
+            .build());
+
+
+        classBuilder.addMethod(MethodSpec.methodBuilder("paginateWith" + relationElementVarNames)
+            .addModifiers(Modifier.PUBLIC)
+            .addParameter(int.class, "skip")
+            .addParameter(int.class, "limit")
+            .returns(ParameterizedTypeName.get(ClassName.get("promise.model", "IdentifiableList"),
+                WildcardTypeName.subtypeOf(
+                    ClassName.get(element.asType())
+                )
+            ))
+            .addCode(CodeBlock.builder()
+                .addStatement("$T " + parentElementVarNames + " = " + getParentElementTableVarName + ".find().paginateDescending(skip, limit)",
+                    ParameterizedTypeName.get(ClassName.get("promise.model", "IdentifiableList"),
+                        WildcardTypeName.subtypeOf(
+                            ClassName.get(element.asType())
+                        )
+                    ))
+                .addStatement("return populateWith" + capitalizeFirst(relationElementVarNames) + "(" + parentElementVarNames + ")")
+                .build())
+            .build());
+
+
+        classBuilder.addMethod(MethodSpec.methodBuilder("listWith" + relationElementVarNames)
+            .addModifiers(Modifier.PUBLIC)
+            .returns(ParameterizedTypeName.get(ClassName.get("promise.model", "IdentifiableList"),
+                WildcardTypeName.subtypeOf(
+                    ClassName.get(element.asType())
+                )
+            ))
+            .addCode(CodeBlock.builder()
+                .addStatement("$T " + parentElementVarNames + " = " + getParentElementTableVarName + ".findAll()",
+                    ParameterizedTypeName.get(ClassName.get("promise.model", "IdentifiableList"),
+                        WildcardTypeName.subtypeOf(
+                            ClassName.get(element.asType())
+                        )
+                    ))
+                .addStatement("return populateWith" + capitalizeFirst(relationElementVarNames) + "(" + parentElementVarNames + ")")
+                .build())
+            .build());
+
+        classBuilder.addMethod(MethodSpec.methodBuilder("listWith" + relationElementVarNames)
+            .addModifiers(Modifier.PUBLIC)
+            .addParameter(ArrayTypeName.of(
+                ParameterizedTypeName.get(ClassName.get("promise.db", "Column"),
+                    WildcardTypeName.subtypeOf(TypeName.OBJECT))
+            ), "columns")
+            .returns(ParameterizedTypeName.get(ClassName.get("promise.model", "IdentifiableList"),
+                WildcardTypeName.subtypeOf(
+                    ClassName.get(element.asType())
+                )
+            ))
+            .addCode(CodeBlock.builder()
+                .addStatement("$T " + parentElementVarNames + " = " + getParentElementTableVarName + ".findAll(columns)",
+                    ParameterizedTypeName.get(ClassName.get("promise.model", "IdentifiableList"),
+                        WildcardTypeName.subtypeOf(
+                            ClassName.get(element.asType())
+                        )
+                    ))
+                .addStatement("return populateWith" + capitalizeFirst(relationElementVarNames) + "(" + parentElementVarNames + ")")
+                .build())
+            .build());
+
+        classBuilder.addMethod(MethodSpec.methodBuilder("populateWith" + relationElementVarNames)
+            .addModifiers(Modifier.PUBLIC)
+            .addParameter(ParameterizedTypeName.get(ClassName.get("promise.model", "IdentifiableList"),
+                WildcardTypeName.subtypeOf(
+                    ClassName.get(element.asType())
+                )
+            ), parentElementVarNames)
+            .returns(ParameterizedTypeName.get(ClassName.get("promise.model", "IdentifiableList"),
+                WildcardTypeName.subtypeOf(
+                    ClassName.get(element.asType())
+                )
+            ))
+            .addCode(CodeBlock.builder()
+                .beginControlFlow(parentElementVarNames + ".forEach(new $T<$T>()",
+                    ClassName.get("java.util.function", "Consumer"),
+                    TypeName.get(element.asType()))
+                .add("@Override\n")
+                .beginControlFlow("public void accept($T " + parentElementVarName + ")",
+                    TypeName.get(element.asType()))
+                .addStatement(parentElementVarName + ".set" + capitalizeFirst(hasOneRelationFieldName) + "(get" + capitalizeFirst(hasOneRelationFieldName) + "(" + parentElementVarName + "))")
+                .endControlFlow()
+                .endControlFlow(")")
+                .addStatement("return " + parentElementVarNames + "")
+                .build())
+            .build());
+
+        classBuilder.addMethod(MethodSpec.methodBuilder("saveWith" + capitalizeFirst(hasOneRelationFieldName))
+            .returns(long.class)
+            .addModifiers(Modifier.PUBLIC)
+            .addParameter(TypeName.get(element.asType()), parentElementVarName)
+            .addCode(CodeBlock.builder()
+                .addStatement("long " + camelCase(relationElementVarName) + "Id = " + relationElementTableVarName + ".save(" + parentElementVarName + ".get" + capitalizeFirst(hasOneRelationFieldName) + "())")
+                .addStatement("$T " + camelCase(relationElementVarName) + " = new $T()", relationElement, relationElement)
+                .addStatement(camelCase(relationElementVarName) + ".setId((int) " + camelCase(relationElementVarName) + "Id)")
+                .addStatement(parentElementVarName + ".set" + capitalizeFirst(hasOneRelationFieldName) + "(" + camelCase(relationElementVarName) + ")")
+                .addStatement("return " + getParentElementTableVarName + ".save(" + parentElementVarName + ")")
+                .build())
+            .build());
+
+
+        classBuilder.addMethod(MethodSpec.methodBuilder("get" + relationElementVarName)
+            .addParameter(TypeName.get(element.asType()), parentElementVarName)
+            .addModifiers(Modifier.PUBLIC)
+            .returns(TypeName.get(relationElement.asType()))
+            .addCode(CodeBlock.builder()
+                .addStatement("return " + relationElementTableVarName + ".findById(" + parentElementVarName + ".get" + capitalizeFirst(hasOneRelationFieldName) + "().getId())")
+                .build())
+            .build());
+
+
+        classBuilder.addMethod(MethodSpec.methodBuilder("saveWith" + relationElementVarNames)
+            .addModifiers(Modifier.PUBLIC)
+            .returns(boolean.class)
+            .addParameter(ParameterizedTypeName.get(ClassName.get("promise.model", "IdentifiableList"),
+                WildcardTypeName.subtypeOf(
+                    ClassName.get(element.asType())
+                )
+            ), parentElementVarNames)
+            .addCode(CodeBlock.builder()
+                .beginControlFlow(parentElementVarNames + ".forEach(new $T<$T>()",
+                    ClassName.get("java.util.function", "Consumer"),
+                    TypeName.get(element.asType()))
+                .add("@Override\n")
+                .beginControlFlow("public void accept($T " + parentElementVarName + ")",
+                    TypeName.get(element.asType()))
+                .addStatement("saveWith"+capitalizeFirst(hasOneRelationFieldName)+"("+parentElementVarName+")")
+                .endControlFlow()
+                .endControlFlow(")")
+                .addStatement("return true")
+                .build())
+            .build());
+
+        classBuilder.addMethod(MethodSpec.methodBuilder("updateWith" + capitalizeFirst(hasOneRelationFieldName))
+            .addModifiers(Modifier.PUBLIC)
+            .addParameter(TypeName.get(element.asType()), parentElementVarName)
+            .addCode(CodeBlock.builder()
+                .addStatement("return "+getParentElementTableVarName+".update("+parentElementVarName+") &&\n" +
+                    " "+relationElementTableVarName+".update("+parentElementVarName+".get"+capitalizeFirst(hasOneRelationFieldName)+"())")
+                .build())
+            .returns(boolean.class)
+            .build());
+
+        return new Pair<>(relationElementTableClassName, relationElement);
+      }
+
+    } else
+      throw new Exception(hasOneRelationFieldElement.getSimpleName() + " in " + element.getSimpleName() + " is marked as HasOne but is a collection type");
+    return null;
+
+  }
+
+  private void generateRelationsDaoBuilder(ArrayList<ParameterSpec> constructorParameters,
+                                           String pack,
+                                           String fileName) {
+
+    TypeSpec.Builder builderClass = TypeSpec.classBuilder("Builder")
+        .addModifiers(Modifier.FINAL, Modifier.STATIC, Modifier.PUBLIC);
+
+    builderClass.addFields(constructorParameters.stream().map(parameterSpec ->
+        FieldSpec.builder(parameterSpec.type, parameterSpec.name)
+            .build()).collect(Collectors.toList()));
+
+    builderClass.addMethods(constructorParameters.stream().map(parameterSpec ->
+        MethodSpec.methodBuilder("set" + capitalizeFirst(parameterSpec.name))
+            .addParameter(parameterSpec)
+            .addModifiers(Modifier.PUBLIC)
+            .addCode(CodeBlock.builder()
+                .addStatement("this." + parameterSpec.name + " = " + parameterSpec.name)
+                .addStatement("return this")
+                .build())
+            .returns(ClassName.get(pack, fileName + ".Builder"))
+            .build()).collect(Collectors.toList()));
+    StringBuilder returnBuilderStatement = new StringBuilder("return new $T(");
+    for (int i = 0; i < constructorParameters.size(); i++) {
+      returnBuilderStatement.append(constructorParameters.get(i).name);
+      if (i != constructorParameters.size() - 1) returnBuilderStatement.append(", ");
+    }
+    returnBuilderStatement.append(")");
+    builderClass.addMethod(MethodSpec.methodBuilder("build")
+        .addModifiers(Modifier.PUBLIC)
+        .returns(ClassName.get(pack, fileName))
+        .addCode(CodeBlock.builder()
+            .addStatement(returnBuilderStatement.toString(), ClassName.get(pack, fileName))
+            .build())
+        .build());
+
+    classBuilder.addType(builderClass.build());
+  }
+}
diff --git a/compiler/src/main/java/promise/db/ompiler/RelationsDaoProcessor.kt b/compiler/src/main/java/promise/db/ompiler/RelationsDaoProcessor.kt
new file mode 100644
index 0000000..b244fc4
--- /dev/null
+++ b/compiler/src/main/java/promise/db/ompiler/RelationsDaoProcessor.kt
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db.ompiler
+
+import com.squareup.javapoet.JavaFile
+import promise.db.Entity
+import promise.db.ompiler.utils.isElementAnnotatedAsRelation
+import javax.annotation.processing.ProcessingEnvironment
+import javax.annotation.processing.RoundEnvironment
+import javax.lang.model.element.Element
+import javax.lang.model.element.TypeElement
+import javax.lang.model.util.ElementFilter
+
+class RelationsDaoProcessor(private val processingEnv: ProcessingEnvironment): AnnotatedClassProcessor() {
+  override fun process(environment: RoundEnvironment?): List<JavaFile.Builder?>? {
+    val javaFiles = ArrayList<JavaFile.Builder?>()
+    environment?.getElementsAnnotatedWith(Entity::class.java)
+        ?.forEach { element ->
+          javaFiles.addAll(processElementDaos(element))
+        }
+    return javaFiles
+  }
+
+  private fun processElementDaos(element: Element): List<JavaFile.Builder?> {
+    val javaFiles = ArrayList<JavaFile.Builder?>()
+    val fields = ElementFilter.fieldsIn(element.enclosedElements).filter {
+      it.isElementAnnotatedAsRelation()
+    }
+    if (fields.isNotEmpty())
+      javaFiles.addAll(RelationsDaoGenerator(processingEnv, element as TypeElement, fields).generate())
+
+    return javaFiles
+  }
+}
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/db/ompiler/TableRelationsGenerator.java b/compiler/src/main/java/promise/db/ompiler/TableRelationsGenerator.java
deleted file mode 100644
index 17ac144..0000000
--- a/compiler/src/main/java/promise/db/ompiler/TableRelationsGenerator.java
+++ /dev/null
@@ -1,311 +0,0 @@
-/*
- * Copyright 2017, Peter Vincent
- * Licensed under the Apache License, Version 2.0, Android Promise.
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package promise.db.ompiler;
-
-import com.squareup.javapoet.ArrayTypeName;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.FieldSpec;
-import com.squareup.javapoet.JavaFile;
-import com.squareup.javapoet.MethodSpec;
-import com.squareup.javapoet.ParameterSpec;
-import com.squareup.javapoet.ParameterizedTypeName;
-import com.squareup.javapoet.TypeName;
-import com.squareup.javapoet.TypeSpec;
-import com.squareup.javapoet.WildcardTypeName;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import javax.annotation.processing.ProcessingEnvironment;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.Modifier;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.element.VariableElement;
-import javax.lang.model.type.TypeMirror;
-import javax.lang.model.util.ElementFilter;
-
-import kotlin.Pair;
-import promise.db.Entity;
-import promise.db.HasMany;
-import promise.db.HasOne;
-import promise.db.ompiler.utils.JavaUtils;
-import promise.db.ompiler.utils.PersistableEntityUtilsKt;
-import promise.db.ompiler.utils.Utils;
-import promise.db.ompiler.utils.UtilsKt;
-
-import static promise.db.ompiler.utils.PersistableEntityUtilsKt.asTableClassName;
-import static promise.db.ompiler.utils.PersistableEntityUtilsKt.camelCase;
-import static promise.db.ompiler.utils.PersistableEntityUtilsKt.capitalizeFirst;
-import static promise.db.ompiler.utils.PersistableEntityUtilsKt.getClassName;
-import static promise.db.ompiler.utils.PersistableEntityUtilsKt.pluralize;
-
-public class TableRelationsGenerator implements CodeGenerator<List<JavaFile.Builder>> {
-
-  private ProcessingEnvironment processingEnvironment;
-  private TypeElement element;
-  private List<VariableElement> relationElements;
-
-  private TypeSpec.Builder classBuilder;
-
-  /*
-   * Variable name for element
-   */
-  private String parentElementVarName;
-  /*
-   * pluralized version of parentElementVarName
-   */
-  private String parentElementVarNames;
-
-  private String getParentElementTableVarName;
-
-  public TableRelationsGenerator(ProcessingEnvironment processingEnvironment,
-                                 TypeElement element,
-                                 List<VariableElement> relationElements) {
-    this.processingEnvironment = processingEnvironment;
-    this.element = element;
-    this.relationElements = relationElements;
-    parentElementVarName = camelCase(element.getSimpleName().toString());
-    parentElementVarNames = pluralize(parentElementVarName);
-    getParentElementTableVarName = camelCase(getClassName(element));
-  }
-
-  @Override
-  public List<JavaFile.Builder> generate() throws Exception {
-    ArrayList<JavaFile.Builder> javaFiles = new ArrayList<>();
-    String className = element.getSimpleName().toString();
-    String pack = processingEnvironment.getElementUtils().getPackageOf(element).toString();
-    String fileName = className + "RelationsDao";
-    classBuilder = TypeSpec.classBuilder(fileName)
-        .addModifiers(Modifier.PUBLIC, Modifier.FINAL);
-    classBuilder.addField(FieldSpec.builder(
-        asTableClassName(element, processingEnvironment),
-        getParentElementTableVarName)
-        .addModifiers(Modifier.PRIVATE)
-        .build());
-    ArrayList<ParameterSpec> constructorParameters = new ArrayList<>();
-    ArrayList<Pair<String, String>> constructorInits = new ArrayList<>();
-    constructorParameters.add(ParameterSpec.builder(PersistableEntityUtilsKt.asTableClassName(element, processingEnvironment), getParentElementTableVarName).build());
-    relationElements.forEach(relationElement -> {
-      if (relationElement.getAnnotation(HasMany.class) != null) {
-        try {
-          Pair<String, String> pair = generateForHasManyRelation(relationElement, constructorParameters);
-          if (pair != null) constructorInits.add(pair);
-        } catch (Exception e) {
-          e.printStackTrace();
-        }
-      }
-      else if (relationElement.getAnnotation(HasOne.class) != null) {
-        generateForHasOneRelation(relationElement);
-      }
-    });
-    CodeBlock.Builder constructorBlock = CodeBlock.builder();
-    constructorBlock.addStatement("this." + getParentElementTableVarName + " = " + getParentElementTableVarName);
-    constructorInits.forEach(stringStringPair ->
-        constructorBlock.addStatement("this." + stringStringPair.getFirst() + " = " + stringStringPair.getSecond()));
-    classBuilder.addMethod(MethodSpec.constructorBuilder()
-        .addModifiers(Modifier.PUBLIC)
-        .addParameters(constructorParameters)
-        .addCode(constructorBlock.build())
-        .build());
-
-    javaFiles.add(JavaFile.builder(pack, classBuilder.build()));
-    javaFiles.add(Utils.INSTANCE.generateInstanceProviderHolder(ClassName.get(pack, fileName)));
-    return javaFiles;
-  }
-
-  /**
-   * generates fields and methods for HasMany relation of the given element
-   *
-   * @param hasManyRelationFieldElement element with HasMany relation
-   * @param constructorParameters
-   */
-  private Pair<String, String> generateForHasManyRelation(Element hasManyRelationFieldElement, ArrayList<ParameterSpec> constructorParameters) throws Exception {
-    if (JavaUtils.isCollectionType(processingEnvironment, (VariableElement) hasManyRelationFieldElement)) {
-      List<? extends TypeMirror> typeMirrors = JavaUtils.getParameterizedTypeMirrors((VariableElement) hasManyRelationFieldElement);
-      if (typeMirrors != null) {
-        /*
-         * Field name for the relation
-         */
-        String hasManyRelationFieldName = hasManyRelationFieldElement.getSimpleName().toString();
-        /*
-         * Element that this element is related to by HasMany relation
-         */
-        TypeElement relationElement = UtilsKt.asTypeElement(typeMirrors.get(0), processingEnvironment);
-        if (relationElement.getAnnotation(Entity.class) == null)
-          throw new Exception("Element related to " + element.getSimpleName() + " as HasMany in " + hasManyRelationFieldElement.getSimpleName() + " field is not marked as an Entity");
-        /*
-         * Table ClassName for relationElement
-         */
-        ClassName relationElementTableClassName = asTableClassName(relationElement, processingEnvironment);
-        /*
-         * Variable name for relationElementTableClassName
-         */
-        String relationElementTableVarName = camelCase(getClassName(relationElement));
-        /*
-         * Name of relationElement
-         */
-        String relationElementVarName = relationElement.getSimpleName().toString();
-        /*
-         * name of relation element for collection types
-         */
-        String relationElementVarNames = pluralize(relationElementVarName);
-
-        /*
-         * adding field for Table of child relation element
-         */
-
-        constructorParameters.add(ParameterSpec.builder(relationElementTableClassName, relationElementTableVarName).build());
-        classBuilder.addField(FieldSpec.builder(relationElementTableClassName, relationElementTableVarName)
-            .addModifiers(Modifier.PRIVATE)
-            .build());
-
-        classBuilder.addMethod(MethodSpec.methodBuilder("listWith" + capitalizeFirst(hasManyRelationFieldName))
-            .addModifiers(Modifier.PUBLIC)
-            .returns(ParameterizedTypeName.get(ClassName.get("promise.model", "IdentifiableList"),
-                WildcardTypeName.subtypeOf(
-                    ClassName.get(element.asType())
-                )
-            )).addCode(CodeBlock.builder()
-                .addStatement("IdentifiableList<? extends $T> " + parentElementVarNames + " = " + getParentElementTableVarName + ".findAll()", ClassName.get(element.asType()))
-                .beginControlFlow(parentElementVarNames + ".forEach(new $T<$T>()",
-                    ClassName.get("java.util.function", "Consumer"),
-                    ClassName.get(element.asType()))
-                .add("@Override\n")
-                .beginControlFlow("public void accept($T " + parentElementVarName + ")",
-                    ClassName.get(element.asType()))
-                .addStatement(parentElementVarName + ".set" + capitalizeFirst(hasManyRelationFieldName) + "(new $T<>(get" + capitalizeFirst(hasManyRelationFieldName) + "(" + parentElementVarName + ")))",
-                    ClassName.get("promise.model", "IdentifiableList"))
-                .endControlFlow()
-                .endControlFlow(")")
-                .addStatement("return " + parentElementVarNames)
-                .build())
-            .build());
-
-        classBuilder.addMethod(MethodSpec.methodBuilder("listWith" + capitalizeFirst(hasManyRelationFieldName))
-            .addParameter(ArrayTypeName.of(
-                ParameterizedTypeName.get(ClassName.get("promise.db", "Column"),
-                    WildcardTypeName.subtypeOf(TypeName.OBJECT))
-            ), "columns")
-            .addModifiers(Modifier.PUBLIC)
-            .returns(ParameterizedTypeName.get(ClassName.get("promise.model", "IdentifiableList"),
-                WildcardTypeName.subtypeOf(
-                    ClassName.get(element.asType())
-                )
-            )).addCode(CodeBlock.builder()
-                .addStatement("IdentifiableList<? extends $T> " + parentElementVarNames + " = " + getParentElementTableVarName + ".findAll(columns)", ClassName.get(element.asType()))
-                .beginControlFlow(parentElementVarNames + ".forEach(new $T<$T>()",
-                    ClassName.get("java.util.function", "Consumer"),
-                    ClassName.get(element.asType()))
-                .add("@Override\n")
-                .beginControlFlow("public void accept($T " + parentElementVarName + ")",
-                    ClassName.get(element.asType()))
-                .addStatement(parentElementVarName + ".set" + capitalizeFirst(hasManyRelationFieldName) + "(new $T<>(get" + capitalizeFirst(hasManyRelationFieldName) + "(" + parentElementVarName + ")))",
-                    ClassName.get("promise.model", "IdentifiableList"))
-                .endControlFlow()
-                .endControlFlow(")")
-                .addStatement("return " + parentElementVarNames)
-                .build())
-            .build());
-
-        VariableElement relationHasOneRelatedElement = null;
-        for (VariableElement elem : ElementFilter.fieldsIn(relationElement.getEnclosedElements()))
-          if (elem.getAnnotation(HasOne.class) != null && JavaUtils.isTypeEqual(elem.asType(), TypeName.get(element.asType())))
-            relationHasOneRelatedElement = elem;
-        if (relationHasOneRelatedElement == null)
-          throw new Exception(relationElement.getSimpleName() + "is marked as HasMany in  " + hasManyRelationFieldElement.getSimpleName() + " for " + element.getSimpleName() + " but it has no as HasOne relation field for " + element.getSimpleName());
-
-        classBuilder.addMethod(MethodSpec.methodBuilder("get" + capitalizeFirst(hasManyRelationFieldName))
-            .addParameter(TypeName.get(element.asType()), parentElementVarName)
-            .addModifiers(Modifier.PUBLIC)
-            .returns(ParameterizedTypeName.get(ClassName.get("promise.model", "IdentifiableList"),
-                WildcardTypeName.subtypeOf(
-                    ClassName.get(relationElement.asType())
-                )
-            ))
-            .addCode(CodeBlock.builder()
-                .addStatement("return " + relationElementTableVarName + ".findAll($T." + relationHasOneRelatedElement.getSimpleName() + "Column.with(" + parentElementVarName + ".getId()))", relationElementTableClassName)
-                .build())
-            .build());
-
-        classBuilder.addMethod(MethodSpec.methodBuilder("delete" + capitalizeFirst(hasManyRelationFieldName))
-            .returns(boolean.class)
-            .addModifiers(Modifier.PUBLIC)
-            .addParameter(TypeName.get(element.asType()), parentElementVarName)
-            .addCode(CodeBlock.builder()
-                .addStatement("return " + relationElementTableVarName + ".delete($T." + relationHasOneRelatedElement.getSimpleName() + "Column.with(" + parentElementVarName + ".getId()))", relationElementTableClassName)
-                .build())
-            .build());
-
-        classBuilder.addMethod(MethodSpec.methodBuilder("saveWith" + capitalizeFirst(hasManyRelationFieldName))
-            .addParameter(TypeName.get(element.asType()), parentElementVarName)
-            .addModifiers(Modifier.PUBLIC)
-            .returns(long.class)
-            .addCode(CodeBlock.builder()
-                .addStatement("long id = " + getParentElementTableVarName + ".save(" + parentElementVarName + ")")
-                .beginControlFlow(parentElementVarName + ".get" + capitalizeFirst(hasManyRelationFieldName) + "().forEach(new $T<$T>()",
-                    ClassName.get("java.util.function", "Consumer"),
-                    TypeName.get(relationElement.asType()))
-                .add("@Override\n")
-                .beginControlFlow("public void accept($T " + camelCase(relationElementVarName) + ")", TypeName.get(relationElement.asType()))
-                .addStatement("$T " + parentElementVarName + "1 = new $T()",
-                    TypeName.get(element.asType()),
-                    TypeName.get(element.asType()))
-                .addStatement(parentElementVarName + "1.setId((int) id)")
-                .addStatement(camelCase(relationElementVarName) + ".set" + capitalizeFirst(relationHasOneRelatedElement.getSimpleName().toString()) + "(" + parentElementVarName + "1)")
-                .endControlFlow()
-                .endControlFlow(")")
-                .addStatement(relationElementTableVarName + ".save(new $T<>(" + parentElementVarName + ".get" + capitalizeFirst(hasManyRelationFieldName) + "()))",
-                    ClassName.get("promise.model", "IdentifiableList"))
-                .addStatement("return id")
-                .build())
-            .build());
-
-        classBuilder.addMethod(MethodSpec.methodBuilder("saveWith" + capitalizeFirst(hasManyRelationFieldName))
-            .addParameter(ParameterizedTypeName.get(
-                ClassName.get("java.util", "List"),
-                WildcardTypeName.subtypeOf(TypeName.get(element.asType()))),
-                parentElementVarNames)
-            .addModifiers(Modifier.PUBLIC)
-            .returns(boolean.class)
-            .addCode(CodeBlock.builder()
-                .beginControlFlow(parentElementVarNames + ".forEach(new $T<$T>()",
-                    ClassName.get("java.util.function", "Consumer"),
-                    TypeName.get(element.asType()))
-                .add("@Override\n")
-                .beginControlFlow("public void accept($T " + parentElementVarName + ")", TypeName.get(element.asType()))
-                .addStatement("saveWith" + capitalizeFirst(hasManyRelationFieldName) + "(" + parentElementVarName + ")")
-                .endControlFlow()
-                .endControlFlow(")")
-                .addStatement("return true")
-                .build())
-            .build());
-
-        classBuilder.addMethod(MethodSpec.methodBuilder("updateWith" + capitalizeFirst(hasManyRelationFieldName))
-            .addModifiers(Modifier.PUBLIC)
-            .addParameter(TypeName.get(element.asType()), parentElementVarName)
-            .returns(boolean.class)
-            .addStatement("return (delete" + capitalizeFirst(hasManyRelationFieldName) + "(" + parentElementVarName + ") && saveWith" + capitalizeFirst(hasManyRelationFieldName) + "(" + parentElementVarName + ") > 0)")
-            .build());
-
-        return new Pair<>(relationElementTableVarName, relationElementTableVarName);
-      }
-    }
-    return null;
-  }
-
-  private void generateForHasOneRelation(Element hasOneRelationFieldElement) {
-
-  }
-}
diff --git a/compiler/src/main/java/promise/db/ompiler/utils/JavaUtils.java b/compiler/src/main/java/promise/db/ompiler/utils/JavaUtils.java
index 5b364bb..a10178a 100644
--- a/compiler/src/main/java/promise/db/ompiler/utils/JavaUtils.java
+++ b/compiler/src/main/java/promise/db/ompiler/utils/JavaUtils.java
@@ -19,8 +19,6 @@
 import com.squareup.javapoet.MethodSpec;
 import com.squareup.javapoet.TypeName;
 
-import org.jetbrains.annotations.Nullable;
-
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
@@ -78,24 +76,63 @@ public static void generateAddConverterStatementInDatabaseConstructorMethod(
         UtilsKt.toTypeName(converter));
   }
 
+  public static void generateAddRelationsDaoStatementInDatabaseConstructorMethod(
+      MethodSpec.Builder constructorMethod,
+      HashMap<ClassName, HashMap<ClassName, Element>> relationsMap) {
+    for (Map.Entry<ClassName, HashMap<ClassName, Element>> relationDao : relationsMap.entrySet()) {
+      CodeBlock.Builder codeBlock = generateGetRelationDaoCodeBlock(relationDao);
+      constructorMethod.addCode(codeBlock.build());
+    }
+  }
+
+  public static CodeBlock.Builder generateGetRelationDaoCodeBlock(Map.Entry<ClassName, HashMap<ClassName, Element>> relationDao) {
+    ClassName providerClassName = ClassName.get(relationDao.getKey().packageName(),
+        UtilsKt.getInstanceProviderClassName(relationDao.getKey().simpleName()));
+    CodeBlock.Builder codeBlock = CodeBlock.builder();
+    codeBlock.add("return $T.provider($T.create(new $T.Builder()\n",
+        ClassName.get("promise.commons", "SingletonInstanceProvider"),
+        providerClassName,
+        relationDao.getKey());
+    for (Map.Entry<ClassName, Element> tableAndEntity: relationDao.getValue().entrySet()) {
+      codeBlock.add(".set"+tableAndEntity.getKey().simpleName()+"(get"+tableAndEntity.getKey().simpleName()+"())\n");
+    }
+    codeBlock.addStatement(".build())).get()");
+    return codeBlock;
+  }
+
   public static void generateIfStatementObtainClassString(
       ProcessingEnvironment processingEnv,
       CodeBlock.Builder codeBlock,
       TypeElement entity) {
     String pack = processingEnv.getElementUtils().getPackageOf(entity).toString();
     if (PersistableEntityUtilsKt.checkIfAnyElementNeedsTypeConverter(entity)) {
-      String tableVarName = PersistableEntityUtilsKt.camelCase(PersistableEntityUtilsKt.getClassName(entity));
+      String tableVarName = PersistableEntityUtilsKt.camelCase(PersistableEntityUtilsKt.getTableClassNameString(entity));
       codeBlock.beginControlFlow("if (entityClass == $T.class)", ClassName.get(pack, entity.getSimpleName().toString()));
       codeBlock.addStatement("$T " + tableVarName + " = getDatabaseInstance().obtain($T.class)",
-          ClassName.get(pack, PersistableEntityUtilsKt.getClassName(entity)),
-          ClassName.get(pack, PersistableEntityUtilsKt.getClassName(entity)));
+          ClassName.get(pack, PersistableEntityUtilsKt.getTableClassNameString(entity)),
+          ClassName.get(pack, PersistableEntityUtilsKt.getTableClassNameString(entity)));
       codeBlock.addStatement(tableVarName + ".setTypeConverter(typeConverter)");
       codeBlock.addStatement("return (FastTable<T>) " + tableVarName);
       codeBlock.endControlFlow();
     } else
       codeBlock.addStatement("if (entityClass == $T.class) return getDatabaseInstance().obtain($T.class)",
           ClassName.get(pack, entity.getSimpleName().toString()),
-          ClassName.get(pack, PersistableEntityUtilsKt.getClassName(entity)));
+          ClassName.get(pack, PersistableEntityUtilsKt.getTableClassNameString(entity)));
+  }
+
+  public static CodeBlock generateGetTableStatement(
+      ProcessingEnvironment processingEnv,
+      TypeElement entity) {
+    String pack = processingEnv.getElementUtils().getPackageOf(entity).toString();
+      return CodeBlock.builder()
+          .addStatement("return ($T) tableOf($T.class)",
+              ClassName.get(pack, PersistableEntityUtilsKt.getTableClassNameString(entity)),
+              TypeName.get(entity.asType()))
+          .build();
+  }
+
+  public static CodeBlock generateGetRelationsDao() {
+    return CodeBlock.builder().build();
   }
 
   public static CodeBlock generateSerializerRelationPutStatement(Element element, String colName) {
@@ -191,4 +228,11 @@ public static List<? extends TypeMirror> getParameterizedTypeMirrors(VariableEle
     }
     return null;
   }
+
+  public static TypeMirror getTypeMirror(VariableElement variableElement) {
+    if (variableElement.asType() instanceof DeclaredType) {
+      return variableElement.asType();
+    }
+    return null;
+  }
 }
diff --git a/compiler/src/main/java/promise/db/ompiler/utils/PersistableEntityUtils.kt b/compiler/src/main/java/promise/db/ompiler/utils/PersistableEntityUtils.kt
index 0a7be40..7aef3cd 100644
--- a/compiler/src/main/java/promise/db/ompiler/utils/PersistableEntityUtils.kt
+++ b/compiler/src/main/java/promise/db/ompiler/utils/PersistableEntityUtils.kt
@@ -39,7 +39,7 @@ import javax.lang.model.util.ElementFilter
  * gets the className for type element
  */
 fun TypeElement.asTableClassName(processingEnv: ProcessingEnvironment): ClassName {
-  val className = this.getClassName()
+  val className = this.getTableClassNameString()
   val pack = processingEnv.elementUtils.getPackageOf(this).toString()
   return ClassName.get(pack, className)
 }
@@ -47,7 +47,7 @@ fun TypeElement.asTableClassName(processingEnv: ProcessingEnvironment): ClassNam
 /**
  * gets the class name for the table class of this element
  */
-fun Element.getClassName(): String = "${this.simpleName.toString().pluralize().capitalizeFirst()}Table"
+fun Element.getTableClassNameString(): String = "${this.simpleName.toString().pluralize().capitalizeFirst()}Table"
 
 //@JvmName("PersistableEntityUtils")
 /**
diff --git a/database/src/main/java/promise/db/PromiseDatabase.java b/database/src/main/java/promise/db/PromiseDatabase.java
index a1e423f..3838762 100644
--- a/database/src/main/java/promise/db/PromiseDatabase.java
+++ b/database/src/main/java/promise/db/PromiseDatabase.java
@@ -18,12 +18,21 @@
 /**
  * Base class for classes annotated with DatabaseEntity
  */
-public interface PromiseDatabase {
+public abstract class PromiseDatabase {
+
+  private FastDatabase fastDatabase;
+
+  public PromiseDatabase(FastDatabase fastDatabase) {
+    this.fastDatabase = fastDatabase;
+  }
 
   /**
    * @return an instance of FastDatabase
    */
-  FastDatabase getDatabaseInstance();
+  public FastDatabase getDatabaseInstance() {
+    if (fastDatabase == null) throw new IllegalStateException("Database not initialized or created yet");
+    return fastDatabase;
+  }
 
   /**
    * returns the table associated with the entity class
@@ -33,7 +42,7 @@ public interface PromiseDatabase {
    * @return FastTable of the entity
    * @throws IllegalArgumentException if entity is not registered with the database
    */
-  <T extends Identifiable<Integer>> FastTable<T> tableOf(Class<? extends T> entityClass) throws IllegalArgumentException;
+  public abstract <T extends Identifiable<Integer>> FastTable<T> tableOf(Class<? extends T> entityClass) throws IllegalArgumentException;
 }
 
 

From db7d20cf9dc8c32bcf8cbff4f5aa6db8560931f7 Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Wed, 5 Aug 2020 23:20:03 +0300
Subject: [PATCH 08/34] fixed logging in compiler

---
 .../db/ompiler/DatabaseAnnotationGenerator.kt |  6 +-
 .../DatabaseCrudStubMethodsGenerator.kt       |  6 +-
 .../DatabaseEntityAnnotatedProcessor.kt       | 57 ++++++-------
 .../ompiler/DatabaseStaticMethodsGenerator.kt | 46 ++--------
 .../db/ompiler/EntityAnnotatedProcessor.kt    | 22 ++---
 .../db/ompiler/PromiseDatabaseCompiler.kt     | 20 ++---
 .../db/ompiler/RelationsDaoGenerator.java     | 18 +---
 .../db/ompiler/TableAnnotationGenerator.java  | 76 +++++------------
 .../db/ompiler/TableColumnFieldsGenerator.kt  | 85 ++++++-------------
 .../TableDeserializerMethodGenerator.kt       | 34 +-------
 .../ompiler/TableMigrationFieldGenerator.kt   | 19 -----
 .../TableRegisteredColumnsMethodGenerator.kt  | 11 +--
 .../ompiler/TableSerializerMethodGenerator.kt |  6 +-
 .../TypeConverterAnnotatedProcessor.kt        |  9 +-
 .../promise/db/ompiler/utils/JavaUtils.java   |  6 +-
 .../promise/db/ompiler/utils/LogUtil.java     | 64 ++++++++++++++
 .../ompiler/utils/PersistableEntityUtils.kt   |  1 -
 .../java/promise/db/ompiler/utils/Utils.kt    |  7 --
 18 files changed, 184 insertions(+), 309 deletions(-)
 create mode 100644 compiler/src/main/java/promise/db/ompiler/utils/LogUtil.java

diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseAnnotationGenerator.kt b/compiler/src/main/java/promise/db/ompiler/DatabaseAnnotationGenerator.kt
index 6aadbda..d880916 100644
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseAnnotationGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/DatabaseAnnotationGenerator.kt
@@ -16,6 +16,7 @@ package promise.db.ompiler
 import com.squareup.javapoet.AnnotationSpec
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
+import promise.db.ompiler.utils.LogUtil
 import promise.db.ompiler.utils.Utils
 import promise.db.ompiler.utils.getTableClassNameString
 import promise.db.ompiler.utils.getDatabaseVersion
@@ -36,13 +37,12 @@ class DatabaseAnnotationGenerator(
       try {
         entities = element.getTableEntities(processingEnv)
       } catch (e: Throwable) {
-        processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "getTableEntities: ${Utils.getStackTraceString(e)}")
+        LogUtil.e(e)
       }
       val version = element.getDatabaseVersion()
       try {
         entities?.forEachIndexed { index, entityClass ->
           val className = entityClass.getTableClassNameString()
-          //fileBuilder.addImport(pack, className)
           stmt += "$className.class"
           if (index != entities.size - 1) {
             stmt += ", \n"
@@ -50,7 +50,7 @@ class DatabaseAnnotationGenerator(
         }
         stmt += "\n}"
       } catch (e: Throwable) {
-        processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "DatabaseAnnotationGenerator: ${Utils.getStackTraceString(e)}")
+        LogUtil.e(e)
       }
       return AnnotationSpec.builder(ClassName.get("promise.db", "Database"))
           .addMember("tables", CodeBlock.of(stmt))
diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseCrudStubMethodsGenerator.kt b/compiler/src/main/java/promise/db/ompiler/DatabaseCrudStubMethodsGenerator.kt
index 0a09e1f..5a32f99 100644
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseCrudStubMethodsGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/DatabaseCrudStubMethodsGenerator.kt
@@ -25,9 +25,9 @@ class DatabaseCrudStubMethodsGenerator(
     private val processingEnv: ProcessingEnvironment) : CodeGenerator<String> {
 
   override fun generate(): String {
-    val pack = processingEnv.elementUtils.getPackageOf(element).toString()
-
-    val entities = (element as TypeElement).getTableEntities(processingEnv)
+//    val pack = processingEnv.elementUtils.getPackageOf(element).toString()
+//
+//    val entities = (element as TypeElement).getTableEntities(processingEnv)
 
     return "created"
   }
diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseEntityAnnotatedProcessor.kt b/compiler/src/main/java/promise/db/ompiler/DatabaseEntityAnnotatedProcessor.kt
index 90498d4..f50dddd 100644
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseEntityAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/db/ompiler/DatabaseEntityAnnotatedProcessor.kt
@@ -19,9 +19,11 @@ import com.squareup.javapoet.MethodSpec
 import com.squareup.javapoet.TypeSpec
 import promise.db.DatabaseEntity
 import promise.db.ompiler.utils.JavaUtils
+import promise.db.ompiler.utils.LogUtil
 import promise.db.ompiler.utils.asTableClassName
 import promise.db.ompiler.utils.getTableClassNameString
 import promise.db.ompiler.utils.getTableEntities
+import java.util.*
 import javax.annotation.processing.ProcessingEnvironment
 import javax.annotation.processing.RoundEnvironment
 import javax.lang.model.element.Element
@@ -33,22 +35,24 @@ import javax.tools.Diagnostic
 class DatabaseEntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment) : AnnotatedClassProcessor() {
 
   override fun process(environment: RoundEnvironment?): List<JavaFile.Builder?>? {
-    return environment?.getElementsAnnotatedWith(DatabaseEntity::class.java)
-        ?.map { element ->
-          if (element.kind != ElementKind.CLASS) {
-            processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "Only classes can be annotated")
-            return null
-          }
-          if (element.kind == ElementKind.CLASS && !(element as TypeElement).modifiers.contains(Modifier.ABSTRACT)) {
-            processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "Database class must be abstract")
-          }
-          val promiseDatabaseType = JavaUtils.getDeclaredType(processingEnv,
-              processingEnv.elementUtils.getTypeElement("promise.db.PromiseDatabase"))
-          if (!JavaUtils.isSubTypeOfDeclaredType(processingEnv, element, promiseDatabaseType)) {
-            processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "Database class must extend from promise.db.PromiseDatabase")
-          }
-          processElement(element)
-        }
+    val databases = environment?.getElementsAnnotatedWith(DatabaseEntity::class.java) ?: emptySet()
+    if (databases.size > 1)
+      LogUtil.e(Exception("There can only be one database in the module"))
+    else if (databases.size == 1) {
+      val element = databases.first()
+      if (element.kind != ElementKind.CLASS) {
+        LogUtil.e(Exception("Only classes can be annotated"), element)
+        return null
+      }
+      if (element.kind == ElementKind.CLASS && !(element as TypeElement).modifiers.contains(Modifier.ABSTRACT))
+        LogUtil.e(Exception("Database class must be abstract"), element)
+      val promiseDatabaseType = JavaUtils.getDeclaredType(processingEnv,
+          processingEnv.elementUtils.getTypeElement("promise.db.PromiseDatabase"))
+      if (!JavaUtils.isSubTypeOfDeclaredType(processingEnv, element, promiseDatabaseType))
+        LogUtil.e(Exception("Database class must extend from promise.db.PromiseDatabase"), element)
+      return Collections.singletonList(processElement(element))
+    }
+    return null
   }
 
   private fun processElement(element: Element): JavaFile.Builder {
@@ -68,22 +72,17 @@ class DatabaseEntityAnnotatedProcessor(private val processingEnv: ProcessingEnvi
             "fastDatabase")
         .addModifiers(Modifier.PRIVATE)
         .addStatement("super(fastDatabase)")
-    if (TypeConverterAnnotatedProcessor.typeConverter != null) {
-      constructorMethod.addJavadoc("""
-        Initializes the TypeConverter as singleton
-      """.trimIndent())
+    if (TypeConverterAnnotatedProcessor.typeConverter != null)
       JavaUtils.generateAddConverterStatementInDatabaseConstructorMethod(processingEnv, constructorMethod, TypeConverterAnnotatedProcessor.typeConverter!!)
-    }
 
-    if (RelationsDaoGenerator.relationsMap.isNotEmpty()) {
+    if (RelationsDaoGenerator.relationsMap.isNotEmpty())
       classBuilder.addMethods(RelationsDaoGenerator.relationsMap.map {
-        MethodSpec.methodBuilder("get"+ it.key.simpleName())
-            .addModifiers(Modifier.PUBLIC)
-            .returns(it.key)
-            .addCode(JavaUtils.generateGetRelationDaoCodeBlock(it).build())
-            .build()
-      })
-    }
+      MethodSpec.methodBuilder("get"+ it.key.simpleName())
+          .addModifiers(Modifier.PUBLIC)
+          .returns(it.key)
+          .addCode(JavaUtils.generateGetRelationDaoCodeBlock(it).build())
+          .build()
+    })
 
     classBuilder.superclass(ClassName.get(pack, className))
         .addAnnotation(databaseAnnotationSpec)
diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseStaticMethodsGenerator.kt b/compiler/src/main/java/promise/db/ompiler/DatabaseStaticMethodsGenerator.kt
index 49fb15e..1c64689 100644
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseStaticMethodsGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/DatabaseStaticMethodsGenerator.kt
@@ -63,23 +63,19 @@ class DatabaseStaticMethodsGenerator(
         .returns(ClassName.get("promise.db", "Migration"))
         .addModifiers(Modifier.PRIVATE, Modifier.STATIC)
         .addCode(migrationCodeBlock.build())
-        .addJavadoc("""
-          Migration callback for adding tables into existing database
-        """.trimIndent())
         .build()
 
     typeSpec.addMethod(migrationPropSpec)
 
-    if (TypeConverterAnnotatedProcessor.typeConverter != null) {
+    if (TypeConverterAnnotatedProcessor.typeConverter != null)
       typeSpec.addField(FieldSpec.builder(
-          TypeConverterAnnotatedProcessor.typeConverter!!.toTypeName(),
-          "typeConverter")
-          .addModifiers(Modifier.PRIVATE)
-          .addJavadoc("""
-            TypeConverter instance
-          """.trimIndent())
-          .build())
-    }
+        TypeConverterAnnotatedProcessor.typeConverter!!.toTypeName(),
+        "typeConverter")
+        .addModifiers(Modifier.PRIVATE)
+        .addJavadoc("""
+          TypeConverter instance
+        """.trimIndent())
+        .build())
 
     typeSpec.addField(FieldSpec.builder(Boolean::class.javaPrimitiveType, "initialized")
         .initializer("false")
@@ -90,13 +86,6 @@ class DatabaseStaticMethodsGenerator(
         .build())
 
 
-    // @JvmStatic
-    //    fun createDatabase(name: String): GeneratedDatabase {
-    //      if (instance != null) throw IllegalStateException("Database already created")
-    //      instance = FastDatabase.createDatabase(GeneratedDatabaseImpl::class.java,
-    //          name, migration)
-    //      return GeneratedDatabaseImpl()
-    //    }
     typeSpec.addMethod(MethodSpec.methodBuilder("createDatabase")
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
         .addParameter(ClassName.get(String::class.java), "name")
@@ -132,12 +121,6 @@ class DatabaseStaticMethodsGenerator(
         """.trimIndent()))
         .build())
 
-    //    @JvmStatic
-    //    fun createInMemoryDatabase(): GeneratedDatabase {
-    //      if (instance != null) throw IllegalStateException("Database already created")
-    //      instance = FastDatabase.createInMemoryDatabase(GeneratedDatabaseImpl::class.java)
-    //      return GeneratedDatabaseImpl()
-    //    }
     typeSpec.addMethod(MethodSpec.methodBuilder("createInMemoryDatabase")
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
         .returns(ClassName.get(pack, classnameImpl))
@@ -168,12 +151,6 @@ class DatabaseStaticMethodsGenerator(
         """.trimIndent()))
         .build())
 
-    //    @JvmStatic
-    //    fun createReactiveInMemoryDatabase(): GeneratedDatabase {
-    //      if (instance != null) throw IllegalStateException("Database already created")
-    //      instance = FastDatabase.createInMemoryReactiveDatabase(GeneratedDatabaseImpl::class.java)
-    //      return GeneratedDatabaseImpl()
-    //    }
     typeSpec.addMethod(MethodSpec.methodBuilder("createReactiveInMemoryDatabase")
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
         .returns(ClassName.get(pack, classnameImpl))
@@ -204,13 +181,6 @@ class DatabaseStaticMethodsGenerator(
         """.trimIndent()))
         .build())
 
-    //    @JvmStatic
-    //    fun createReactiveDatabase(name: String): GeneratedDatabase {
-    //      if (instance != null) throw IllegalStateException("Database already created")
-    //      instance = FastDatabase.createReactiveDatabase(GeneratedDatabaseImpl::class.java,
-    //          name, migration)
-    //      return GeneratedDatabaseImpl()
-    //    }
     typeSpec.addMethod(MethodSpec.methodBuilder("createReactiveDatabase")
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
         .addParameter(ClassName.get(String::class.java), "name")
diff --git a/compiler/src/main/java/promise/db/ompiler/EntityAnnotatedProcessor.kt b/compiler/src/main/java/promise/db/ompiler/EntityAnnotatedProcessor.kt
index 147b9bb..132651c 100644
--- a/compiler/src/main/java/promise/db/ompiler/EntityAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/db/ompiler/EntityAnnotatedProcessor.kt
@@ -25,6 +25,7 @@ import com.squareup.javapoet.TypeSpec
 import org.jetbrains.annotations.NotNull
 import promise.db.Entity
 import promise.db.ompiler.utils.JavaUtils
+import promise.db.ompiler.utils.LogUtil
 import promise.db.ompiler.utils.checkIfAnyElementNeedsTypeConverter
 import promise.db.ompiler.utils.getTableClassNameString
 import javax.annotation.processing.ProcessingEnvironment
@@ -33,24 +34,18 @@ import javax.lang.model.element.Element
 import javax.lang.model.element.ElementKind
 import javax.lang.model.element.Modifier
 import javax.lang.model.element.TypeElement
-import javax.tools.Diagnostic
 
 class EntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment) : AnnotatedClassProcessor() {
   override fun process(environment: RoundEnvironment?): List<JavaFile.Builder?>? {
     val javaFiles = ArrayList<JavaFile.Builder?>()
     environment?.getElementsAnnotatedWith(Entity::class.java)
         ?.forEach { element ->
-          if (element.kind != ElementKind.CLASS) {
-            processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "Only classes can be annotated")
-          }
+          if (element.kind != ElementKind.CLASS) LogUtil.e(Exception("Only classes can be annotated"), element)
           val identifiableInterface = processingEnv.elementUtils.getTypeElement("promise.commons.model.Identifiable")
           val declaredInterface = JavaUtils.toWildCardType(processingEnv, identifiableInterface, 1)
-          if (!JavaUtils.isSubTypeOfDeclaredType(processingEnv, element as TypeElement, declaredInterface)) {
-            processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "The Entity class ${element.simpleName} must implement Identifiable")
-          } else {
-            javaFiles.add(processAnnotation(element))
-          }
-          //processAnnotation(element)
+          if (!JavaUtils.isSubTypeOfDeclaredType(processingEnv, element as TypeElement, declaredInterface))
+            LogUtil.e(Exception("The Entity class ${element.simpleName} must implement Identifiable"), element)
+          else javaFiles.add(processAnnotation(element))
         }
     return javaFiles
   }
@@ -127,9 +122,7 @@ class EntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment)
         .initializer(CodeBlock.of("FastTable.getId()")).build()
 
     classBuilder.addField(idColumnSpec)
-    /**
-     * private static final String TAG = LogUtil.makeTag(PersonFastTable.class);
-     */
+
     val tagSpec = JavaUtils.generateEntityTableLogField(element)
 
     classBuilder.addField(tagSpec)
@@ -149,8 +142,7 @@ class EntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment)
     classBuilder.addMethod(serializerGenerator.generate())
 
     // deserializer generator
-    val deserializerGenerator = TableDeserializerMethodGenerator(processingEnv, pack, className,
-        tableColumnPropsGenerator.genColValues)
+    val deserializerGenerator = TableDeserializerMethodGenerator(pack, className, tableColumnPropsGenerator.genColValues)
     classBuilder.addMethod(deserializerGenerator.generate())
 
     // migrations
diff --git a/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt b/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt
index 65508ce..a86bef8 100644
--- a/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt
+++ b/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt
@@ -18,23 +18,26 @@ import com.squareup.javapoet.JavaFile
 import promise.db.DatabaseEntity
 import promise.db.Entity
 import promise.db.TypeConverter
-import promise.db.ompiler.utils.Utils
-import java.util.*
+import promise.db.ompiler.utils.LogUtil
 import javax.annotation.processing.AbstractProcessor
+import javax.annotation.processing.ProcessingEnvironment
 import javax.annotation.processing.Processor
 import javax.annotation.processing.RoundEnvironment
 import javax.annotation.processing.SupportedOptions
 import javax.annotation.processing.SupportedSourceVersion
 import javax.lang.model.SourceVersion
 import javax.lang.model.element.TypeElement
-import javax.tools.Diagnostic
-import kotlin.collections.ArrayList
 
 @AutoService(Processor::class) // For registering the service
 @SupportedSourceVersion(SourceVersion.RELEASE_8) // to support Java 8
 @SupportedOptions(PromiseDatabaseCompiler.KAPT_JAVA_GENERATED_OPTION_NAME)
 class PromiseDatabaseCompiler : AbstractProcessor() {
 
+  override fun init(processingEnv: ProcessingEnvironment?) {
+    super.init(processingEnv)
+    LogUtil.initLogger(processingEnv)
+  }
+
   override fun process(mutableSet: MutableSet<out TypeElement>?, environment: RoundEnvironment?): Boolean {
     try {
       val javaFiles: ArrayList<JavaFile.Builder> = ArrayList()
@@ -76,14 +79,7 @@ class PromiseDatabaseCompiler : AbstractProcessor() {
       }
       return true
     } catch (e: Throwable) {
-      e.printStackTrace()
-//      val stringBuilder = StringBuilder()
-//      stringBuilder.append(Utils.getStackTraceString(e))
-//      stringBuilder.append("\n")
-//      stringBuilder.append("Trace: ").append(Arrays.toString(e.stackTrace))
-//      processingEnv.messager.printMessage(Diagnostic.Kind.ERROR,
-//          "EntityProcessor: $stringBuilder ")
-//      // "EntityProcessor Trace: ${Arrays.toString(e.stackTrace)}")
+      LogUtil.e(e)
       return false
     }
   }
diff --git a/compiler/src/main/java/promise/db/ompiler/RelationsDaoGenerator.java b/compiler/src/main/java/promise/db/ompiler/RelationsDaoGenerator.java
index cfdfaba..2a22024 100644
--- a/compiler/src/main/java/promise/db/ompiler/RelationsDaoGenerator.java
+++ b/compiler/src/main/java/promise/db/ompiler/RelationsDaoGenerator.java
@@ -43,6 +43,7 @@
 import promise.db.HasMany;
 import promise.db.HasOne;
 import promise.db.ompiler.utils.JavaUtils;
+import promise.db.ompiler.utils.LogUtil;
 import promise.db.ompiler.utils.PersistableEntityUtilsKt;
 import promise.db.ompiler.utils.Utils;
 import promise.db.ompiler.utils.UtilsKt;
@@ -104,13 +105,13 @@ public List<JavaFile.Builder> generate() throws Exception {
         Pair<ClassName, Element> pair = generateForHasManyRelation(relationElement, constructorParameters);
         if (pair != null) tableAndRelationElements.put(pair.getFirst(), pair.getSecond());
       } catch (Exception e) {
-        e.printStackTrace();
+        LogUtil.e(e, relationElement);
       }
       else if (relationElement.getAnnotation(HasOne.class) != null) try {
         Pair<ClassName, Element> pair = generateForHasOneRelation(relationElement, constructorParameters);
         if (pair != null) tableAndRelationElements.put(pair.getFirst(), pair.getSecond());
       } catch (Exception e) {
-        e.printStackTrace();
+        LogUtil.e(e, relationElement);
       }
     });
     CodeBlock.Builder constructorBlock = CodeBlock.builder();
@@ -129,13 +130,6 @@ else if (relationElement.getAnnotation(HasOne.class) != null) try {
     return javaFiles;
   }
 
-
-  /**
-   * generates fields and methods for HasMany relation of the given element
-   *
-   * @param hasManyRelationFieldElement element with HasMany relation
-   * @param constructorParameters
-   */
   private Pair<ClassName, Element> generateForHasManyRelation(Element hasManyRelationFieldElement, ArrayList<ParameterSpec> constructorParameters) throws Exception {
     if (JavaUtils.isCollectionType(processingEnvironment, (VariableElement) hasManyRelationFieldElement)) {
       List<? extends TypeMirror> typeMirrors = JavaUtils.getParameterizedTypeMirrors((VariableElement) hasManyRelationFieldElement);
@@ -347,12 +341,6 @@ private Pair<ClassName, Element> generateForHasOneRelation(Element hasOneRelatio
          * Element that this element is related to by HasOne relation
          */
         TypeElement relationElement = UtilsKt.asTypeElement(typeMirror, processingEnvironment);
-//        Element bx = processingEnvironment.getTypeUtils().asElement(hasOneRelationFieldElement.asType());
-//        if (!(bx instanceof TypeElement) ||
-//            !(bx instanceof DeclaredType)) {
-//          throw new Exception("Element related to " + element.getSimpleName() + " as HasOne in " + hasOneRelationFieldName+ " field is not a declared type");
-//        }
-//        TypeElement relationElement = (TypeElement) bx;
 
         if (relationElement.getAnnotation(Entity.class) == null)
           throw new Exception("Element related to " + element.getSimpleName() + " as HasOne in " + hasOneRelationFieldName + " field is not marked as an Entity");
diff --git a/compiler/src/main/java/promise/db/ompiler/TableAnnotationGenerator.java b/compiler/src/main/java/promise/db/ompiler/TableAnnotationGenerator.java
index 2ae185a..362e44f 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableAnnotationGenerator.java
+++ b/compiler/src/main/java/promise/db/ompiler/TableAnnotationGenerator.java
@@ -17,16 +17,15 @@
 import com.squareup.javapoet.CodeBlock;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Map;
 
 import javax.annotation.processing.ProcessingEnvironment;
 import javax.lang.model.element.Element;
 import javax.lang.model.element.TypeElement;
-import javax.tools.Diagnostic;
 
 import promise.db.Entity;
 import promise.db.Table;
+import promise.db.ompiler.utils.LogUtil;
 import promise.db.ompiler.utils.PersistableEntityUtilsKt;
 
 public class TableAnnotationGenerator implements CodeGenerator<AnnotationSpec> {
@@ -43,65 +42,32 @@ private String getCompoundIndexAnnotation(Entity.CompoundIndex annotation) {
     for (int i = 0; i < annotation.columns().length; i++) {
       String index = annotation.columns()[i];
       stmt.append("@Table.Index(columnName = \"").append(index).append("\")");
-      if (i != annotation.columns().length - 1) {
-        stmt.append(",\n");
-      }
+      if (i != annotation.columns().length - 1) stmt.append(",\n");
     }
-    if (annotation.unique()) {
-      stmt.append("},\n" +
-          "unique = true\n" +
-          ")");
-    } else stmt.append("\n})");
-
+    if (annotation.unique()) stmt.append("},\n" +
+        "unique = true\n" +
+        ")");
+    else stmt.append("\n})");
     return stmt.toString();
   }
 
   @Override
   public AnnotationSpec generate() throws Exception {
-    String gen = "@Table(\n" +
-        "         tableName = \"p\",\n" +
-        "         compoundIndexes = {\n" +
-        "             @Table.CompoundIndex(\n" +
-        "                 indexes = {\n" +
-        "                     @Table.Index(columnName = \"n\"),\n" +
-        "                     @Table.Index(columnName = \"m\")\n" +
-        "                 }, unique = true\n" +
-        "             ),\n" +
-        "             @Table.CompoundIndex(\n" +
-        "                 indexes = {\n" +
-        "                     @Table.Index(columnName = \"a\"),\n" +
-        "                     @Table.Index(columnName = \"m\")\n" +
-        "                 }\n" +
-        "             )\n" +
-        "         },\n" +
-        "         indexes = {\n" +
-        "             @Table.Index(columnName = \"n\")\n" +
-        "         },\n" +
-        "         foreignKeys = {\n" +
-        "             @Table.ForeignKey(columnName = \"m\", referencedColumnName = \"legs\", referencedTableName = \"cats\")\n" +
-        "         }\n" +
-        "     )";
+
     AnnotationSpec.Builder annotationSpec = AnnotationSpec.builder(Table.class);
     Entity.CompoundIndex[] compoundIndices = PersistableEntityUtilsKt.getTableCompoundIndices((TypeElement) element);
-    //System.out.println(compoundIndices.toString());
-    //this.processingEnvironment.getMessager().printMessage(Diagnostic.Kind.ERROR, "CompoundIndices " + Arrays.toString(compoundIndices));
-    StringBuilder stmt = new StringBuilder("{\n");
-    if (compoundIndices.length > 0) {
-      //fileBuilder.addImport("promise.db", "Table")
-      try {
-        for (int index = 0; index < compoundIndices.length; index++) {
-          Entity.CompoundIndex compoundIndex = compoundIndices[index];
-          stmt.append(getCompoundIndexAnnotation(compoundIndex));
-          if (index != compoundIndices.length - 1) {
-            stmt.append(",\n");
-          }
-        }
-        stmt.append("}\n");
 
-        annotationSpec.addMember("compoundIndexes", CodeBlock.of(stmt.toString()));
-      } catch (Throwable e) {
-        this.processingEnvironment.getMessager().printMessage(Diagnostic.Kind.ERROR, "CompoundIndex gen error " + Arrays.toString(e.getStackTrace()));
+    StringBuilder stmt = new StringBuilder("{\n");
+    if (compoundIndices.length > 0) try {
+      for (int index = 0; index < compoundIndices.length; index++) {
+        Entity.CompoundIndex compoundIndex = compoundIndices[index];
+        stmt.append(getCompoundIndexAnnotation(compoundIndex));
+        if (index != compoundIndices.length - 1) stmt.append(",\n");
       }
+      stmt.append("}\n");
+      annotationSpec.addMember("compoundIndexes", CodeBlock.of(stmt.toString()));
+    } catch (Throwable e) {
+      LogUtil.e(e);
     }
     String[] indices = PersistableEntityUtilsKt.getTableIndices((TypeElement) element);
     if (indices != null) {
@@ -109,14 +75,12 @@ public AnnotationSpec generate() throws Exception {
       try {
         for (int i = 0; i < indices.length; i++) {
           stmt2.append("@Table.Index(columnName = \"").append(indices[i]).append("\")\n");
-          if (i != indices.length - 1) {
-            stmt2.append(",\n");
-          }
+          if (i != indices.length - 1) stmt2.append(",\n");
         }
         stmt2.append("}\n");
         annotationSpec.addMember("indices", CodeBlock.of(stmt2.toString()));
       } catch (Throwable e) {
-        this.processingEnvironment.getMessager().printMessage(Diagnostic.Kind.ERROR, "Index gen error " + Arrays.toString(e.getStackTrace()));
+        LogUtil.e(e);
       }
     }
     Map<String, String>[] foreignKeys = PersistableEntityUtilsKt.getTableForeignKeys((TypeElement) element, processingEnvironment);
@@ -139,7 +103,7 @@ public AnnotationSpec generate() throws Exception {
         stmt3.append("}\n");
         annotationSpec.addMember("foreignKeys", CodeBlock.of(stmt3.toString()));
       } catch (Throwable e) {
-        this.processingEnvironment.getMessager().printMessage(Diagnostic.Kind.ERROR, "Index gen error " + Arrays.toString(e.getStackTrace()));
+        LogUtil.e(e);
       }
     }
     annotationSpec.addMember("tableName", "$S", PersistableEntityUtilsKt.getTableName(element));
diff --git a/compiler/src/main/java/promise/db/ompiler/TableColumnFieldsGenerator.kt b/compiler/src/main/java/promise/db/ompiler/TableColumnFieldsGenerator.kt
index c00e73f..d1779b8 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableColumnFieldsGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/TableColumnFieldsGenerator.kt
@@ -22,6 +22,7 @@ import promise.db.HasOne
 import promise.db.Ignore
 import promise.db.PrimaryKey
 import promise.db.PrimaryKeyAutoIncrement
+import promise.db.ompiler.utils.LogUtil
 import promise.db.ompiler.utils.checkIfHasTypeConverter
 import promise.db.ompiler.utils.getNameOfColumn
 import promise.db.ompiler.utils.isElementAnnotatedAsRelation
@@ -32,16 +33,11 @@ import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
 
-/**
- * generates column fields for the entity
- */
 class TableColumnFieldsGenerator(
     private val processingEnvironment: ProcessingEnvironment,
     private val setElements: List<Element>) : CodeGenerator<Map<Pair<Element, String>, FieldSpec>> {
 
-  /**
-   *
-   */
+
   var genColValues: ArrayList<Pair<Pair<String, Element>, String>> = ArrayList()
 
   override fun generate(): Map<Pair<Element, String>, FieldSpec> {
@@ -56,9 +52,6 @@ class TableColumnFieldsGenerator(
       val colVariableName = "${element.simpleName}Column"
       var variableClassType = element.toTypeName()
       if (variableClassType.isPrimitive) variableClassType = variableClassType.box()
-      /**
-       * For fields that need type converter
-       */
       if (!element.isPersistable() && !element.isElementAnnotatedAsRelation()) {
         if (element.checkIfHasTypeConverter()) {
           val parameterizedColumnTypeName = ParameterizedTypeName.get(
@@ -80,9 +73,6 @@ class TableColumnFieldsGenerator(
           genColValues.add(pair)
         }
       }
-      /**
-       * for fields marked as relation, additional column needs to be added
-       */
       else if (element.isElementAnnotatedAsRelation()) {
         val hasOneAnnotation = element.getAnnotation(HasOne::class.java)
         if (hasOneAnnotation != null) {
@@ -106,9 +96,6 @@ class TableColumnFieldsGenerator(
           genColValues.add(pair)
         }
       }
-      /**
-       * for normal persistable fields
-       */
       else if (element.isPersistable()) {
         val spec = processField(element, nameOfColumn, i)
         map[Pair(element, colVariableName)] = spec
@@ -116,13 +103,9 @@ class TableColumnFieldsGenerator(
         genColValues.add(pair)
       }
     }
-
     return map
   }
 
-  /**
-   * generates field for the column type of this particular field
-   */
   private fun processField(element: Element, nameOfColumn: String, i: Int): FieldSpec {
     val colVariableName = "${element.simpleName}Column"
     var variableClassType = element.toTypeName()
@@ -143,9 +126,7 @@ class TableColumnFieldsGenerator(
         .build()
   }
 
-  /**
-   * returns column type initializer for this column type
-   */
+
   private fun getColumnInitializer(element: Element, classTypeName: TypeName): String {
     var str = "Column.Type"
     if (classTypeName.isSameAs(Integer::class.java) ||
@@ -154,77 +135,61 @@ class TableColumnFieldsGenerator(
         classTypeName.isSameAs(Double::class.java) ||
         classTypeName.isSameAs(Boolean::class.java)) {
       str += ".INTEGER"
-      if (element.getAnnotation(PrimaryKey::class.java) != null) {
-        str += ".PRIMARY_KEY()"
-      } else if (element.getAnnotation(promise.db.Number::class.java) != null) {
+      if (element.getAnnotation(PrimaryKey::class.java) != null) str += ".PRIMARY_KEY()"
+      else if (element.getAnnotation(promise.db.Number::class.java) != null) {
         val annotation = element.getAnnotation(promise.db.Number::class.java)
         if (annotation.default != 0) {
           str += ".DEFAULT(${annotation.default})"
         } else {
-          if (annotation.nullable) {
-            str += ".NULLABLE()"
-          } else if (!annotation.nullable) {
-            str += ".NON_NULL()"
-          }
+          if (annotation.nullable) str += ".NULLABLE()"
+          else if (!annotation.nullable) str += ".NON_NULL()"
         }
-      } else {
-        str += ".NULLABLE()"
-      }
+      } else str += ".NULLABLE()"
     } else if (classTypeName.isSameAs(String::class.java)) {
       if (element.getAnnotation(promise.db.VarChar::class.java) != null) {
         str += ".VARCHAR"
         val annotation = element.getAnnotation(promise.db.VarChar::class.java)
-        str += if (annotation.unique && annotation.length != 0) {
+        str += if (annotation.unique && annotation.length != 0)
           ".UNIQUE(${annotation.length})"
-        } else if (annotation.nullable && annotation.length != 0) {
+        else if (annotation.nullable && annotation.length != 0)
           ".NULLABLE(${annotation.length})"
-        } else if (!annotation.nullable && annotation.length != 0) {
+        else if (!annotation.nullable && annotation.length != 0)
           ".NOT_NULL(${annotation.length})"
-        } else {
-          throw IllegalStateException("element ${element.simpleName} is annotated as varchar without length")
-        }
+        else LogUtil.e(IllegalStateException("element ${element.simpleName} is annotated as varchar without length"), element)
       } else {
         if (element.getAnnotation(promise.db.Text::class.java) != null) {
           str += ".TEXT"
           val annotation = element.getAnnotation(promise.db.Text::class.java)
-          str += if (annotation.nullable) {
+          str += if (annotation.nullable)
             ".NULLABLE()"
-          } else if (!annotation.nullable) {
+          else if (!annotation.nullable)
             ".NOT_NULL()"
-          } else {
-            throw IllegalStateException("element ${element.simpleName} is annotated as varchar without length")
-          }
-        } else {
-          str += ".TEXT.NULLABLE()"
-        }
+          else
+            LogUtil.e(IllegalStateException("unknown error in  ${element.simpleName}"), element)
+        } else str += ".TEXT.NULLABLE()"
       }
     } else {
       if (element.getAnnotation(promise.db.VarChar::class.java) != null) {
         str += ".VARCHAR"
         val annotation = element.getAnnotation(promise.db.VarChar::class.java)
-        str += if (annotation.unique && annotation.length != 0) {
+        str += if (annotation.unique && annotation.length != 0)
           ".UNIQUE(${annotation.length})"
-        } else if (annotation.nullable && annotation.length != 0) {
+        else if (annotation.nullable && annotation.length != 0)
           ".NULLABLE(${annotation.length})"
-        } else if (!annotation.nullable && annotation.length != 0) {
+        else if (!annotation.nullable && annotation.length != 0)
           ".NOT_NULL(${annotation.length})"
-        } else {
-          throw IllegalStateException("element ${element.simpleName} is annotated as varchar without length")
-        }
+        else LogUtil.e(IllegalStateException("element ${element.simpleName} is annotated as varchar without length"), element)
       } else {
         if (element.getAnnotation(promise.db.Text::class.java) != null) {
           str += ".TEXT"
           val annotation = element.getAnnotation(promise.db.Text::class.java)
-          str += if (annotation.nullable) {
+          str += if (annotation.nullable)
             ".NULLABLE()"
-          } else if (!annotation.nullable) {
+          else if (!annotation.nullable)
             ".NOT_NULL()"
-          } else {
-            throw IllegalStateException("element ${element.simpleName} is annotated as varchar without length")
-          }
-        } else {
+          else LogUtil.e(IllegalStateException("unknown error in  ${element.simpleName} "), element)
+        } else
           str += ".TEXT.NULLABLE()"
-        }
       }
     }
     return str
diff --git a/compiler/src/main/java/promise/db/ompiler/TableDeserializerMethodGenerator.kt b/compiler/src/main/java/promise/db/ompiler/TableDeserializerMethodGenerator.kt
index e44d23d..ca5806c 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableDeserializerMethodGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/TableDeserializerMethodGenerator.kt
@@ -26,20 +26,14 @@ import promise.db.ompiler.utils.getConverterCompatibleMethod
 import promise.db.ompiler.utils.isElementAnnotatedAsRelation
 import promise.db.ompiler.utils.isSameAs
 import promise.db.ompiler.utils.toTypeName
-import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
 
 class TableDeserializerMethodGenerator(
-    private val processingEnvironment: ProcessingEnvironment,
     private val typeDataTypePack: String,
     private val typeDataType: String,
     private val columns: List<Pair<Pair<String, Element>, String>>) : CodeGenerator<MethodSpec> {
 
-  init {
-    //fileSpec.addImport(ClassName("android.database", "Cursor"))
-  }
-
   override fun generate(): MethodSpec {
     val codeBlock = CodeBlock.builder()
     val varName = typeDataType.camelCase()
@@ -56,8 +50,6 @@ class TableDeserializerMethodGenerator(
     JavaUtils.generateCatchSQliteExceptionBlockForDeserializer(codeBlock, typeDataType)
     codeBlock.endControlFlow()
 
-    //fileSpec.addImport("android.database", "CursorIndexOutOfBoundsException")
-
     return MethodSpec.methodBuilder("deserialize")
         .addParameter(ClassName.get("android.database", "Cursor"), "e")
         .addAnnotation(Override::class.java)
@@ -68,9 +60,6 @@ class TableDeserializerMethodGenerator(
         .build()
   }
 
-  /**
-   * person.setAge(cursor.getInt(ageColumn.getIndex(cursor)));
-   */
   private fun generateSetStatement(
       codeBlock: CodeBlock.Builder,
       objectName: String,
@@ -81,30 +70,15 @@ class TableDeserializerMethodGenerator(
       codeBlock.addStatement("$objectName.set${varName.capitalizeFirst()}(e.${getCursorReturn(varType.toTypeName())}(${colName}.getIndex(e)) == 1)")
       return
     }
-
-//    processingEnvironment.messager.printMessage(Diagnostic.Kind.ERROR,
-//         "deserializer Checking element:  $varType for typename $varType" )
     if (varType.checkIfHasTypeConverter()) {
-
       val executableFn = varType.getConverterCompatibleMethod(ConverterTypes.DESERIALIZER)
-      if (executableFn != null) {
+      if (executableFn != null)
         codeBlock.addStatement("$objectName.set${varName.capitalizeFirst()}(typeConverter.${executableFn.simpleName}(e.${getCursorReturn(TypeName.get(String::class.java))}(${colName}.getIndex(e))))")
-      }
-    } else if (varType.isElementAnnotatedAsRelation()) {
-      val gen = """
-        int personId = e.getInt(personColumn.getIndex(e));
-      if (personId != 0) {
-        Person person = new Person();
-        person.setId(personId);
-        dog.setPerson(person);
-      }
-      """.trimIndent()
-      codeBlock.add(JavaUtils.generateDeserializerRelationSetStatement(objectName, varType, colName))
-    } else codeBlock.addStatement("$objectName.set${varName.capitalizeFirst()}(e.${getCursorReturn(varType.toTypeName())}(${colName}.getIndex(e)))")
-    //throw Exception("Could not generate deserializer method for entity")
+    } else if (varType.isElementAnnotatedAsRelation())
+      codeBlock.add(JavaUtils.generateDeserializerRelationSetStatement(objectName, varType, colName)) else codeBlock.addStatement("$objectName.set${varName.capitalizeFirst()}(e.${getCursorReturn(varType.toTypeName())}(${colName}.getIndex(e)))")
   }
 
-  private fun getCursorReturn(varType: TypeName): String =//processingEnvironment.messager.printMessage(Diagnostic.Kind.ERROR, "type ${varType.toString()}")
+  private fun getCursorReturn(varType: TypeName): String =
       when {
         varType.isSameAs(Integer::class.java) -> "getInt"
         varType.isSameAs(Boolean::class.java) -> "getInt"
diff --git a/compiler/src/main/java/promise/db/ompiler/TableMigrationFieldGenerator.kt b/compiler/src/main/java/promise/db/ompiler/TableMigrationFieldGenerator.kt
index 41ab689..c1b33cc 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableMigrationFieldGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/TableMigrationFieldGenerator.kt
@@ -27,25 +27,7 @@ import javax.lang.model.element.Modifier
 
 class TableMigrationFieldGenerator(
     private val elements: Map<Element, String>) : CodeGenerator<MethodSpec?> {
-  init {
-    //fileSpec.addImport("android.content", "ContentValues")
-  }
 
-  /**
-   * @Override
-  public void onUpgrade(@NotNull SQLiteDatabase x, int v1, int v2) throws TableError {
-  super.onUpgrade(x, v1, v2);
-  if (v1 == 3 && v2 == 4) {
-  dropColumns(x, ageColumn);
-  }
-  if (v1 == 4 && v2 == 5) {
-  addColumns(x, marksColumn);
-  }
-  if (v1 == 7 && v2 == 8) {
-  dropColumns(x, marksColumn);
-  }
-  }
-   */
   private fun buildIndexMigration(
       codeBlock: CodeBlock.Builder,
       column: String,
@@ -85,7 +67,6 @@ class TableMigrationFieldGenerator(
     }
     if (migrateFields.isEmpty()) return null
     val codeBlock = CodeBlock.builder()
-
     migrateFields.forEach {
       val migration = it.key.getAnnotation(Migrate::class.java)
       if (migration != null) {
diff --git a/compiler/src/main/java/promise/db/ompiler/TableRegisteredColumnsMethodGenerator.kt b/compiler/src/main/java/promise/db/ompiler/TableRegisteredColumnsMethodGenerator.kt
index 71217d1..e580ab6 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableRegisteredColumnsMethodGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/TableRegisteredColumnsMethodGenerator.kt
@@ -22,21 +22,13 @@ import com.squareup.javapoet.WildcardTypeName
 import org.jetbrains.annotations.NotNull
 import javax.lang.model.element.Modifier
 
-
 class TableRegisteredColumnsMethodGenerator(
     private val columns: List<String>) : CodeGenerator<MethodSpec> {
-  init {
-    //fileSpec.addImport("promise.commons.model", "List")
-  }
-
   override fun generate(): MethodSpec {
-
     var stmt = "return List.fromArray("
     columns.forEachIndexed { index, s ->
       stmt += s
-      if (index != columns.size - 1) {
-        stmt += ", "
-      }
+      if (index != columns.size - 1) stmt += ", "
     }
     stmt += ");"
     return MethodSpec.methodBuilder("getColumns")
@@ -57,6 +49,5 @@ class TableRegisteredColumnsMethodGenerator(
         """.trimIndent())
         .addCode(CodeBlock.of(stmt))
         .build()
-
   }
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/db/ompiler/TableSerializerMethodGenerator.kt b/compiler/src/main/java/promise/db/ompiler/TableSerializerMethodGenerator.kt
index b15f244..19bfcb6 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableSerializerMethodGenerator.kt
+++ b/compiler/src/main/java/promise/db/ompiler/TableSerializerMethodGenerator.kt
@@ -27,7 +27,6 @@ import promise.db.ompiler.utils.toTypeName
 import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
 
-
 class TableSerializerMethodGenerator(
     private val typeDataTypePack: String,
     private val typeDataType: String,
@@ -65,8 +64,7 @@ class TableSerializerMethodGenerator(
       val executableFn = varTypeName.getConverterCompatibleMethod(ConverterTypes.SERIALIZER)
       if (executableFn != null)
         codeBlock.addStatement("values.put(${columnName}.getName(), typeConverter.${executableFn.simpleName}(t.get${typeVariable.capitalizeFirst()}()))")
-    } else if (varTypeName.isElementAnnotatedAsRelation()) {
-      codeBlock.add(JavaUtils.generateSerializerRelationPutStatement(varTypeName, columnName))
-    } else codeBlock.addStatement("values.put(${columnName}.getName(), t.get${typeVariable.capitalizeFirst()}())")
+    } else if (varTypeName.isElementAnnotatedAsRelation())
+      codeBlock.add(JavaUtils.generateSerializerRelationPutStatement(varTypeName, columnName)) else codeBlock.addStatement("values.put(${columnName}.getName(), t.get${typeVariable.capitalizeFirst()}())")
   }
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/db/ompiler/TypeConverterAnnotatedProcessor.kt b/compiler/src/main/java/promise/db/ompiler/TypeConverterAnnotatedProcessor.kt
index 0e04252..3d7a7d4 100644
--- a/compiler/src/main/java/promise/db/ompiler/TypeConverterAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/db/ompiler/TypeConverterAnnotatedProcessor.kt
@@ -16,6 +16,7 @@ package promise.db.ompiler
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.JavaFile
 import promise.db.TypeConverter
+import promise.db.ompiler.utils.LogUtil
 import promise.db.ompiler.utils.Utils
 import java.util.*
 import javax.annotation.processing.ProcessingEnvironment
@@ -28,11 +29,13 @@ class TypeConverterAnnotatedProcessor(private val processingEnv: ProcessingEnvir
   override fun process(environment: RoundEnvironment?): List<JavaFile.Builder?>? {
     val typeConverters = environment?.getElementsAnnotatedWith(TypeConverter::class.java)
     if (typeConverters != null) {
-      if (typeConverters.size > 1) processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "There can only be one typeConverter in the module")
-      else try {
-        typeConverter = typeConverters.firstOrNull() as TypeElement
+      if (typeConverters.size > 1)
+       LogUtil.e(Exception("There can only be one typeConverter in the module"))
+      else if (typeConverters.size == 1) try {
+        typeConverter = typeConverters.first() as TypeElement
         return Collections.singletonList(processElement(typeConverter!!))
       } catch (e: Throwable) {
+        LogUtil.e(e, typeConverter)
       }
     }
     return null
diff --git a/compiler/src/main/java/promise/db/ompiler/utils/JavaUtils.java b/compiler/src/main/java/promise/db/ompiler/utils/JavaUtils.java
index a10178a..0793647 100644
--- a/compiler/src/main/java/promise/db/ompiler/utils/JavaUtils.java
+++ b/compiler/src/main/java/promise/db/ompiler/utils/JavaUtils.java
@@ -131,10 +131,6 @@ public static CodeBlock generateGetTableStatement(
           .build();
   }
 
-  public static CodeBlock generateGetRelationsDao() {
-    return CodeBlock.builder().build();
-  }
-
   public static CodeBlock generateSerializerRelationPutStatement(Element element, String colName) {
     CodeBlock.Builder codeBlock = CodeBlock.builder();
     String variableName = PersistableEntityUtilsKt.camelCase(element.getSimpleName().toString());
@@ -235,4 +231,6 @@ public static TypeMirror getTypeMirror(VariableElement variableElement) {
     }
     return null;
   }
+
+
 }
diff --git a/compiler/src/main/java/promise/db/ompiler/utils/LogUtil.java b/compiler/src/main/java/promise/db/ompiler/utils/LogUtil.java
new file mode 100644
index 0000000..e4112cb
--- /dev/null
+++ b/compiler/src/main/java/promise/db/ompiler/utils/LogUtil.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db.ompiler.utils;
+
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.Element;
+import javax.tools.Diagnostic;
+
+public class LogUtil {
+
+  private static ProcessingEnvironment processingEnv;
+
+  private static final String TAG = "PromiseDatabaseCompiler: ";
+
+  public static void initLogger(ProcessingEnvironment processingEnvironment) {
+    LogUtil.processingEnv = processingEnvironment;
+  }
+
+  private LogUtil() {
+    //no instance
+  }
+
+  public static void w( Object... messages) {
+    StringBuilder builder = new StringBuilder();
+    builder.append(TAG);
+    for (Object message: messages) {
+      builder.append(message.toString());
+    }
+    processingEnv.getMessager().printMessage(Diagnostic.Kind.WARNING, builder.toString());
+  }
+
+  public static void n(Object... messages) {
+    StringBuilder builder = new StringBuilder();
+
+    builder.append(TAG);
+    for (Object message: messages) {
+      builder.append(message.toString());
+    }
+    processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, builder.toString());
+  }
+
+  public static void e(Throwable t) {
+    processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR,
+        TAG + Utils.INSTANCE.getStackTraceString(t));
+  }
+
+  public static void e(Throwable t, Element element) {
+    processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR,
+        TAG + Utils.INSTANCE.getStackTraceString(t), element);
+  }
+
+}
+
diff --git a/compiler/src/main/java/promise/db/ompiler/utils/PersistableEntityUtils.kt b/compiler/src/main/java/promise/db/ompiler/utils/PersistableEntityUtils.kt
index 7aef3cd..812c4b3 100644
--- a/compiler/src/main/java/promise/db/ompiler/utils/PersistableEntityUtils.kt
+++ b/compiler/src/main/java/promise/db/ompiler/utils/PersistableEntityUtils.kt
@@ -200,7 +200,6 @@ fun Element.getConverterCompatibleMethod(converterTypes: ConverterTypes): Execut
 
 
 fun Element.isElementAnnotatedAsRelation(): Boolean {
-
   return this.getAnnotation(HasMany::class.java) != null ||
       this.getAnnotation(HasOne::class.java) != null
 }
diff --git a/compiler/src/main/java/promise/db/ompiler/utils/Utils.kt b/compiler/src/main/java/promise/db/ompiler/utils/Utils.kt
index 5275f75..833b293 100644
--- a/compiler/src/main/java/promise/db/ompiler/utils/Utils.kt
+++ b/compiler/src/main/java/promise/db/ompiler/utils/Utils.kt
@@ -46,17 +46,10 @@ fun TypeName.isSameAs(javaClass: Class<*>): Boolean {
   return this.toString() == JavaUtils.wrap(javaClass).name
 }
 
-fun TypeName.isSameAs2(processingEnvironment: ProcessingEnvironment, javaClass: Class<*>): Boolean {
-  processingEnvironment.messager.printMessage(Diagnostic.Kind.OTHER, "comparing \n: elem typeName ${this}, javaClass: ${JavaUtils.wrap(javaClass).name}")
-  if (this.isPrimitive) return this.box().toString() == JavaUtils.wrap(javaClass).name
-  return this.toString() == JavaUtils.wrap(javaClass).name
-}
-
 fun Element.toTypeName(): TypeName {
   return TypeName.get(this.asType())
 }
 
-
 fun VariableElement.getClass(): KClass<*> {
   val type = this.asType()
   return when (type.kind) {

From cce3728613b3640e5a21cd305e1b70652349afee Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Thu, 6 Aug 2020 00:55:52 +0300
Subject: [PATCH 09/34] updated readme

---
 README.md | 485 ++++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 360 insertions(+), 125 deletions(-)

diff --git a/README.md b/README.md
index b7968b1..e059b8e 100644
--- a/README.md
+++ b/README.md
@@ -1,141 +1,380 @@
 # Android Promise Database [![](https://jitpack.io/v/android-promise/database.svg)](https://jitpack.io/#android-promise/database)
  Manage SqLite databases in android with ease
 
+# Table of Contents
+
+**[Sample Application](##SampleApplication)**<br>
+***[Entity Classes](***EntityClasses)***<br>
+***[Database Class](###DatabaseClass)***<br>
+***[TypeConverter Class](###DatabaseClass)***<br>
+***[Entity Relations](###EntityRelations)***<br>
+***[Database Initialization](###DatabaseInitialization)***<br>
+***[Migrations](###Migrations)***<br>
+**[Setup](##Setup)**<br>
+**[Initialization](##Initialization)**<br>
+**[Next Steps, Credits, Feedback, License](#next-steps)**<br>
+
+## Sample Application
+### Entity Classes
+Pojo classes to be persisted are annotated with @Entity
+The classes can either implement Identifiable<Integer> or extend from ActiveRecord
+This classes must hava a no args constructor or no constructors at all
 
-## Making your Record Class
-Annotate the entity class with Entity, the class can either implement Identifiable<Integer> or extend from ActiveRecord and override parcelable functionality.
-A sample:
-### Person Class
 > Optionally add the table name in the annotation
 
-```java
+#### Photo Class
+```kotlin
 
+@SuppressLint("ParcelCreator")
 @Entity
-public class Person extends ActiveRecord<Person> {
-  // Indexed column
-  @Index
-  private String name;
-  private int age;
-  private boolean aged;
-  private float height;
-  private double marks;
-  private String email;
-  private String phoneNumber;
-  // denote a person has many dogs
-  @HasMany(entity = Dog.class)
-  private List<Dog> dogs;
-
-  public Person() {
-  }
+class Photo: ActiveRecord<Photo>() {
+	var albumId: Int? = null
+	var title: String? = null
+	var url: String? = null
+	var thumbnailUrl: String? = null
 
-  @NotNull
-  @Override
-  public Person getEntity() {
-    return this;
-  }
+  // denotes a photo has one post
+	@HasOne var post: Post? = null
+
+	override fun getEntity(): Photo {
+		return this
+	}
+
+}
+  
+}
+```
+#### Todo Class
+```java
+
+@SuppressLint("ParcelCreator")
+@Entity
+public class Todo extends ActiveRecord<Todo> {
+	private int uid;
+	private boolean completed;
+	private String title;
+  private int userId;
+  
+  // denotes a todo item has one photo record
+	@HasOne
+  private Photo photo;
   // include parcelable implementation if extending from ActiveRecord
-  // include getters and setters for persistable fields
+  
 }
 ```
-> A MUST include correct getter and setter signatures for Java file or generated code will not compile,
-> if entity is a kt file, DO NOT include any getter and setters, BOOLEAN fields MUST NOT start with `is`
+#### Post Class
+```java
 
-## Making your database
-The database expects a list of entities to be registered with it
-```kotlin
+@SuppressLint("ParcelCreator")
+@Entity
+public class Post extends ActiveRecord<Post> {
+	private ID uId;
+	private String title;
+	private String body;
+	private int userId;
+
+  // denotes a post has many post comments
+	@HasMany
+	private List<PostComment> comments;
+
+  // denotes a post has many photos
+	@HasMany
+	private List<Photo> photos;
+}
+```
+
+> Include correct getter and setter signatures for Java file or generated code will not compile, including fields convertable via type converter and fields marked as relation
+
+> BOOLEAN fields MUST NOT start with `is`
 
+### Database Class
+Database classe is annotated with @DatabaseEntity and contain a list
+of persistable entity classes
+The class must be abstract and extend from PromiseDatabase
+> **There can only be one database class in a module**
+```kotlin
 @DatabaseEntity(
     persistableEntities = [
-      Person::class,
-      Dog::class,
-      Sales::class
+      PostComment::class,
+      Photo::class,
+      Post::class,
+      Todo::class
     ]
 )
-/**
- *
- */
-abstract class AppDatabase : PromiseDatabase {
+abstract class AppDatabase(fastDatabase: FastDatabase)
+  : PromiseDatabase(fastDatabase)
+```
 
+Rebuild your project to generate database implementation
 
-  /**
-   *
+### TypeConverter Class
+A type converter is a utility that helps to convert fields not directly persistable to persistable,
+For instance the Post entity has named uId with a type
+```kotlin
+data class ID(val id: String)
+```
+To make the uId field persistable, we provide a type converter
+```kotlin
+@TypeConverter
+class AppTypeConverter {
+
+  fun toUniqueId(data: String): ID = ID(data)
+
+  fun toString(data: ID?): String = data?.id ?: ""
+
+}
+```
+A type converter must be annotated with @TypeConverter and contain non static methods that converts between the non persistable type to a string and vice verser
+Conversion methods in a type converter should have only one parameter and must return
+` Type converter is not for fields that are relations`
+**There can only be one type converter in one module**
+
+> Without a type converter provision, the compiler will not generate columns for non persistable fields
+
+### Entity Relations
+
+#### HasOne Relation
+Denotes one entity has one other entity, a sample
+```java
+@Entity
+public class Todo extends ActiveRecord<Todo> {
+  // other fields
+	...
+
+  // denotes this todo has one photo
+  @HasOne
+  private Photo photo;
+}
+```
+To utilize the relation, the compiler will generate a class called TodoRelationsDao with convenient methods, a snippet of generated code below
+```java
+
+public final class TodoRelationsDao {
+  private TodoesTable todoesTable;
+
+  private PhotosTable photosTable;
+
+  private TodoRelationsDao(TodoesTable todoesTable, PhotosTable photosTable) {
+    this.todoesTable = todoesTable;
+    this.photosTable = photosTable;
+  }
+
+  public IdentifiableList<? extends Todo> paginateWithPhotos(int skip, int limit) {
+    IdentifiableList<? extends Todo> todoes = todoesTable.find().paginateDescending(skip, limit);
+    return populateWithPhotos(todoes);
+  }
+
+  ...
+  // other convenient methods
+  ...
+  
+  public Photo getPhoto(Todo todo) {
+    return photosTable.findById(todo.getPhoto().getId());
+  }
+
+}
+```
+Instances of RelationDaos are retrieved from the generated database class,
+Sampled from AppDatabaseImpl file
+```java
+public final class AppDatabaseImpl extends AppDatabase {
+  ...
+  public TodoRelationsDao getTodoRelationsDao() {
+    return SingletonInstanceProvider.provider(TodoRelationsDaoInstanceProvider.create(new TodoRelationsDao.Builder()
+    .setTodoesTable(getTodoesTable())
+    .setPhotosTable(getPhotosTable())
+    .build())).get();
+  }
+  ...
+}
+```
+
+#### HasMany Relation
+Denotes one entity has many entities of same type and the other entity has one entity of this type, a sample a post has many post comments and a post comment has one post
+
+Post Entity
+```java
+
+@Entity
+public class Post extends ActiveRecord<Post> {
+  // other fields
+	...
+	@HasMany
+  private List<PostComment> comments;
+}
+
+```
+PostComment Entity
+```java
+@SuppressLint("ParcelCreator")
+@Entity
+public class PostComment extends ActiveRecord<PostComment> {
+  // other fields
+	...
+
+	@HasOne
+  private Post post;
+}
+```
+**Both relations must exist at the same time**
+To utilize the relation, the compiler will generate a class called PostRelationsDao with convenient methods, a snippet of generated code below
+```java
+
+public final class PostRelationsDao {
+  private PostsTable postsTable;
+
+  private PostCommentsTable postCommentsTable;
+
+  private PhotosTable photosTable;
+
+  private PostRelationsDao(PostsTable postsTable, PostCommentsTable postCommentsTable,
+      PhotosTable photosTable) {
+    this.postsTable = postsTable;
+    this.postCommentsTable = postCommentsTable;
+    this.photosTable = photosTable;
+  }
+
+  public IdentifiableList<? extends Post> paginateWithComments(int skip, int limit) {
+    IdentifiableList<? extends Post> posts = postsTable.find().paginateDescending(skip, limit);
+    posts.forEach(new Consumer<Post>() {
+      @Override
+      public void accept(Post post) {
+        post.setComments(new IdentifiableList<>(getComments(post)));
+      }
+    } );
+    return posts;
+  }
+
+  public IdentifiableList<? extends Post> listWithComments() {
+    IdentifiableList<? extends Post> posts = postsTable.findAll();
+    posts.forEach(new Consumer<Post>() {
+      @Override
+      public void accept(Post post) {
+        post.setComments(new IdentifiableList<>(getComments(post)));
+      }
+    } );
+    return posts;
+  }
+}
+```
+Instances of RelationDaos are retrieved from the generated database class,
+Sampled from AppDatabaseImpl file
+```java
+public final class AppDatabaseImpl extends AppDatabase {
+  ...
+  public PostRelationsDao getPostRelationsDao() {
+    return SingletonInstanceProvider.provider(PostRelationsDaoInstanceProvider.create(new PostRelationsDao.Builder()
+    .setPostCommentsTable(getPostCommentsTable())
+    .setPostsTable(getPostsTable())
+    .setPhotosTable(getPhotosTable())
+    .build())).get();
+  }
+  ...
+}
+```
+
+### Database Initialization
+The compiler generates a database class for creating your database implementation and accesing tables
+and relation daos, sampled code from generated database file below
+
+```java
+ /**
+   * Creates the simplest database with name specified
+   * @Param name the name of the database
    */
-  private val personsTable: FastTable<Person> by lazy { tableOf(Person::class.java) }
+  public static AppDatabaseImpl createDatabase(String name) {
+    if (initialized) throw new IllegalStateException("Database already created");
+    initialized = true;
+    return new AppDatabaseImpl(FastDatabase.createDatabase(AppDatabaseImpl.class, name, getMigration()));
+  }
 
   /**
-   *
+   * Creates the simplest database with name specified with callback
+   * Callback can be used to pre populate database with records or
+   * set flags like foreign keys
+   * @Param name the name of the database
+   * @Param databaseCreationCallback callback
    */
-  private val dogsTable: FastTable<Dog> by lazy { tableOf(Dog::class.java) }
+  public static AppDatabaseImpl createDatabase(String name,
+      DatabaseCreationCallback databaseCreationCallback) {
+    if (initialized) throw new IllegalStateException("Database already created");
+    initialized = true;
+    return new AppDatabaseImpl(FastDatabase.createDatabase(AppDatabaseImpl.class, name, getMigration(), databaseCreationCallback));
+  }
 
   /**
-   *
+   * Creates an in memory database, useful for tests
    */
-  fun listAllPersons() = personsTable.findAll()
-
-  fun listAllPersonsWithEmail(): List<Person> {
-    val cursor = personsTable.query(personsTable.queryBuilder().whereAnd(Criteria.notIsNull(PersonsTable.emailColumn)))
-    val persons = ArrayList<Person>()
-    while (cursor.moveToNext()) {
-      persons.add(personsTable.deserialize(cursor))
-    }
-    cursor.close()
-
-    return persons
+  public static AppDatabaseImpl createInMemoryDatabase() {
+    if (initialized) throw new IllegalStateException("Database already created");
+    initialized = true;
+    return new AppDatabaseImpl(FastDatabase.createInMemoryDatabase(AppDatabaseImpl.class));
   }
 
   /**
-   *
+   * Creates an in memory database, useful for tests
+   * Callback can be used to pre populate database with records or
+   * set flags like foreign keys
+   * @Param databaseCreationCallback callback
    */
-  fun listAllDogs() = dogsTable.findAll()
-
-//  /**
-//   *
-//   */
-//  @OneToMany(parent = Person::class, child = Dog::class)
-//  @FindAll
-//  abstract fun getPersonsWithDogs(array: Array<Column<*>>?): List<Person>
-//
-//  /**
-//   *
-//   */
-//  @OneToOne(parent = Dog::class, child = Person::class)
-//  @FindAll
-//  abstract fun getDogsWithPersons(array: Array<Column<*>>?): List<Dog>
+  public static AppDatabaseImpl createInMemoryDatabase(
+      DatabaseCreationCallback databaseCreationCallback) {
+    if (initialized) throw new IllegalStateException("Database already created");
+    initialized = true;
+    return new AppDatabaseImpl(FastDatabase.createInMemoryDatabase(AppDatabaseImpl.class, databaseCreationCallback));
+  }
 
-}
-```
-> Database class MUST be abstract even if it has no abstract methods to override
-> Database class MUST implement PromiseDatabase
+  /**
+   * Creates an in memory database, enables calling rx DML functions in the tables
+   */
+  public static AppDatabaseImpl createReactiveInMemoryDatabase() {
+    if (initialized) throw new IllegalStateException("Database already created");
+    initialized = true;
+    return new AppDatabaseImpl(FastDatabase.createInMemoryReactiveDatabase(AppDatabaseImpl.class));
+  }
 
+  /**
+   * Creates an in memory database, enables calling rx DML functions in the tables
+   * Callback can be used to pre populate database with records or
+   * set flags like foreign keys
+   * @Param databaseCreationCallback callback
+   */
+  public static AppDatabaseImpl createReactiveInMemoryDatabase(
+      DatabaseCreationCallback databaseCreationCallback) {
+    if (initialized) throw new IllegalStateException("Database already created");
+    initialized = true;
+    return new AppDatabaseImpl(FastDatabase.createInMemoryReactiveDatabase(AppDatabaseImpl.class, databaseCreationCallback));
+  }
 
-## Consuming your database
-The compiler generates a database class for creating your database implementation and accesing tables.
-If using Dagger, initialize it from a module
-```kotlin
- ...
- 
-@Module
-object DatabaseDependencies {
-
-  @Provides
-  @Singleton
-  @JvmStatic
-  fun providesAppDatabase(): AppDatabase {
-    return AppDatabase_Impl.createDatabase("name")
+  /**
+   * Creates database, that enables calling rx DML functions in the tables
+   * @Param name name of the database 
+   */
+  public static AppDatabaseImpl createReactiveDatabase(String name) {
+    if (initialized) throw new IllegalStateException("Database already created");
+     initialized = true;
+    return new AppDatabaseImpl(FastDatabase.createReactiveDatabase(AppDatabaseImpl.class, name, getMigration()));
   }
 
-  // tables obtained are Singleton, no need to annotate with Singleton
-  @Provides
-  @JvmStatic
-  fun providesPersonsTable(appDatabase: AppDatabase): PersonsTable {
-    return appDatabase.databaseInstance.obtain<PersonsTable>(PersonsTable::class.java)
+  /**
+   * Creates database, that enables calling rx DML functions in the tables
+   * Callback can be used to pre populate database with records or
+   * set flags like foreign keys
+   * @Param name name of the database 
+   * @Param databaseCreationCallback callback
+   */
+  public static AppDatabaseImpl createReactiveDatabase(String name,
+      DatabaseCreationCallback databaseCreationCallback) {
+    if (initialized) throw new IllegalStateException("Database already created");
+     initialized = true;
+    return new AppDatabaseImpl(FastDatabase.createReactiveDatabase(AppDatabaseImpl.class, name, getMigration(), databaseCreationCallback));
   }
-}
-...
 ```
-> All the crud functionality exist on the table
 
-## Migrations
+
+### Migrations
+
+#### Migrations For Entities
 Adding an entity to be persisted to the database from version 1 to version 2 of the database
 Annotate it with AddedEntity
 ##### Sales Entity
@@ -161,34 +400,28 @@ public class Sales extends ActiveRecord<Sales> {
 }
   // getters and setters and parcelable implementation
 ```
-And then add the new entity to the database 
+And then add the new entity to the database and upgrade database version to 2
 
 ```kotlin
-...
 
 @DatabaseEntity(
-    /**
-     *
-     */
+   
     persistableEntities = [
-      Person::class,
+      /// other entities
       Sales::class
     ],
     version = 2
 )
-/**
- *
- */
-abstract class AppDatabase : PromiseDatabase {
-  ...
-  // 
-  ...
-}
 
-...
+abstract class AppDatabase(fastDatabase: FastDatabase) : PromiseDatabase(fastDatabas) 
 ```
-> Finally upgrade the version of the database to 2
+
 Adding columns to an existing entity, annotate the new field with Migrate, a migration will be generated by the compiler >
+
+#### Migrations For Columns
+Annotate the added field with @Migrate and include fromVersion and toVersion
+If a field is to pass multiple migrations, annotate it with @Migrations and add the migrate annotations in the 
+migrations annotation
 ##### Sales Entity
 ```java
 ...
@@ -199,9 +432,9 @@ Adding columns to an existing entity, annotate the new field with Migrate, a mig
 ```
 
 ## Setup
-##### build.gradle
+##### Project level build.gradle
+Add jitpack repository
 ```
-
 allprojects {
     repositories {
         ...
@@ -209,6 +442,10 @@ allprojects {
     }
 }
 
+```
+##### Module level build.gradle
+Compile with java 8, add rxJava dependency of using rx DML functions in the tables
+```
 android {
     ...
     compileOptions {
@@ -224,8 +461,8 @@ dependencies {
      implementation 'com.github.android-promise:commons:1.1-alpha03'
 }
 ```
-### Initialization
-Initialize Promise in your main application file, entry point
+##### Initialization
+Initialize Promise in your main application class
 
 ##### App.java
 ```java
@@ -233,8 +470,7 @@ public class App extends Application {
   @Override
   public void onCreate() {
     super.onCreate();
-    // 10 is the number of threads allowed to run in the background
-    AndroidPromise.init(this, 10, BuildConfig.DEBUG);
+    AndroidPromise.init(this, BuildConfig.DEBUG);
   }
 
   @Override
@@ -249,19 +485,18 @@ public class App extends Application {
 watch this repo to stay updated 
 
 # Developed By
-* Peter Vincent - <dev4vin@gmail.com>
+* Peter Vincent - [Portfolio](https://dev4vin.github.io/info)
+
 # Donations
 If you'd like to support this library development, you could buy me coffee here:
 * [![Become a Patreon]("https://c6.patreon.com/becomePatronButton.bundle.js")](https://www.patreon.com/bePatron?u=31932751)
 
-Thank you very much in advance!
-
 #### Pull requests / Issues / Improvement requests
 Feel free to contribute and ask!<br/>
 
 # License
 
-    Copyright 2018 Peter Vincent
+    Copyright 2018 Android Promise Database
 
     Licensed under the Apache License, Version 2.0 Android Promise;
     you may not use this file except in compliance with the License.

From 7d3092948da1e65d748ca3d3b3b324f6f2b0d89f Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Thu, 6 Aug 2020 01:10:58 +0300
Subject: [PATCH 10/34] updated readme

---
 README.md                                     | 33 +++----------------
 .../db/ompiler/PromiseDatabaseCompiler.kt     |  2 +-
 2 files changed, 6 insertions(+), 29 deletions(-)

diff --git a/README.md b/README.md
index e059b8e..74dda4b 100644
--- a/README.md
+++ b/README.md
@@ -174,20 +174,8 @@ public final class TodoRelationsDao {
 
 }
 ```
-Instances of RelationDaos are retrieved from the generated database class,
-Sampled from AppDatabaseImpl file
-```java
-public final class AppDatabaseImpl extends AppDatabase {
-  ...
-  public TodoRelationsDao getTodoRelationsDao() {
-    return SingletonInstanceProvider.provider(TodoRelationsDaoInstanceProvider.create(new TodoRelationsDao.Builder()
-    .setTodoesTable(getTodoesTable())
-    .setPhotosTable(getPhotosTable())
-    .build())).get();
-  }
-  ...
-}
-```
+Instances of RelationDaos are retrieved from the generated database class
+
 
 #### HasMany Relation
 Denotes one entity has many entities of same type and the other entity has one entity of this type, a sample a post has many post comments and a post comment has one post
@@ -255,23 +243,12 @@ public final class PostRelationsDao {
     } );
     return posts;
   }
-}
-```
-Instances of RelationDaos are retrieved from the generated database class,
-Sampled from AppDatabaseImpl file
-```java
-public final class AppDatabaseImpl extends AppDatabase {
-  ...
-  public PostRelationsDao getPostRelationsDao() {
-    return SingletonInstanceProvider.provider(PostRelationsDaoInstanceProvider.create(new PostRelationsDao.Builder()
-    .setPostCommentsTable(getPostCommentsTable())
-    .setPostsTable(getPostsTable())
-    .setPhotosTable(getPhotosTable())
-    .build())).get();
-  }
   ...
+  // more convenience methods
 }
 ```
+Instances of RelationDaos are retrieved from the generated database class,
+
 
 ### Database Initialization
 The compiler generates a database class for creating your database implementation and accesing tables
diff --git a/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt b/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt
index a86bef8..3461c8b 100644
--- a/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt
+++ b/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt
@@ -68,7 +68,7 @@ class PromiseDatabaseCompiler : AbstractProcessor() {
                 See the License for the specific language governing permissions and
                 limitations under the License
                 
-                Resource https://github.com/android-promise
+                Resource https://github.com/android-promise/database
                 
                 Generated by Android Promise Database Compiler, do not modify
               

From 3329d9e3a8b486173e023c8e51f9dce646eb92e5 Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Thu, 6 Aug 2020 01:45:34 +0300
Subject: [PATCH 11/34] updated readme

---
 README.md | 37 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 36 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 74dda4b..db1e09e 100644
--- a/README.md
+++ b/README.md
@@ -247,7 +247,42 @@ public final class PostRelationsDao {
   // more convenience methods
 }
 ```
-Instances of RelationDaos are retrieved from the generated database class,
+Instances of RelationDaos are retrieved from the generated database class
+
+Snippet of RelationDao usage in main activity
+```kotlin
+...
+// generate 5 posts and each post 4 comments
+val posts = IdentifiableList(List.generate(5) {
+      Post().apply {
+        uId = ID(it.toString())
+        title = "post".plus(it)
+        body = "body".plus(it)
+        userId = it
+        comments = List.generate(4) {
+          PostComment().apply {
+            name = "nm".repeat(it)
+            uId = ID((it + 1).toString())
+            body = "hbytcvbcrxgfvbtrxt"
+            email = "ejmail;jgfccghcfcvhbhcgvb"
+          }
+        }
+      }
+    })
+
+  // save the posts
+   postRelationsDao.saveWithComments(posts)
+  // reading the posts
+   val posts1 = postRelationsDao.listWithComments()
+  // display the posts
+   complex_values_textview.text = posts1.toString()
+  // delete comments for each post and then delete the post
+   posts1.forEach {
+     postRelationsDao.deleteComments(it)
+     it.delete()
+   }
+ ...
+```
 
 
 ### Database Initialization

From 65218a1703bad5d4a4f5a6d52e75a5144bb576f5 Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Fri, 7 Aug 2020 16:36:37 +0300
Subject: [PATCH 12/34] removed proguard in project

---
 .gitignore                                    |  12 --
 app/.classpath                                |   6 +
 app/.gitignore                                |   1 +
 app/.project                                  |  23 +++
 .../org.eclipse.buildship.core.prefs          |   2 +
 app/build.gradle                              |  77 ++++++++
 app/deps.txt                                  |   6 +
 app/proguard-rules.pro                        |  21 ++
 .../promise/dbapp/ExampleInstrumentedTest.kt  |  35 ++++
 app/src/main/AndroidManifest.xml              |  39 ++++
 app/src/main/java/promise/base/AppDatabase.kt |  33 ++++
 .../java/promise/base/AppTypeConverter.kt     |  25 +++
 app/src/main/java/promise/base/ID.kt          |  19 ++
 .../promise/base/comment/PostComment.java     |  80 ++++++++
 app/src/main/java/promise/base/photo/Photo.kt |  26 +++
 app/src/main/java/promise/base/post/Post.java | 104 ++++++++++
 app/src/main/java/promise/base/todo/Todo.java |  79 ++++++++
 .../promise/dbapp/ActivityBuildersModule.kt   |  23 +++
 app/src/main/java/promise/dbapp/App.kt        |  29 +++
 .../main/java/promise/dbapp/AppComponent.kt   |  40 ++++
 .../promise/dbapp/DatabaseDependencies.kt     |  37 ++++
 .../main/java/promise/dbapp/MainActivity.kt   |  77 ++++++++
 .../java/promise/dbapp/test/TestUtils.java    |  19 ++
 .../drawable-v24/ic_launcher_foreground.xml   |  47 +++++
 .../res/drawable/ic_launcher_background.xml   | 182 ++++++++++++++++++
 app/src/main/res/layout/activity_main.xml     |  45 +++++
 app/src/main/res/layout/complex_layout.xml    |  19 ++
 app/src/main/res/layout/content_main.xml      |  41 ++++
 app/src/main/res/menu/menu_main.xml           |  23 +++
 .../res/mipmap-anydpi-v26/ic_launcher.xml     |  17 ++
 .../mipmap-anydpi-v26/ic_launcher_round.xml   |  17 ++
 app/src/main/res/mipmap-hdpi/ic_launcher.png  | Bin 0 -> 2963 bytes
 .../res/mipmap-hdpi/ic_launcher_round.png     | Bin 0 -> 4905 bytes
 app/src/main/res/mipmap-mdpi/ic_launcher.png  | Bin 0 -> 2060 bytes
 .../res/mipmap-mdpi/ic_launcher_round.png     | Bin 0 -> 2783 bytes
 app/src/main/res/mipmap-xhdpi/ic_launcher.png | Bin 0 -> 4490 bytes
 .../res/mipmap-xhdpi/ic_launcher_round.png    | Bin 0 -> 6895 bytes
 .../main/res/mipmap-xxhdpi/ic_launcher.png    | Bin 0 -> 6387 bytes
 .../res/mipmap-xxhdpi/ic_launcher_round.png   | Bin 0 -> 10413 bytes
 .../main/res/mipmap-xxxhdpi/ic_launcher.png   | Bin 0 -> 9128 bytes
 .../res/mipmap-xxxhdpi/ic_launcher_round.png  | Bin 0 -> 15132 bytes
 app/src/main/res/values/colors.xml            |  18 ++
 app/src/main/res/values/dimens.xml            |  16 ++
 app/src/main/res/values/strings.xml           |  17 ++
 app/src/main/res/values/styles.xml            |  33 ++++
 .../java/promise/dbapp/ExampleUnitTest.kt     |  29 +++
 build.gradle                                  |  17 ++
 checkstyle.xml                                | 139 +++++++++++++
 .../src/main/java/promise/db/AddedEntity.kt   |  19 ++
 .../src/main/java/promise/db/ColumnInfo.kt    |  75 --------
 commons/src/main/java/promise/db/Embedded.kt  |  18 ++
 .../promise/db/{EntityInfo.kt => Entity.kt}   |  51 +----
 .../src/main/java/promise/db/ForeignKey.kt    |  22 +++
 commons/src/main/java/promise/db/HasMany.kt   |  22 +++
 commons/src/main/java/promise/db/HasOne.kt    |  18 ++
 commons/src/main/java/promise/db/Ignore.kt    |  18 ++
 commons/src/main/java/promise/db/Index.kt     |  18 ++
 commons/src/main/java/promise/db/Migrate.kt   |  20 ++
 .../main/java/promise/db/MigrationOptions.kt  |  18 ++
 .../src/main/java/promise/db/Migrations.kt    |  18 ++
 commons/src/main/java/promise/db/Number.kt    |  22 +++
 .../src/main/java/promise/db/PrimaryKey.kt    |  18 ++
 .../promise/db/PrimaryKeyAutoIncrement.kt     |  18 ++
 commons/src/main/java/promise/db/Table.java   |  44 -----
 commons/src/main/java/promise/db/Text.kt      |  21 ++
 .../src/main/java/promise/db/TypeConverter.kt |  21 ++
 commons/src/main/java/promise/db/VarChar.kt   |  22 +++
 compiler/build.gradle                         |   3 -
 .../db/ompiler/PromiseDatabaseCompiler.kt     |   7 +-
 .../promise/db/ompiler/utils/JavaUtils.java   |   1 +
 .../java/promise/db/ompiler/utils/Utils.kt    |   7 +
 database/build.gradle                         |   5 +-
 .../src/main/java/promise/db/ActiveRecord.kt  |  22 +--
 database/src/main/java/promise/db/Column.java |  17 --
 .../src/main/java/promise/db/Corrupt.java     |   7 +-
 database/src/main/java/promise/db/Crud.kt     |  43 -----
 .../src/main/java/promise/db/CrudStore.java   |  36 +---
 .../src/main/java/promise/db/DBError.java     |   4 +-
 .../src/main/java/promise/db/DMLFunctions.kt  | 118 +-----------
 .../promise/db/DatabaseCursorFactory.java     |   4 +-
 .../src/main/java/promise/db/FastDatabase.kt  |  21 +-
 .../main/java/promise/db/FastDatabaseImpl.kt  | 156 +--------------
 .../src/main/java/promise/db/FastTable.kt     |   9 +-
 .../src/main/java/promise/db/ReactiveCrud.kt  |  42 ----
 .../java/promise/db/ReactiveFastDatabase.kt   | 169 +---------------
 database/src/main/java/promise/db/Store.java  |  79 +-------
 database/src/main/java/promise/db/Utils.java  |  35 +---
 .../java/promise}/model/ITimeStamped.java     |   2 +-
 .../java/promise/model/IdentifiableList.java  |  24 +--
 .../main/java/promise/model/TimeStamped.java  |   1 -
 gradle.properties                             |   4 +-
 settings.gradle                               |   4 +-
 92 files changed, 1833 insertions(+), 943 deletions(-)
 create mode 100644 app/.classpath
 create mode 100644 app/.gitignore
 create mode 100644 app/.project
 create mode 100644 app/.settings/org.eclipse.buildship.core.prefs
 create mode 100644 app/build.gradle
 create mode 100644 app/deps.txt
 create mode 100644 app/proguard-rules.pro
 create mode 100644 app/src/androidTest/java/promise/dbapp/ExampleInstrumentedTest.kt
 create mode 100644 app/src/main/AndroidManifest.xml
 create mode 100644 app/src/main/java/promise/base/AppDatabase.kt
 create mode 100644 app/src/main/java/promise/base/AppTypeConverter.kt
 create mode 100644 app/src/main/java/promise/base/ID.kt
 create mode 100644 app/src/main/java/promise/base/comment/PostComment.java
 create mode 100644 app/src/main/java/promise/base/photo/Photo.kt
 create mode 100644 app/src/main/java/promise/base/post/Post.java
 create mode 100644 app/src/main/java/promise/base/todo/Todo.java
 create mode 100644 app/src/main/java/promise/dbapp/ActivityBuildersModule.kt
 create mode 100644 app/src/main/java/promise/dbapp/App.kt
 create mode 100644 app/src/main/java/promise/dbapp/AppComponent.kt
 create mode 100644 app/src/main/java/promise/dbapp/DatabaseDependencies.kt
 create mode 100644 app/src/main/java/promise/dbapp/MainActivity.kt
 create mode 100644 app/src/main/java/promise/dbapp/test/TestUtils.java
 create mode 100644 app/src/main/res/drawable-v24/ic_launcher_foreground.xml
 create mode 100644 app/src/main/res/drawable/ic_launcher_background.xml
 create mode 100644 app/src/main/res/layout/activity_main.xml
 create mode 100644 app/src/main/res/layout/complex_layout.xml
 create mode 100644 app/src/main/res/layout/content_main.xml
 create mode 100644 app/src/main/res/menu/menu_main.xml
 create mode 100644 app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml
 create mode 100644 app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml
 create mode 100644 app/src/main/res/mipmap-hdpi/ic_launcher.png
 create mode 100644 app/src/main/res/mipmap-hdpi/ic_launcher_round.png
 create mode 100644 app/src/main/res/mipmap-mdpi/ic_launcher.png
 create mode 100644 app/src/main/res/mipmap-mdpi/ic_launcher_round.png
 create mode 100644 app/src/main/res/mipmap-xhdpi/ic_launcher.png
 create mode 100644 app/src/main/res/mipmap-xhdpi/ic_launcher_round.png
 create mode 100644 app/src/main/res/mipmap-xxhdpi/ic_launcher.png
 create mode 100644 app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png
 create mode 100644 app/src/main/res/mipmap-xxxhdpi/ic_launcher.png
 create mode 100644 app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png
 create mode 100644 app/src/main/res/values/colors.xml
 create mode 100644 app/src/main/res/values/dimens.xml
 create mode 100644 app/src/main/res/values/strings.xml
 create mode 100644 app/src/main/res/values/styles.xml
 create mode 100644 app/src/test/java/promise/dbapp/ExampleUnitTest.kt
 create mode 100644 checkstyle.xml
 create mode 100644 commons/src/main/java/promise/db/AddedEntity.kt
 delete mode 100644 commons/src/main/java/promise/db/ColumnInfo.kt
 create mode 100644 commons/src/main/java/promise/db/Embedded.kt
 rename commons/src/main/java/promise/db/{EntityInfo.kt => Entity.kt} (51%)
 create mode 100644 commons/src/main/java/promise/db/ForeignKey.kt
 create mode 100644 commons/src/main/java/promise/db/HasMany.kt
 create mode 100644 commons/src/main/java/promise/db/HasOne.kt
 create mode 100644 commons/src/main/java/promise/db/Ignore.kt
 create mode 100644 commons/src/main/java/promise/db/Index.kt
 create mode 100644 commons/src/main/java/promise/db/Migrate.kt
 create mode 100644 commons/src/main/java/promise/db/MigrationOptions.kt
 create mode 100644 commons/src/main/java/promise/db/Migrations.kt
 create mode 100644 commons/src/main/java/promise/db/Number.kt
 create mode 100644 commons/src/main/java/promise/db/PrimaryKey.kt
 create mode 100644 commons/src/main/java/promise/db/PrimaryKeyAutoIncrement.kt
 create mode 100644 commons/src/main/java/promise/db/Text.kt
 create mode 100644 commons/src/main/java/promise/db/TypeConverter.kt
 create mode 100644 commons/src/main/java/promise/db/VarChar.kt
 rename {commons => database}/src/main/java/promise/db/Corrupt.java (95%)
 rename {commons => database}/src/main/java/promise/db/DBError.java (94%)
 rename {commons/src/main/java/promise/db => database/src/main/java/promise}/model/ITimeStamped.java (96%)

diff --git a/.gitignore b/.gitignore
index ac58a36..1c60545 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,17 +9,5 @@
 /build
 /captures
 .externalNativeBuild
-/app
-/appbase
-/commonsapp
-/modelapp
-/netapp
-/promise
-/promisecommons
-/promisemodel
-/promisenet
-/promisepref
-/promiseui
-/uiapp
 
 
diff --git a/app/.classpath b/app/.classpath
new file mode 100644
index 0000000..eb19361
--- /dev/null
+++ b/app/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8/"/>
+	<classpathentry kind="con" path="org.eclipse.buildship.core.gradleclasspathcontainer"/>
+	<classpathentry kind="output" path="bin/default"/>
+</classpath>
diff --git a/app/.gitignore b/app/.gitignore
new file mode 100644
index 0000000..796b96d
--- /dev/null
+++ b/app/.gitignore
@@ -0,0 +1 @@
+/build
diff --git a/app/.project b/app/.project
new file mode 100644
index 0000000..ac485d7
--- /dev/null
+++ b/app/.project
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>app</name>
+	<comment>Project app created by Buildship.</comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.buildship.core.gradleprojectbuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.buildship.core.gradleprojectnature</nature>
+	</natures>
+</projectDescription>
diff --git a/app/.settings/org.eclipse.buildship.core.prefs b/app/.settings/org.eclipse.buildship.core.prefs
new file mode 100644
index 0000000..b1886ad
--- /dev/null
+++ b/app/.settings/org.eclipse.buildship.core.prefs
@@ -0,0 +1,2 @@
+connection.project.dir=..
+eclipse.preferences.version=1
diff --git a/app/build.gradle b/app/build.gradle
new file mode 100644
index 0000000..7ae5417
--- /dev/null
+++ b/app/build.gradle
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+apply plugin: 'com.android.application'
+apply plugin: 'kotlin-android'
+apply plugin: 'kotlin-kapt'
+apply plugin: 'kotlin-android-extensions'
+
+kapt {
+    correctErrorTypes true
+}
+
+android {
+    compileSdkVersion 29
+    buildToolsVersion "29.0.2"
+
+    defaultConfig {
+        applicationId "promise.dbapp"
+        minSdkVersion 21
+        targetSdkVersion 29
+        versionCode 1
+        versionName "1.0"
+
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+
+    }
+
+    compileOptions {
+        sourceCompatibility 1.8
+        targetCompatibility 1.8
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+
+}
+
+dependencies {
+
+    implementation "com.android.support:recyclerview-v7:$supportLibVersion"
+
+    implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
+    implementation 'androidx.appcompat:appcompat:1.1.0'
+    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
+    implementation 'com.google.android.material:material:1.1.0'
+    testImplementation 'junit:junit:4.13'
+    androidTestImplementation 'androidx.test:runner:1.2.0'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
+
+    implementation 'com.github.android-promise:commons:1.1-beta02'
+    implementation 'io.reactivex.rxjava2:rxjava:2.2.17'
+    implementation project(path: ':database')
+    kapt project(path: ':compiler')
+
+    implementation 'com.google.dagger:dagger:2.27'
+    kapt 'com.google.dagger:dagger-compiler:2.27'
+
+    implementation 'com.google.dagger:dagger-android:2.27'
+    implementation 'com.google.dagger:dagger-android-support:2.27'
+    // if you use the support libraries
+    kapt 'com.google.dagger:dagger-android-processor:2.27'
+}
diff --git a/app/deps.txt b/app/deps.txt
new file mode 100644
index 0000000..d4fc7f3
--- /dev/null
+++ b/app/deps.txt
@@ -0,0 +1,6 @@
+//    implementation 'com.google.dagger:dagger:2.27'
+//    kapt 'com.google.dagger:dagger-compiler:2.27'
+//
+//    implementation 'com.google.dagger:dagger-android:2.27'
+//    implementation 'com.google.dagger:dagger-android-support:2.27' // if you use the support libraries
+//    kapt 'com.google.dagger:dagger-android-processor:2.27'
\ No newline at end of file
diff --git a/app/proguard-rules.pro b/app/proguard-rules.pro
new file mode 100644
index 0000000..2a1d497
--- /dev/null
+++ b/app/proguard-rules.pro
@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class tableName to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file tableName.
+#-renamesourcefileattribute SourceFile
diff --git a/app/src/androidTest/java/promise/dbapp/ExampleInstrumentedTest.kt b/app/src/androidTest/java/promise/dbapp/ExampleInstrumentedTest.kt
new file mode 100644
index 0000000..96cce7b
--- /dev/null
+++ b/app/src/androidTest/java/promise/dbapp/ExampleInstrumentedTest.kt
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.dbapp
+
+import androidx.test.InstrumentationRegistry
+import androidx.test.runner.AndroidJUnit4
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * Instrumented test, which will execute on an Android device.
+ *
+ * See [testing documentation](http://d.android.com/tools/testing).
+ */
+@RunWith(AndroidJUnit4::class)
+class ExampleInstrumentedTest {
+  @Test
+  fun useAppContext() {
+    // Context of the app under test.
+    val appContext = InstrumentationRegistry.getTargetContext()
+    assertEquals("promise.dbapp", appContext.packageName)
+  }
+}
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..5b5531a
--- /dev/null
+++ b/app/src/main/AndroidManifest.xml
@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+  ~ Copyright 2017, Peter Vincent
+  ~ Licensed under the Apache License, Version 2.0, Android Promise.
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~ http://www.apache.org/licenses/LICENSE-2.0
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an "AS IS" BASIS,
+  ~  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    package="promise.dbapp">
+
+    <application
+        android:name=".App"
+        android:allowBackup="true"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:roundIcon="@mipmap/ic_launcher_round"
+        android:supportsRtl="true"
+        android:theme="@style/AppTheme"
+        tools:ignore="AllowBackup,GoogleAppIndexingWarning">
+        <activity
+            android:name=".MainActivity"
+            android:label="@string/app_name"
+            android:theme="@style/AppTheme.NoActionBar">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest>
\ No newline at end of file
diff --git a/app/src/main/java/promise/base/AppDatabase.kt b/app/src/main/java/promise/base/AppDatabase.kt
new file mode 100644
index 0000000..42fbb4d
--- /dev/null
+++ b/app/src/main/java/promise/base/AppDatabase.kt
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.base
+
+import promise.base.comment.PostComment
+import promise.base.photo.Photo
+import promise.base.post.Post
+import promise.base.todo.Todo
+import promise.db.DatabaseEntity
+import promise.db.FastDatabase
+import promise.db.PromiseDatabase
+
+@DatabaseEntity(
+    persistableEntities = [
+      PostComment::class,
+      Photo::class,
+      Post::class,
+      Todo::class
+    ]
+)
+abstract class AppDatabase(fastDatabase: FastDatabase)
+  : PromiseDatabase(fastDatabase)
diff --git a/app/src/main/java/promise/base/AppTypeConverter.kt b/app/src/main/java/promise/base/AppTypeConverter.kt
new file mode 100644
index 0000000..1472393
--- /dev/null
+++ b/app/src/main/java/promise/base/AppTypeConverter.kt
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.base
+
+import promise.db.TypeConverter
+
+@TypeConverter
+class AppTypeConverter {
+
+  fun toUniqueId(data: String): ID = ID(data)
+
+  fun toString(data: ID?): String = data?.id ?: ""
+
+}
\ No newline at end of file
diff --git a/app/src/main/java/promise/base/ID.kt b/app/src/main/java/promise/base/ID.kt
new file mode 100644
index 0000000..59ce5f4
--- /dev/null
+++ b/app/src/main/java/promise/base/ID.kt
@@ -0,0 +1,19 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.base
+
+import android.os.Parcel
+import android.os.Parcelable
+
+data class ID(val id: String)
diff --git a/app/src/main/java/promise/base/comment/PostComment.java b/app/src/main/java/promise/base/comment/PostComment.java
new file mode 100644
index 0000000..590de58
--- /dev/null
+++ b/app/src/main/java/promise/base/comment/PostComment.java
@@ -0,0 +1,80 @@
+package promise.base.comment;
+
+import android.annotation.SuppressLint;
+
+import org.jetbrains.annotations.NotNull;
+
+import promise.base.ID;
+import promise.base.post.Post;
+import promise.db.ActiveRecord;
+import promise.db.Entity;
+import promise.db.HasOne;
+
+@SuppressLint("ParcelCreator")
+@Entity
+public class PostComment extends ActiveRecord<PostComment> {
+	private String name;
+	private ID uId;
+	private String body;
+	private String email;
+
+	@HasOne
+	private Post post;
+
+	public void setName(String name){
+		this.name = name;
+	}
+
+	public String getName(){
+		return name;
+	}
+
+	public void setBody(String body){
+		this.body = body;
+	}
+
+	public String getBody(){
+		return body;
+	}
+
+	public void setEmail(String email){
+		this.email = email;
+	}
+
+	public String getEmail(){
+		return email;
+	}
+
+	public Post getPost() {
+		return post;
+	}
+
+	public void setPost(Post post) {
+		this.post = post;
+	}
+
+	@Override
+ 	public String toString(){
+		return 
+			"Comment{" + 
+			"name = '" + name + '\'' +
+			",id = '" + uId + '\'' +
+			",body = '" + body + '\'' + 
+			",email = '" + email + '\'' + 
+			"}";
+		}
+
+	@NotNull
+	@Override
+	public PostComment getEntity() {
+		return this;
+	}
+
+	public ID getUId() {
+		return uId;
+	}
+
+	public void setUId(ID uId) {
+		this.uId = uId;
+	}
+}
diff --git a/app/src/main/java/promise/base/photo/Photo.kt b/app/src/main/java/promise/base/photo/Photo.kt
new file mode 100644
index 0000000..23be1dd
--- /dev/null
+++ b/app/src/main/java/promise/base/photo/Photo.kt
@@ -0,0 +1,26 @@
+package promise.base.photo
+
+import android.annotation.SuppressLint
+import android.os.Parcel
+import android.os.Parcelable
+import promise.base.ID
+import promise.base.post.Post
+import promise.db.ActiveRecord
+import promise.db.Entity
+import promise.db.HasOne
+
+@SuppressLint("ParcelCreator")
+@Entity
+class Photo: ActiveRecord<Photo>() {
+	var albumId: Int? = null
+	var title: String? = null
+	var url: String? = null
+	var thumbnailUrl: String? = null
+	@HasOne var post: Post? = null
+
+	override fun getEntity(): Photo {
+		return this
+	}
+
+}
+
diff --git a/app/src/main/java/promise/base/post/Post.java b/app/src/main/java/promise/base/post/Post.java
new file mode 100644
index 0000000..b73e7ee
--- /dev/null
+++ b/app/src/main/java/promise/base/post/Post.java
@@ -0,0 +1,104 @@
+package promise.base.post;
+
+import android.annotation.SuppressLint;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+import promise.base.ID;
+import promise.base.comment.PostComment;
+import promise.base.photo.Photo;
+import promise.db.ActiveRecord;
+import promise.db.Entity;
+import promise.db.HasMany;
+
+@SuppressLint("ParcelCreator")
+@Entity
+public class Post extends ActiveRecord<Post> {
+	private ID uId;
+	private String title;
+	private String body;
+	private int userId;
+
+	@Override
+	public String toString() {
+		return "Post{" +
+				"uId=" + uId +
+				", title='" + title + '\'' +
+				", body='" + body + '\'' +
+				", userId=" + userId +
+				", comments=" + comments +
+				", photos=" + photos +
+				'}';
+	}
+
+	@HasMany
+	private List<PostComment> comments;
+
+	@HasMany
+	private List<Photo> photos;
+
+
+	public String getTitle(){
+		return title;
+	}
+
+	public String getBody(){
+		return body;
+	}
+
+	public int getUserId(){
+		return userId;
+	}
+
+	public ID getUId() {
+		return uId;
+	}
+
+	public void setUId(ID uId) {
+		this.uId = uId;
+	}
+
+	public void setTitle(String title) {
+		this.title = title;
+	}
+
+	public void setBody(String body) {
+		this.body = body;
+	}
+
+	public void setUserId(int userId) {
+		this.userId = userId;
+	}
+
+	public ID getuId() {
+		return uId;
+	}
+
+	public void setuId(ID uId) {
+		this.uId = uId;
+	}
+
+	public List<PostComment> getComments() {
+		return comments;
+	}
+
+	public void setComments(List<PostComment> comments) {
+		this.comments = comments;
+	}
+
+	public List<Photo> getPhotos() {
+		return photos;
+	}
+
+	public void setPhotos(List<Photo> photos) {
+		this.photos = photos;
+	}
+
+	@NotNull
+	@Override
+	public Post getEntity() {
+		return this;
+	}
+}
diff --git a/app/src/main/java/promise/base/todo/Todo.java b/app/src/main/java/promise/base/todo/Todo.java
new file mode 100644
index 0000000..6fe34c4
--- /dev/null
+++ b/app/src/main/java/promise/base/todo/Todo.java
@@ -0,0 +1,79 @@
+package promise.base.todo;
+
+import android.annotation.SuppressLint;
+
+import org.jetbrains.annotations.NotNull;
+
+import promise.base.photo.Photo;
+import promise.db.ActiveRecord;
+import promise.db.Entity;
+import promise.db.HasOne;
+
+@SuppressLint("ParcelCreator")
+@Entity
+public class Todo extends ActiveRecord<Todo> {
+	private int uid;
+	private boolean completed;
+	private String title;
+	private int userId;
+
+	@HasOne
+	private Photo photo;
+
+	public int getUid() {
+		return uid;
+	}
+
+	public void setUid(int uid) {
+		this.uid = uid;
+	}
+
+	public Photo getPhoto() {
+		return photo;
+	}
+
+	public void setPhoto(Photo photo) {
+		this.photo = photo;
+	}
+
+	public void setCompleted(boolean completed){
+		this.completed = completed;
+	}
+
+	public boolean isCompleted(){
+		return completed;
+	}
+
+	public void setTitle(String title){
+		this.title = title;
+	}
+
+	public String getTitle(){
+		return title;
+	}
+
+	public void setUserId(int userId){
+		this.userId = userId;
+	}
+
+	public int getUserId(){
+		return userId;
+	}
+
+	@Override
+ 	public String toString(){
+		return 
+			"Todo{" + 
+			"id = '" + uid + '\'' +
+			",completed = '" + completed + '\'' + 
+			",title = '" + title + '\'' + 
+			",userId = '" + userId + '\'' + 
+			"}";
+		}
+
+	@NotNull
+	@Override
+	public Todo getEntity() {
+		return this;
+	}
+}
diff --git a/app/src/main/java/promise/dbapp/ActivityBuildersModule.kt b/app/src/main/java/promise/dbapp/ActivityBuildersModule.kt
new file mode 100644
index 0000000..eb210f9
--- /dev/null
+++ b/app/src/main/java/promise/dbapp/ActivityBuildersModule.kt
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.dbapp
+
+import dagger.Module
+import dagger.android.ContributesAndroidInjector
+
+@Module
+abstract class ActivityBuildersModule {
+  @ContributesAndroidInjector
+  abstract fun contributeMainActivity(): MainActivity
+}
\ No newline at end of file
diff --git a/app/src/main/java/promise/dbapp/App.kt b/app/src/main/java/promise/dbapp/App.kt
new file mode 100644
index 0000000..73b32bc
--- /dev/null
+++ b/app/src/main/java/promise/dbapp/App.kt
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.dbapp
+
+import dagger.android.AndroidInjector
+import dagger.android.support.DaggerApplication
+import promise.commons.AndroidPromise
+
+class App : DaggerApplication() {
+  override fun onCreate() {
+    super.onCreate()
+    AndroidPromise.init(this, BuildConfig.DEBUG)
+  }
+
+  override fun applicationInjector(): AndroidInjector<out DaggerApplication> =
+      DaggerAppComponent.builder().app(this).build()
+
+}
\ No newline at end of file
diff --git a/app/src/main/java/promise/dbapp/AppComponent.kt b/app/src/main/java/promise/dbapp/AppComponent.kt
new file mode 100644
index 0000000..0982d25
--- /dev/null
+++ b/app/src/main/java/promise/dbapp/AppComponent.kt
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.dbapp
+
+import dagger.BindsInstance
+import dagger.Component
+import dagger.android.AndroidInjector
+import dagger.android.support.AndroidSupportInjectionModule
+import javax.inject.Singleton
+
+@Component(
+    modules = [
+      AndroidSupportInjectionModule::class,
+      ActivityBuildersModule::class,
+      DatabaseDependencies::class
+    ]
+)
+@Singleton
+interface AppComponent : AndroidInjector<App> {
+
+  @Component.Builder
+  interface Builder {
+
+    @BindsInstance
+    fun app(app: App): Builder
+
+    fun build(): AppComponent
+  }
+}
\ No newline at end of file
diff --git a/app/src/main/java/promise/dbapp/DatabaseDependencies.kt b/app/src/main/java/promise/dbapp/DatabaseDependencies.kt
new file mode 100644
index 0000000..570bb6b
--- /dev/null
+++ b/app/src/main/java/promise/dbapp/DatabaseDependencies.kt
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.dbapp
+
+import dagger.Module
+//import dagger.Provides
+//import promise.base.AppDatabase
+//import promise.base.AppDatabaseImpl
+//import promise.base.post.PostRelationsDao
+//import javax.inject.Singleton
+
+@Module
+object DatabaseDependencies {
+
+//  @Provides
+//  @Singleton
+//  @JvmStatic
+//  fun provideAppDatabase(): AppDatabaseImpl = AppDatabaseImpl.createDatabase("blog_db")
+//
+//  @Provides
+//  @JvmStatic
+//  fun providePostRelationsDao(appDatabase: AppDatabaseImpl): PostRelationsDao =
+//      appDatabase.postRelationsDao
+
+
+}
\ No newline at end of file
diff --git a/app/src/main/java/promise/dbapp/MainActivity.kt b/app/src/main/java/promise/dbapp/MainActivity.kt
new file mode 100644
index 0000000..0a88c63
--- /dev/null
+++ b/app/src/main/java/promise/dbapp/MainActivity.kt
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.dbapp
+
+import android.os.Bundle
+import com.google.android.material.snackbar.Snackbar
+import dagger.android.support.DaggerAppCompatActivity
+import kotlinx.android.synthetic.main.activity_main.*
+import kotlinx.android.synthetic.main.content_main.*
+import promise.base.ID
+import promise.base.comment.PostComment
+import promise.base.post.Post
+import promise.base.post.PostRelationsDao
+import promise.model.IdentifiableList
+import javax.inject.Inject
+import promise.commons.model.List
+
+class MainActivity : DaggerAppCompatActivity() {
+
+ @Inject
+ lateinit var postRelationsDao: PostRelationsDao
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    setContentView(R.layout.activity_main)
+    setSupportActionBar(toolbar)
+
+    fab.setOnClickListener { view ->
+      Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
+          .setAction("Action", null).show()
+    }
+  }
+
+  override fun onPostCreate(savedInstanceState: Bundle?) {
+    super.onPostCreate(savedInstanceState)
+  
+    val posts = IdentifiableList(List.generate(5) {
+      Post().apply {
+        uId = ID(it.toString())
+        title = "post".plus(it)
+        body = "body".plus(it)
+        userId = it
+        comments = List.generate(4) {
+          PostComment().apply {
+            name = "nm".repeat(it)
+            uId = ID((it + 1).toString())
+            body = "hbytcvbcrxgfvbtrxt"
+            email = "ejmail;jgfccghcfcvhbhcgvb"
+          }
+        }
+      }
+    })
+
+   postRelationsDao.saveWithComments(posts)
+
+   val persons = postRelationsDao.listWithComments()
+
+   complex_values_textview.text = persons.toString()
+
+   persons.forEach {
+     postRelationsDao.deleteComments(it)
+     it.delete()
+   }
+  }
+
+}
diff --git a/app/src/main/java/promise/dbapp/test/TestUtils.java b/app/src/main/java/promise/dbapp/test/TestUtils.java
new file mode 100644
index 0000000..1de702e
--- /dev/null
+++ b/app/src/main/java/promise/dbapp/test/TestUtils.java
@@ -0,0 +1,19 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.dbapp.test;
+
+
+public class TestUtils {
+
+}
diff --git a/app/src/main/res/drawable-v24/ic_launcher_foreground.xml b/app/src/main/res/drawable-v24/ic_launcher_foreground.xml
new file mode 100644
index 0000000..9413e02
--- /dev/null
+++ b/app/src/main/res/drawable-v24/ic_launcher_foreground.xml
@@ -0,0 +1,47 @@
+<!--
+  ~ Copyright 2017, Peter Vincent
+  ~ Licensed under the Apache License, Version 2.0, Android Promise.
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~ http://www.apache.org/licenses/LICENSE-2.0
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an "AS IS" BASIS,
+  ~  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:aapt="http://schemas.android.com/aapt"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportWidth="108"
+    android:viewportHeight="108">
+    <path
+        android:fillType="evenOdd"
+        android:pathData="M32,64C32,64 38.39,52.99 44.13,50.95C51.37,48.37 70.14,49.57 70.14,49.57L108.26,87.69L108,109.01L75.97,107.97L32,64Z"
+        android:strokeWidth="1"
+        android:strokeColor="#00000000">
+        <aapt:attr name="android:fillColor">
+            <gradient
+                android:endX="78.5885"
+                android:endY="90.9159"
+                android:startX="48.7653"
+                android:startY="61.0927"
+                android:type="linear">
+                <item
+                    android:color="#44000000"
+                    android:offset="0.0" />
+                <item
+                    android:color="#00000000"
+                    android:offset="1.0" />
+            </gradient>
+        </aapt:attr>
+    </path>
+    <path
+        android:fillColor="#FFFFFF"
+        android:fillType="nonZero"
+        android:pathData="M66.94,46.02L66.94,46.02C72.44,50.07 76,56.61 76,64L32,64C32,56.61 35.56,50.11 40.98,46.06L36.18,41.19C35.45,40.45 35.45,39.3 36.18,38.56C36.91,37.81 38.05,37.81 38.78,38.56L44.25,44.05C47.18,42.57 50.48,41.71 54,41.71C57.48,41.71 60.78,42.57 63.68,44.05L69.11,38.56C69.84,37.81 70.98,37.81 71.71,38.56C72.44,39.3 72.44,40.45 71.71,41.19L66.94,46.02ZM62.94,56.92C64.08,56.92 65,56.01 65,54.88C65,53.76 64.08,52.85 62.94,52.85C61.8,52.85 60.88,53.76 60.88,54.88C60.88,56.01 61.8,56.92 62.94,56.92ZM45.06,56.92C46.2,56.92 47.13,56.01 47.13,54.88C47.13,53.76 46.2,52.85 45.06,52.85C43.92,52.85 43,53.76 43,54.88C43,56.01 43.92,56.92 45.06,56.92Z"
+        android:strokeWidth="1"
+        android:strokeColor="#00000000" />
+</vector>
diff --git a/app/src/main/res/drawable/ic_launcher_background.xml b/app/src/main/res/drawable/ic_launcher_background.xml
new file mode 100644
index 0000000..bb0d62d
--- /dev/null
+++ b/app/src/main/res/drawable/ic_launcher_background.xml
@@ -0,0 +1,182 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+  ~ Copyright 2017, Peter Vincent
+  ~ Licensed under the Apache License, Version 2.0, Android Promise.
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~ http://www.apache.org/licenses/LICENSE-2.0
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an "AS IS" BASIS,
+  ~  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportWidth="108"
+    android:viewportHeight="108">
+    <path
+        android:fillColor="#008577"
+        android:pathData="M0,0h108v108h-108z" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M9,0L9,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,0L19,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M29,0L29,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M39,0L39,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M49,0L49,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M59,0L59,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M69,0L69,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M79,0L79,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M89,0L89,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M99,0L99,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,9L108,9"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,19L108,19"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,29L108,29"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,39L108,39"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,49L108,49"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,59L108,59"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,69L108,69"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,79L108,79"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,89L108,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,99L108,99"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,29L89,29"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,39L89,39"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,49L89,49"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,59L89,59"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,69L89,69"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,79L89,79"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M29,19L29,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M39,19L39,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M49,19L49,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M59,19L59,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M69,19L69,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M79,19L79,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+</vector>
diff --git a/app/src/main/res/layout/activity_main.xml b/app/src/main/res/layout/activity_main.xml
new file mode 100644
index 0000000..ee61dd8
--- /dev/null
+++ b/app/src/main/res/layout/activity_main.xml
@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+  ~ Copyright 2017, Peter Vincent
+  ~ Licensed under the Apache License, Version 2.0, Android Promise.
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~ http://www.apache.org/licenses/LICENSE-2.0
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an "AS IS" BASIS,
+  ~  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+
+<androidx.coordinatorlayout.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:context=".MainActivity">
+
+    <com.google.android.material.appbar.AppBarLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:theme="@style/AppTheme.AppBarOverlay">
+
+        <androidx.appcompat.widget.Toolbar
+            android:id="@+id/toolbar"
+            android:layout_width="match_parent"
+            android:layout_height="?attr/actionBarSize"
+            android:background="?attr/colorPrimary"
+            app:popupTheme="@style/AppTheme.PopupOverlay" />
+
+    </com.google.android.material.appbar.AppBarLayout>
+
+    <include layout="@layout/content_main" />
+
+    <com.google.android.material.floatingactionbutton.FloatingActionButton
+        android:id="@+id/fab"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_gravity="bottom|end"
+        android:layout_margin="@dimen/fab_margin"
+        app:srcCompat="@android:drawable/ic_dialog_email" />
+
+</androidx.coordinatorlayout.widget.CoordinatorLayout>
\ No newline at end of file
diff --git a/app/src/main/res/layout/complex_layout.xml b/app/src/main/res/layout/complex_layout.xml
new file mode 100644
index 0000000..10606a7
--- /dev/null
+++ b/app/src/main/res/layout/complex_layout.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+  ~ Copyright 2017, Peter Vincent
+  ~ Licensed under the Apache License, Version 2.0, Android Promise.
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~ http://www.apache.org/licenses/LICENSE-2.0
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an "AS IS" BASIS,
+  ~  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical">
+
+</LinearLayout>
\ No newline at end of file
diff --git a/app/src/main/res/layout/content_main.xml b/app/src/main/res/layout/content_main.xml
new file mode 100644
index 0000000..ab1a145
--- /dev/null
+++ b/app/src/main/res/layout/content_main.xml
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+  ~ Copyright 2017, Peter Vincent
+  ~ Licensed under the Apache License, Version 2.0, Android Promise.
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~ http://www.apache.org/licenses/LICENSE-2.0
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an "AS IS" BASIS,
+  ~  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+
+<androidx.appcompat.widget.LinearLayoutCompat
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical"
+    app:layout_behavior="@string/appbar_scrolling_view_behavior"
+    tools:context=".MainActivity"
+    tools:showIn="@layout/activity_main">
+    <ScrollView
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content">
+        <TextView
+            android:id="@+id/complex_values_textview"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="Hello World!"
+           />
+    </ScrollView>
+
+    <Button
+        android:id="@+id/clear_button"
+        android:layout_width="match_parent"
+        android:layout_height="30dp"
+        android:text="Clear" />
+
+</androidx.appcompat.widget.LinearLayoutCompat>
\ No newline at end of file
diff --git a/app/src/main/res/menu/menu_main.xml b/app/src/main/res/menu/menu_main.xml
new file mode 100644
index 0000000..6138539
--- /dev/null
+++ b/app/src/main/res/menu/menu_main.xml
@@ -0,0 +1,23 @@
+<!--
+  ~ Copyright 2017, Peter Vincent
+  ~ Licensed under the Apache License, Version 2.0, Android Promise.
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~ http://www.apache.org/licenses/LICENSE-2.0
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an "AS IS" BASIS,
+  ~  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+
+<menu xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    tools:context="promise.dbapp.MainActivity">
+    <item
+        android:id="@+id/action_settings"
+        android:orderInCategory="100"
+        android:title="@string/action_settings"
+        app:showAsAction="never" />
+</menu>
diff --git a/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml b/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml
new file mode 100644
index 0000000..f801df8
--- /dev/null
+++ b/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+  ~ Copyright 2017, Peter Vincent
+  ~ Licensed under the Apache License, Version 2.0, Android Promise.
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~ http://www.apache.org/licenses/LICENSE-2.0
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an "AS IS" BASIS,
+  ~  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@drawable/ic_launcher_background" />
+    <foreground android:drawable="@drawable/ic_launcher_foreground" />
+</adaptive-icon>
\ No newline at end of file
diff --git a/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml b/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml
new file mode 100644
index 0000000..f801df8
--- /dev/null
+++ b/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+  ~ Copyright 2017, Peter Vincent
+  ~ Licensed under the Apache License, Version 2.0, Android Promise.
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~ http://www.apache.org/licenses/LICENSE-2.0
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an "AS IS" BASIS,
+  ~  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@drawable/ic_launcher_background" />
+    <foreground android:drawable="@drawable/ic_launcher_foreground" />
+</adaptive-icon>
\ No newline at end of file
diff --git a/app/src/main/res/mipmap-hdpi/ic_launcher.png b/app/src/main/res/mipmap-hdpi/ic_launcher.png
new file mode 100644
index 0000000000000000000000000000000000000000..898f3ed59ac9f3248734a00e5902736c9367d455
GIT binary patch
literal 2963
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
JPDHLkV1g@XpTGbB

literal 0
HcmV?d00001

diff --git a/app/src/main/res/mipmap-hdpi/ic_launcher_round.png b/app/src/main/res/mipmap-hdpi/ic_launcher_round.png
new file mode 100644
index 0000000000000000000000000000000000000000..dffca3601eba7bf5f409bdd520820e2eb5122c75
GIT binary patch
literal 4905
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
b2HgJxw7%AYvJx@g00000NkvXXu0mjfkw#Z`

literal 0
HcmV?d00001

diff --git a/app/src/main/res/mipmap-mdpi/ic_launcher.png b/app/src/main/res/mipmap-mdpi/ic_launcher.png
new file mode 100644
index 0000000000000000000000000000000000000000..64ba76f75e9ce021aa3d95c213491f73bcacb597
GIT binary patch
literal 2060
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

literal 0
HcmV?d00001

diff --git a/app/src/main/res/mipmap-mdpi/ic_launcher_round.png b/app/src/main/res/mipmap-mdpi/ic_launcher_round.png
new file mode 100644
index 0000000000000000000000000000000000000000..dae5e082342fcdeee5db8a6e0b27028e2d2808f5
GIT binary patch
literal 2783
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

literal 0
HcmV?d00001

diff --git a/app/src/main/res/mipmap-xhdpi/ic_launcher.png b/app/src/main/res/mipmap-xhdpi/ic_launcher.png
new file mode 100644
index 0000000000000000000000000000000000000000..e5ed46597ea8447d91ab1786a34e30f1c26b18bd
GIT binary patch
literal 4490
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

literal 0
HcmV?d00001

diff --git a/app/src/main/res/mipmap-xhdpi/ic_launcher_round.png b/app/src/main/res/mipmap-xhdpi/ic_launcher_round.png
new file mode 100644
index 0000000000000000000000000000000000000000..14ed0af35023e4f1901cf03487b6c524257b8483
GIT binary patch
literal 6895
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

literal 0
HcmV?d00001

diff --git a/app/src/main/res/mipmap-xxhdpi/ic_launcher.png b/app/src/main/res/mipmap-xxhdpi/ic_launcher.png
new file mode 100644
index 0000000000000000000000000000000000000000..b0907cac3bfd8fbfdc46e1108247f0a1055387ec
GIT binary patch
literal 6387
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

literal 0
HcmV?d00001

diff --git a/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png b/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png
new file mode 100644
index 0000000000000000000000000000000000000000..d8ae03154975f397f8ed1b84f2d4bf9783ecfa26
GIT binary patch
literal 10413
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
XdJ+W}DiIkV00000NkvXXu0mjfKBlg6

literal 0
HcmV?d00001

diff --git a/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png b/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png
new file mode 100644
index 0000000000000000000000000000000000000000..2c18de9e66108411737e910f5c1972476f03ddbf
GIT binary patch
literal 9128
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
I20H400LcNok^lez

literal 0
HcmV?d00001

diff --git a/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png b/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png
new file mode 100644
index 0000000000000000000000000000000000000000..beed3cdd2c32af5114a7dc70b9ef5b698eb8797e
GIT binary patch
literal 15132
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
SFP~Pu0;-By3RQBju>S)leN-3#

literal 0
HcmV?d00001

diff --git a/app/src/main/res/values/colors.xml b/app/src/main/res/values/colors.xml
new file mode 100644
index 0000000..f7cdf4d
--- /dev/null
+++ b/app/src/main/res/values/colors.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+  ~ Copyright 2017, Peter Vincent
+  ~ Licensed under the Apache License, Version 2.0, Android Promise.
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~ http://www.apache.org/licenses/LICENSE-2.0
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an "AS IS" BASIS,
+  ~  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+
+<resources>
+    <color name="colorPrimary">#008577</color>
+    <color name="colorPrimaryDark">#00574B</color>
+    <color name="colorAccent">#D81B60</color>
+</resources>
diff --git a/app/src/main/res/values/dimens.xml b/app/src/main/res/values/dimens.xml
new file mode 100644
index 0000000..55ab9c8
--- /dev/null
+++ b/app/src/main/res/values/dimens.xml
@@ -0,0 +1,16 @@
+<!--
+  ~ Copyright 2017, Peter Vincent
+  ~ Licensed under the Apache License, Version 2.0, Android Promise.
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~ http://www.apache.org/licenses/LICENSE-2.0
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an "AS IS" BASIS,
+  ~  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+
+<resources>
+    <dimen name="fab_margin">16dp</dimen>
+</resources>
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
new file mode 100644
index 0000000..cc69657
--- /dev/null
+++ b/app/src/main/res/values/strings.xml
@@ -0,0 +1,17 @@
+<!--
+  ~ Copyright 2017, Peter Vincent
+  ~ Licensed under the Apache License, Version 2.0, Android Promise.
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~ http://www.apache.org/licenses/LICENSE-2.0
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an "AS IS" BASIS,
+  ~  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+
+<resources>
+    <string name="app_name">DBApp</string>
+    <string name="action_settings">Settings</string>
+</resources>
diff --git a/app/src/main/res/values/styles.xml b/app/src/main/res/values/styles.xml
new file mode 100644
index 0000000..53a7d87
--- /dev/null
+++ b/app/src/main/res/values/styles.xml
@@ -0,0 +1,33 @@
+<!--
+  ~ Copyright 2017, Peter Vincent
+  ~ Licensed under the Apache License, Version 2.0, Android Promise.
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~ http://www.apache.org/licenses/LICENSE-2.0
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an "AS IS" BASIS,
+  ~  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+
+<resources>
+
+    <!-- Base application theme. -->
+    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
+        <!-- Customize your theme here. -->
+        <item name="colorPrimary">@color/colorPrimary</item>
+        <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
+        <item name="colorAccent">@color/colorAccent</item>
+    </style>
+
+    <style name="AppTheme.NoActionBar">
+        <item name="windowActionBar">false</item>
+        <item name="windowNoTitle">true</item>
+    </style>
+
+    <style name="AppTheme.AppBarOverlay" parent="ThemeOverlay.AppCompat.Dark.ActionBar" />
+
+    <style name="AppTheme.PopupOverlay" parent="ThemeOverlay.AppCompat.Light" />
+
+</resources>
diff --git a/app/src/test/java/promise/dbapp/ExampleUnitTest.kt b/app/src/test/java/promise/dbapp/ExampleUnitTest.kt
new file mode 100644
index 0000000..b68961f
--- /dev/null
+++ b/app/src/test/java/promise/dbapp/ExampleUnitTest.kt
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.dbapp
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+/**
+ * Example local unit test, which will execute on the development machine (host).
+ *
+ * See [testing documentation](http://d.android.com/tools/testing).
+ */
+class ExampleUnitTest {
+  @Test
+  fun addition_isCorrect() {
+    assertEquals(4, 2 + 2)
+  }
+}
diff --git a/build.gradle b/build.gradle
index 1047ed5..ea4b265 100644
--- a/build.gradle
+++ b/build.gradle
@@ -45,6 +45,18 @@ allprojects {
 }
 
 subprojects { subProject ->
+//    apply plugin: 'checkstyle'
+//
+//    task checkstyle(type: Checkstyle) {
+//        description 'Runs Checkstyle inspection .'
+//        group = 'database'
+//        configFile rootProject.file('checkstyle.xml')
+//        ignoreFailures false
+//        showViolations true
+//        classpath = files()
+//        exclude '**/*.kt'
+//        source 'src/main/java'
+//    }
 
     configurations.all { configuration ->
         // Workaround for kapt bug with MPP dependencies
@@ -54,6 +66,11 @@ subprojects { subProject ->
             attributes.attribute(Usage.USAGE_ATTRIBUTE, subProject.objects.named(Usage.class, Usage.JAVA_RUNTIME))
         }
     }
+
+//     // check code style after project evaluation
+//    afterEvaluate {
+//        check.dependsOn('checkstyle')
+//    }
 }
 
 task clean(type: Delete) {
diff --git a/checkstyle.xml b/checkstyle.xml
new file mode 100644
index 0000000..5d58444
--- /dev/null
+++ b/checkstyle.xml
@@ -0,0 +1,139 @@
+<?xml version="1.0"?>
+<!DOCTYPE module PUBLIC
+    "-//Puppy Crawl//DTD Check Configuration 1.3//EN"
+    "http://www.puppycrawl.com/dtds/configuration_1_3.dtd">
+
+<module name="Checker">
+  <module name="SuppressWarningsFilter"/>
+  <module name="NewlineAtEndOfFile"/>
+  <module name="FileLength"/>
+  <module name="FileTabCharacter"/>
+
+  <!-- Trailing spaces -->
+  <module name="RegexpSingleline">
+    <property name="format" value="\s+$"/>
+    <property name="message" value="Line has trailing spaces."/>
+  </module>
+
+  <!-- Space after 'for' and 'if' -->
+  <module name="RegexpSingleline">
+    <property name="format" value="^\s*(for|if)\b[^ ]"/>
+    <property name="message" value="Space needed before opening parenthesis."/>
+  </module>
+
+  <!-- For each spacing -->
+  <module name="RegexpSingleline">
+    <property name="format" value="^\s*for \(.*?([^ ]:|:[^ ])"/>
+    <property name="message" value="Space needed around ':' character."/>
+  </module>
+
+  <module name="TreeWalker">
+    <!-- Checks for Javadoc comments.                     -->
+    <!-- See http://checkstyle.sf.net/config_javadoc.html -->
+    <!--module name="JavadocMethod"/-->
+    <!--module name="JavadocType"/-->
+    <!--module name="JavadocVariable"/-->
+    <module name="JavadocStyle">
+      <property name="checkFirstSentence" value="false"/>
+    </module>
+
+    <!-- See http://checkstyle.sf.net/config_naming.html -->
+    <!--<module name="ConstantName"/>-->
+    <!--<module name="PackageName"/>-->
+    <module name="LocalFinalVariableName"/>
+    <module name="LocalVariableName"/>
+    <module name="MemberName">
+      <property name="format" value="^[a-z]{2,}\S"/>
+    </module>
+    <module name="MethodName"/>
+    <module name="ParameterName"/>
+    <module name="StaticVariableName">
+      <property name="format" value="^[a-z]{2,}\S"/>
+    </module>
+    <module name="TypeName"/>
+
+    <!-- See http://checkstyle.sf.net/config_import.html -->
+    <module name="AvoidStarImport"/>
+    <module name="IllegalImport"/>
+    <!-- defaults to sun.* packages -->
+    <module name="RedundantImport"/>
+    <module name="UnusedImports">
+      <property name="processJavadoc" value="true"/>
+    </module>
+
+    <!-- Checks for Size Violations.                    -->
+    <!-- See http://checkstyle.sf.net/config_sizes.html -->
+    <module name="LineLength">
+      <property name="max" value="120"/>
+    </module>
+    <module name="MethodLength">
+      <property name="max" value="200"/>
+    </module>
+
+    <!-- See http://checkstyle.sf.net/config_whitespace.html -->
+    <!--<module name="NoWhitespaceAfter"/>-->
+    <!--<module name="NoWhitespaceBefore"/>-->
+    <!--<module name="EmptyForIteratorPad"/>-->
+    <module name="GenericWhitespace"/>
+    <module name="MethodParamPad"/>
+    <module name="OperatorWrap"/>
+    <module name="ParenPad"/>
+    <module name="TypecastParenPad"/>
+    <module name="WhitespaceAfter"/>
+    <module name="WhitespaceAround">
+      <property name="tokens"
+          value="ASSIGN, BAND, BAND_ASSIGN, BOR, BOR_ASSIGN, BSR, BSR_ASSIGN, BXOR, BXOR_ASSIGN,
+          COLON, DIV, DIV_ASSIGN, DO_WHILE, EQUAL, GE, GT, LAND, LCURLY, LE, LITERAL_CATCH,
+          LITERAL_DO, LITERAL_ELSE, LITERAL_FINALLY, LITERAL_FOR, LITERAL_IF, LITERAL_RETURN,
+          LITERAL_SWITCH, LITERAL_SYNCHRONIZED, LITERAL_TRY, LITERAL_WHILE, LOR, LT, MINUS,
+          MINUS_ASSIGN, MOD, MOD_ASSIGN, NOT_EQUAL, PLUS, PLUS_ASSIGN, QUESTION, SL, SLIST,
+          SL_ASSIGN, SR, SR_ASSIGN, STAR, STAR_ASSIGN, LITERAL_ASSERT, TYPE_EXTENSION_AND"/>
+    </module>
+
+    <!-- See http://checkstyle.sf.net/config_modifiers.html -->
+    <module name="ModifierOrder"/>
+    <module name="RedundantModifier"/>
+
+    <!-- See http://checkstyle.sf.net/config_blocks.html -->
+    <!--module name="EmptyBlock"/-->
+    <!--<module name="NeedBraces"/>-->
+    <module name="AvoidNestedBlocks"/>
+    <module name="LeftCurly"/>
+    <module name="RightCurly"/>
+
+    <!-- Checks for common coding problems               -->
+    <!-- See http://checkstyle.sf.net/config_coding.html -->
+    <!--module name="AvoidInlineConditionals"/-->
+    <!--module name="HiddenField"/-->
+    <!--module name="InnerAssignment"/-->
+    <!--module name="MissingSwitchDefault"/-->
+    <!--<module name="RedundantThrows"/>-->
+    <!--<module name="EqualsAvoidNull"/>-->
+
+    <module name="CovariantEquals"/>
+    <module name="EmptyStatement"/>
+    <module name="EqualsHashCode"/>
+    <module name="IllegalInstantiation"/>
+    <module name="SimplifyBooleanExpression"/>
+    <module name="SimplifyBooleanReturn"/>
+    <module name="MagicNumber">
+      <property name="ignoreHashCodeMethod" value="true"/>
+    </module>
+
+    <!-- See http://checkstyle.sf.net/config_design.html -->
+    <!--module name="DesignForExtension"/-->
+    <!--<module name="FinalClass"/>-->
+    <!--module name="VisibilityModifier"/-->
+    <module name="HideUtilityClassConstructor"/>
+    <module name="InterfaceIsType"/>
+
+    <!-- See http://checkstyle.sf.net/config_misc.html -->
+    <!--module name="FinalParameters"/-->
+    <!--module name="TodoComment"/-->
+    <module name="UpperEll"/>
+    <module name="ArrayTypeStyle"/>
+
+    <!-- Make the @SuppressWarnings annotations available to Checkstyle -->
+    <module name="SuppressWarningsHolder"/>
+  </module>
+</module>
\ No newline at end of file
diff --git a/commons/src/main/java/promise/db/AddedEntity.kt b/commons/src/main/java/promise/db/AddedEntity.kt
new file mode 100644
index 0000000..5052d9b
--- /dev/null
+++ b/commons/src/main/java/promise/db/AddedEntity.kt
@@ -0,0 +1,19 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db
+
+@Target(AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.SOURCE)
+annotation class AddedEntity(val fromVersion: Int,
+                             val toVersion: Int)
\ No newline at end of file
diff --git a/commons/src/main/java/promise/db/ColumnInfo.kt b/commons/src/main/java/promise/db/ColumnInfo.kt
deleted file mode 100644
index 551bc2e..0000000
--- a/commons/src/main/java/promise/db/ColumnInfo.kt
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright 2017, Peter Vincent
- * Licensed under the Apache License, Version 2.0, Android Promise.
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package promise.db
-
-@Target(AnnotationTarget.FIELD)
-@Retention(AnnotationRetention.SOURCE)
-annotation class VarChar(val columnName: String = "",
-                         val length: Int,
-                         val nullable: Boolean = true,
-                         val unique: Boolean = false,
-                         val index: Boolean = false)
-
-@Target(AnnotationTarget.FIELD)
-@Retention(AnnotationRetention.SOURCE)
-annotation class Text(val columnName: String = "",
-                      val nullable: Boolean = true,
-                      val unique: Boolean = false,
-                      val index: Boolean = false)
-
-@Target(AnnotationTarget.FIELD)
-@Retention(AnnotationRetention.SOURCE)
-annotation class Number(val columnName: String = "",
-                        val default: Int = 0,
-                        val nullable: Boolean = true,
-                        val unique: Boolean = false,
-                        val index: Boolean = false)
-
-@Target(AnnotationTarget.FIELD)
-@Retention(AnnotationRetention.SOURCE)
-annotation class PrimaryKey(val name: String = "")
-
-@Target(AnnotationTarget.FIELD)
-@Retention(AnnotationRetention.SOURCE)
-annotation class Embedded(val prefix: String = "")
-
-@Target(AnnotationTarget.FIELD)
-@Retention(AnnotationRetention.SOURCE)
-annotation class Ignore
-
-@Target(AnnotationTarget.FIELD)
-@Retention(AnnotationRetention.SOURCE)
-annotation class PrimaryKeyAutoIncrement
-
-
-enum class MigrationOptions {
-  CREATE, DROP, CREATE_INDEX
-}
-
-@Target(AnnotationTarget.FIELD)
-@Retention(AnnotationRetention.SOURCE)
-annotation class Migrate(val fromVersion: Int,
-                         val toVersion: Int,
-                         val action: MigrationOptions)
-
-
-@Target(AnnotationTarget.FIELD)
-@Retention(AnnotationRetention.SOURCE)
-annotation class Migrations(val values: Array<Migrate>)
-
-@Target(AnnotationTarget.FIELD, AnnotationTarget.CLASS)
-@Retention(AnnotationRetention.SOURCE)
-annotation class TypeConverter
-
-
-
diff --git a/commons/src/main/java/promise/db/Embedded.kt b/commons/src/main/java/promise/db/Embedded.kt
new file mode 100644
index 0000000..22add9d
--- /dev/null
+++ b/commons/src/main/java/promise/db/Embedded.kt
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db
+
+@Target(AnnotationTarget.FIELD)
+@Retention(AnnotationRetention.SOURCE)
+annotation class Embedded(val prefix: String = "")
\ No newline at end of file
diff --git a/commons/src/main/java/promise/db/EntityInfo.kt b/commons/src/main/java/promise/db/Entity.kt
similarity index 51%
rename from commons/src/main/java/promise/db/EntityInfo.kt
rename to commons/src/main/java/promise/db/Entity.kt
index 81e65ab..0148617 100644
--- a/commons/src/main/java/promise/db/EntityInfo.kt
+++ b/commons/src/main/java/promise/db/Entity.kt
@@ -13,63 +13,14 @@
 
 package promise.db
 
-import kotlin.reflect.KClass
-
-@Target(AnnotationTarget.CLASS)
-@Retention(AnnotationRetention.SOURCE)
-annotation class AddedEntity(val fromVersion: Int,
-                             val toVersion: Int)
-
 @Target(AnnotationTarget.CLASS)
 @Retention(AnnotationRetention.SOURCE)
 annotation class Entity(val tableName: String = "",
-                        /**
-                         * @return
-                         */
                         val compoundIndices: Array<CompoundIndex> = []
 ) {
-  /**
-   *
-   */
   @Target(AnnotationTarget.FIELD)
   @Retention(AnnotationRetention.SOURCE)
   annotation class CompoundIndex(
       val columns: Array<String>,
-      /**
-       * @return
-       */
       val unique: Boolean = false)
-
-  /**
-   *
-   */
-
-}
-
-@Target(AnnotationTarget.FIELD)
-@Retention(AnnotationRetention.SOURCE)
-annotation class Index
-
-@Target(AnnotationTarget.FIELD)
-@Retention(AnnotationRetention.SOURCE)
-annotation class ForeignKey(
-    /**
-     * @return
-     */
-    val referencedEntity: KClass<*>,
-    /**
-     * @return
-     */
-    val referencedEntityColumnName: String = "id")
-
-
-@Target(AnnotationTarget.FIELD)
-@Retention(AnnotationRetention.SOURCE)
-annotation class HasOne
-
-@Target(AnnotationTarget.FIELD)
-@Retention(AnnotationRetention.SOURCE)
-annotation class HasMany
-
-
-
+}
\ No newline at end of file
diff --git a/commons/src/main/java/promise/db/ForeignKey.kt b/commons/src/main/java/promise/db/ForeignKey.kt
new file mode 100644
index 0000000..af03565
--- /dev/null
+++ b/commons/src/main/java/promise/db/ForeignKey.kt
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db
+
+import kotlin.reflect.KClass
+
+@Target(AnnotationTarget.FIELD)
+@Retention(AnnotationRetention.SOURCE)
+annotation class ForeignKey(
+    val referencedEntity: KClass<*>,
+    val referencedEntityColumnName: String = "id")
\ No newline at end of file
diff --git a/commons/src/main/java/promise/db/HasMany.kt b/commons/src/main/java/promise/db/HasMany.kt
new file mode 100644
index 0000000..aee5ea5
--- /dev/null
+++ b/commons/src/main/java/promise/db/HasMany.kt
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db
+
+
+@Target(AnnotationTarget.FIELD)
+@Retention(AnnotationRetention.SOURCE)
+annotation class HasMany
+
+
+
diff --git a/commons/src/main/java/promise/db/HasOne.kt b/commons/src/main/java/promise/db/HasOne.kt
new file mode 100644
index 0000000..292eb94
--- /dev/null
+++ b/commons/src/main/java/promise/db/HasOne.kt
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db
+
+@Target(AnnotationTarget.FIELD)
+@Retention(AnnotationRetention.SOURCE)
+annotation class HasOne
\ No newline at end of file
diff --git a/commons/src/main/java/promise/db/Ignore.kt b/commons/src/main/java/promise/db/Ignore.kt
new file mode 100644
index 0000000..21a990c
--- /dev/null
+++ b/commons/src/main/java/promise/db/Ignore.kt
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db
+
+@Target(AnnotationTarget.FIELD)
+@Retention(AnnotationRetention.SOURCE)
+annotation class Ignore
\ No newline at end of file
diff --git a/commons/src/main/java/promise/db/Index.kt b/commons/src/main/java/promise/db/Index.kt
new file mode 100644
index 0000000..b0cbe20
--- /dev/null
+++ b/commons/src/main/java/promise/db/Index.kt
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db
+
+@Target(AnnotationTarget.FIELD)
+@Retention(AnnotationRetention.SOURCE)
+annotation class Index
\ No newline at end of file
diff --git a/commons/src/main/java/promise/db/Migrate.kt b/commons/src/main/java/promise/db/Migrate.kt
new file mode 100644
index 0000000..c2485d6
--- /dev/null
+++ b/commons/src/main/java/promise/db/Migrate.kt
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db
+
+@Target(AnnotationTarget.FIELD)
+@Retention(AnnotationRetention.SOURCE)
+annotation class Migrate(val fromVersion: Int,
+                         val toVersion: Int,
+                         val action: MigrationOptions)
\ No newline at end of file
diff --git a/commons/src/main/java/promise/db/MigrationOptions.kt b/commons/src/main/java/promise/db/MigrationOptions.kt
new file mode 100644
index 0000000..572d100
--- /dev/null
+++ b/commons/src/main/java/promise/db/MigrationOptions.kt
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db
+
+enum class MigrationOptions {
+  CREATE, DROP, CREATE_INDEX
+}
\ No newline at end of file
diff --git a/commons/src/main/java/promise/db/Migrations.kt b/commons/src/main/java/promise/db/Migrations.kt
new file mode 100644
index 0000000..7163a45
--- /dev/null
+++ b/commons/src/main/java/promise/db/Migrations.kt
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db
+
+@Target(AnnotationTarget.FIELD)
+@Retention(AnnotationRetention.SOURCE)
+annotation class Migrations(val values: Array<Migrate>)
\ No newline at end of file
diff --git a/commons/src/main/java/promise/db/Number.kt b/commons/src/main/java/promise/db/Number.kt
new file mode 100644
index 0000000..bdb636f
--- /dev/null
+++ b/commons/src/main/java/promise/db/Number.kt
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db
+
+@Target(AnnotationTarget.FIELD)
+@Retention(AnnotationRetention.SOURCE)
+annotation class Number(val columnName: String = "",
+                        val default: Int = 0,
+                        val nullable: Boolean = true,
+                        val unique: Boolean = false,
+                        val index: Boolean = false)
\ No newline at end of file
diff --git a/commons/src/main/java/promise/db/PrimaryKey.kt b/commons/src/main/java/promise/db/PrimaryKey.kt
new file mode 100644
index 0000000..98e9100
--- /dev/null
+++ b/commons/src/main/java/promise/db/PrimaryKey.kt
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db
+
+@Target(AnnotationTarget.FIELD)
+@Retention(AnnotationRetention.SOURCE)
+annotation class PrimaryKey(val name: String = "")
\ No newline at end of file
diff --git a/commons/src/main/java/promise/db/PrimaryKeyAutoIncrement.kt b/commons/src/main/java/promise/db/PrimaryKeyAutoIncrement.kt
new file mode 100644
index 0000000..5f0a1c5
--- /dev/null
+++ b/commons/src/main/java/promise/db/PrimaryKeyAutoIncrement.kt
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db
+
+@Target(AnnotationTarget.FIELD)
+@Retention(AnnotationRetention.SOURCE)
+annotation class PrimaryKeyAutoIncrement
\ No newline at end of file
diff --git a/commons/src/main/java/promise/db/Table.java b/commons/src/main/java/promise/db/Table.java
index 513d2d7..f799b05 100644
--- a/commons/src/main/java/promise/db/Table.java
+++ b/commons/src/main/java/promise/db/Table.java
@@ -18,74 +18,30 @@
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
-/**
- *
- */
 @Target(ElementType.TYPE)
 @Retention(RetentionPolicy.RUNTIME)
 public @interface Table {
-  /**
-   * @return
-   */
   String tableName();
-
-  /**
-   * @return
-   */
   Index[] indices() default {};
-
   CompoundIndex[] compoundIndexes() default {};
-
-  /**
-   * @return
-   */
   ForeignKey[] foreignKeys() default {};
-
-  /**
-   *
-   */
   @Target(ElementType.TYPE)
   @Retention(RetentionPolicy.RUNTIME)
   @interface Index {
-    /**
-     * @return
-     */
     String columnName();
-
-    ;
   }
-
-  /**
-   *
-   */
   @Target(ElementType.TYPE)
   @Retention(RetentionPolicy.RUNTIME)
   @interface CompoundIndex {
     boolean unique() default false;
-
     Index[] indexes() default {};
   }
 
-  /**
-   *
-   */
   @Target(ElementType.TYPE)
   @Retention(RetentionPolicy.RUNTIME)
   @interface ForeignKey {
-    /**
-     * @return
-     */
     String columnName();
-
-    /**
-     * @return
-     */
     String referencedTableName();
-
-    /**
-     * @return
-     */
     String referencedColumnName();
   }
-
 }
diff --git a/commons/src/main/java/promise/db/Text.kt b/commons/src/main/java/promise/db/Text.kt
new file mode 100644
index 0000000..60d4511
--- /dev/null
+++ b/commons/src/main/java/promise/db/Text.kt
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db
+
+@Target(AnnotationTarget.FIELD)
+@Retention(AnnotationRetention.SOURCE)
+annotation class Text(val columnName: String = "",
+                      val nullable: Boolean = true,
+                      val unique: Boolean = false,
+                      val index: Boolean = false)
\ No newline at end of file
diff --git a/commons/src/main/java/promise/db/TypeConverter.kt b/commons/src/main/java/promise/db/TypeConverter.kt
new file mode 100644
index 0000000..e606fc1
--- /dev/null
+++ b/commons/src/main/java/promise/db/TypeConverter.kt
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package promise.db
+
+
+@Target(AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.SOURCE)
+annotation class TypeConverter
+
+
+
diff --git a/commons/src/main/java/promise/db/VarChar.kt b/commons/src/main/java/promise/db/VarChar.kt
new file mode 100644
index 0000000..afe7753
--- /dev/null
+++ b/commons/src/main/java/promise/db/VarChar.kt
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db
+
+@Target(AnnotationTarget.FIELD)
+@Retention(AnnotationRetention.SOURCE)
+annotation class VarChar(val columnName: String = "",
+                         val length: Int,
+                         val nullable: Boolean = true,
+                         val unique: Boolean = false,
+                         val index: Boolean = false)
\ No newline at end of file
diff --git a/compiler/build.gradle b/compiler/build.gradle
index 54634b5..da64c43 100644
--- a/compiler/build.gradle
+++ b/compiler/build.gradle
@@ -22,14 +22,11 @@ dependencies {
     compileOnly project(path: ':commons')
     compileOnly files(Jvm.current().getToolsJar())
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
-
     implementation group: 'org.atteo', name: 'evo-inflector', version: '1.0.1'
-
     implementation 'com.squareup:javapoet:1.13.0'
     implementation "org.jetbrains.kotlin:kotlin-reflect:1.3.72"
     implementation 'com.google.auto:auto-common:0.10'
     compileOnly "com.google.auto.service:auto-service:1.0-rc4"
     kapt "com.google.auto.service:auto-service:1.0-rc4"
-
     testImplementation 'junit:junit:4.13'
 }
diff --git a/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt b/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt
index 3461c8b..7dd5115 100644
--- a/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt
+++ b/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt
@@ -28,8 +28,8 @@ import javax.annotation.processing.SupportedSourceVersion
 import javax.lang.model.SourceVersion
 import javax.lang.model.element.TypeElement
 
-@AutoService(Processor::class) // For registering the service
-@SupportedSourceVersion(SourceVersion.RELEASE_8) // to support Java 8
+@AutoService(Processor::class)
+@SupportedSourceVersion(SourceVersion.RELEASE_8)
 @SupportedOptions(PromiseDatabaseCompiler.KAPT_JAVA_GENERATED_OPTION_NAME)
 class PromiseDatabaseCompiler : AbstractProcessor() {
 
@@ -39,6 +39,7 @@ class PromiseDatabaseCompiler : AbstractProcessor() {
   }
 
   override fun process(mutableSet: MutableSet<out TypeElement>?, environment: RoundEnvironment?): Boolean {
+    if (mutableSet == null || mutableSet.isEmpty()) return false
     try {
       val javaFiles: ArrayList<JavaFile.Builder> = ArrayList()
       val processors: ArrayList<AnnotatedClassProcessor> = ArrayList()
@@ -53,7 +54,7 @@ class PromiseDatabaseCompiler : AbstractProcessor() {
       }
       javaFiles.forEach {
         it
-            .indent("  ")
+            .indent("\\t")
             .skipJavaLangImports(true)
             .addFileComment(
                 """
diff --git a/compiler/src/main/java/promise/db/ompiler/utils/JavaUtils.java b/compiler/src/main/java/promise/db/ompiler/utils/JavaUtils.java
index 0793647..805bca0 100644
--- a/compiler/src/main/java/promise/db/ompiler/utils/JavaUtils.java
+++ b/compiler/src/main/java/promise/db/ompiler/utils/JavaUtils.java
@@ -34,6 +34,7 @@
 import javax.lang.model.type.TypeMirror;
 import javax.lang.model.type.WildcardType;
 
+@SuppressWarnings("WeakerAccess")
 public class JavaUtils {
 
   // code generation participants
diff --git a/compiler/src/main/java/promise/db/ompiler/utils/Utils.kt b/compiler/src/main/java/promise/db/ompiler/utils/Utils.kt
index 833b293..790c701 100644
--- a/compiler/src/main/java/promise/db/ompiler/utils/Utils.kt
+++ b/compiler/src/main/java/promise/db/ompiler/utils/Utils.kt
@@ -33,11 +33,14 @@ import javax.lang.model.element.ExecutableElement
 import javax.lang.model.element.Modifier
 import javax.lang.model.element.TypeElement
 import javax.lang.model.element.VariableElement
+import javax.lang.model.type.DeclaredType
 import javax.lang.model.type.MirroredTypeException
 import javax.lang.model.type.TypeKind
 import javax.lang.model.type.TypeMirror
 import javax.lang.model.util.Types
 import javax.tools.Diagnostic
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.contract
 import kotlin.reflect.KClass
 
 
@@ -66,7 +69,11 @@ fun VariableElement.getClass(): KClass<*> {
   }
 }
 
+@UseExperimental(ExperimentalContracts::class)
 fun TypeMirror.asTypeElement(processingEnv: ProcessingEnvironment): TypeElement {
+  contract {
+    returns() implies (this@asTypeElement is DeclaredType)
+  }
   val typeUtils: Types = processingEnv.typeUtils
   return (try {
     typeUtils.asElement(this)
diff --git a/database/build.gradle b/database/build.gradle
index a6478c7..081ca48 100644
--- a/database/build.gradle
+++ b/database/build.gradle
@@ -28,9 +28,10 @@ android {
     }
 
     buildTypes {
+
         release {
             minifyEnabled false
-            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+            //proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
         }
     }
 
@@ -43,7 +44,7 @@ android {
 dependencies {
     api project(path: ':commons')
     compileOnly 'io.reactivex.rxjava2:rxjava:2.2.17'
-    compileOnly 'androidx.appcompat:appcompat:1.1.0'
+    compileOnly 'androidx.appcompat:appcompat:1.2.0'
     compileOnly 'com.github.android-promise:commons:1.1-beta02'
     testImplementation 'junit:junit:4.13'
     androidTestImplementation 'androidx.test:runner:1.2.0'
diff --git a/database/src/main/java/promise/db/ActiveRecord.kt b/database/src/main/java/promise/db/ActiveRecord.kt
index 0a7935c..79ec070 100644
--- a/database/src/main/java/promise/db/ActiveRecord.kt
+++ b/database/src/main/java/promise/db/ActiveRecord.kt
@@ -18,51 +18,31 @@ import promise.commons.model.Identifiable
 import promise.commons.util.Conditions
 import promise.model.TimeStamped
 
-/**
- *
- */
 abstract class ActiveRecord<T : Identifiable<Int>>() : TimeStamped() {
-  /**
-   *
-   */
+
   internal var table: FastTable<T>? = null
 
-  /**
-   *
-   */
   constructor(parcel: Parcel?) : this() {
     super.readFromParcel(parcel)
   }
 
-  /**
-   *
-   */
   @Throws(Exception::class)
   fun save(): Long {
     Conditions.checkNotNull(table, "This record has not been read from the database and can't be saved")
     return table!!.save(getEntity())
   }
 
-  /**
-   *
-   */
   @Throws(Exception::class)
   fun update(): Boolean {
     Conditions.checkNotNull(table, "This record has not been read from the database and can't be updated")
     return table!!.update(getEntity())
   }
 
-  /**
-   *
-   */
   @Throws(Exception::class)
   fun delete(): Boolean {
     Conditions.checkNotNull(table, "This record has not been read from the database and can't be deleted")
     return table!!.delete(getEntity())
   }
 
-  /**
-   *
-   */
   abstract fun getEntity(): T
 }
\ No newline at end of file
diff --git a/database/src/main/java/promise/db/Column.java b/database/src/main/java/promise/db/Column.java
index d68d6f2..b7e63b4 100644
--- a/database/src/main/java/promise/db/Column.java
+++ b/database/src/main/java/promise/db/Column.java
@@ -230,23 +230,6 @@ public static Type NOT_NULL(int len) {
       }
     }
 
-    public static class BLOB {
-      private static final String prefix =
-          "BLOB";
-
-      public static Type NULLABLE() {
-        return newType(prefix, NULL.YES);
-      }
-
-      public static Type UNIQUE() {
-        return newType(prefix);
-      }
-
-      public static Type NOT_NULL() {
-        return newType(prefix, NULL.NO);
-      }
-    }
-
     public static class REAL {
       private static final String prefix =
           "REAL";
diff --git a/commons/src/main/java/promise/db/Corrupt.java b/database/src/main/java/promise/db/Corrupt.java
similarity index 95%
rename from commons/src/main/java/promise/db/Corrupt.java
rename to database/src/main/java/promise/db/Corrupt.java
index c0aef65..08b6efb 100644
--- a/commons/src/main/java/promise/db/Corrupt.java
+++ b/database/src/main/java/promise/db/Corrupt.java
@@ -13,12 +13,7 @@
 
 package promise.db;
 
-/**
- *
- */
 public interface Corrupt {
-  /**
-   *
-   */
+
   void onCorrupt();
 }
diff --git a/database/src/main/java/promise/db/Crud.kt b/database/src/main/java/promise/db/Crud.kt
index 5074ec8..ebe8781 100644
--- a/database/src/main/java/promise/db/Crud.kt
+++ b/database/src/main/java/promise/db/Crud.kt
@@ -16,74 +16,31 @@ import promise.commons.model.Identifiable
 import promise.commons.model.List
 import promise.model.IdentifiableList
 
-/**
- *
- */
 interface Crud<X> {
 
-
-  /**
-   *
-   */
   fun <T : Identifiable<Int>> find(tableCrud: TableCrud<T, in X>): TableCrud.Extras<T>
 
-  /**
-   *
-   */
   fun <T : Identifiable<Int>> findAll(tableCrud: TableCrud<T, in X>): IdentifiableList<out T>
 
-  /**
-   *
-   */
   fun <T : Identifiable<Int>> update(t: T, tableCrud: TableCrud<T, in X>, column: Column<*>): Boolean
 
-  /**
-   *
-   */
   fun <T : Identifiable<Int>> update(t: T, tableCrud: TableCrud<T, in X>): Boolean
 
-  /**
-   *
-   */
   fun <T : Identifiable<Int>> findAll(tableCrud: TableCrud<T, in X>, vararg columns: Column<*>): IdentifiableList<out T>
 
-  /**
-   *
-   */
   fun delete(tableCrud: TableCrud<*, in X>, column: Column<*>): Boolean
 
-  /**
-   *
-   */
   fun <T : Identifiable<Int>> delete(tableCrud: TableCrud<T, in X>, t: T): Boolean
 
-  /**
-   *
-   */
   fun delete(tableCrud: TableCrud<*, in X>): Boolean
 
-  /**
-   *
-   */
   fun <T> delete(tableCrud: TableCrud<*, in X>, column: Column<T>, list: List<out T>): Boolean
 
-  /**
-   *
-   */
   fun <T : Identifiable<Int>> save(t: T, tableCrud: TableCrud<T, in X>): Long
 
-  /**
-   *
-   */
   fun <T : Identifiable<Int>> save(list: IdentifiableList<out T>, tableCrud: TableCrud<T, in X>): Boolean
 
-  /**
-   *
-   */
   fun deleteAll(): Boolean
 
-  /**
-   *
-   */
   fun getLastId(tableCrud: TableCrud<*, in X>): Int
 }
\ No newline at end of file
diff --git a/database/src/main/java/promise/db/CrudStore.java b/database/src/main/java/promise/db/CrudStore.java
index c8da0e6..181bbea 100644
--- a/database/src/main/java/promise/db/CrudStore.java
+++ b/database/src/main/java/promise/db/CrudStore.java
@@ -19,27 +19,15 @@
 import promise.commons.model.List;
 import promise.commons.tx.PromiseResult;
 
-/**
- * @param <T>
- */
 public class CrudStore<T extends Identifiable<Integer>>
     implements Store<T, TableCrud<T, ? super SQLiteDatabase>, Throwable> {
-  /**
-   *
-   */
+
   private Crud<SQLiteDatabase> crudStore;
 
-  /**
-   * @param crudStore
-   */
   public CrudStore(Crud<SQLiteDatabase> crudStore) {
     this.crudStore = crudStore;
   }
 
-  /**
-   * @param tsqLiteDatabaseTable
-   * @param callBack
-   */
   @Override
   public void get(
       TableCrud<T, ? super SQLiteDatabase> tsqLiteDatabaseTable,
@@ -53,11 +41,6 @@ public final <X> List<? extends T> filter(List<? extends T> list, X... x) {
     }, callBack);
   }
 
-  /**
-   * @param tsqLiteDatabaseTable
-   * @param t
-   * @param callBack
-   */
   @Override
   public void delete(
       TableCrud<T, ? super SQLiteDatabase> tsqLiteDatabaseTable,
@@ -70,11 +53,6 @@ public void delete(
     }
   }
 
-  /**
-   * @param tsqLiteDatabaseTable
-   * @param t
-   * @param callBack
-   */
   @Override
   public void update(
       TableCrud<T, ? super SQLiteDatabase> tsqLiteDatabaseTable,
@@ -87,11 +65,6 @@ public void update(
     }
   }
 
-  /**
-   * @param tsqLiteDatabaseTable
-   * @param t
-   * @param callBack
-   */
   @Override
   public void save(
       TableCrud<T, ? super SQLiteDatabase> tsqLiteDatabaseTable,
@@ -104,10 +77,6 @@ public void save(
     }
   }
 
-  /**
-   * @param tsqLiteDatabaseTable
-   * @param callBack
-   */
   @Override
   public void clear(
       TableCrud<T, ? super SQLiteDatabase> tsqLiteDatabaseTable,
@@ -119,9 +88,6 @@ public void clear(
     }
   }
 
-  /**
-   * @param callBack
-   */
   @Override
   public void clear(PromiseResult<Boolean, Throwable> callBack) {
     try {
diff --git a/commons/src/main/java/promise/db/DBError.java b/database/src/main/java/promise/db/DBError.java
similarity index 94%
rename from commons/src/main/java/promise/db/DBError.java
rename to database/src/main/java/promise/db/DBError.java
index af80017..85fa03d 100644
--- a/commons/src/main/java/promise/db/DBError.java
+++ b/database/src/main/java/promise/db/DBError.java
@@ -13,9 +13,7 @@
 
 package promise.db;
 
-/**
- * Created by yoctopus on 2/21/17.
- */
+
 public final class DBError extends Exception {
   DBError() {
   }
diff --git a/database/src/main/java/promise/db/DMLFunctions.kt b/database/src/main/java/promise/db/DMLFunctions.kt
index a4bf807..7d1797c 100644
--- a/database/src/main/java/promise/db/DMLFunctions.kt
+++ b/database/src/main/java/promise/db/DMLFunctions.kt
@@ -20,182 +20,68 @@ import promise.commons.model.Identifiable
 import promise.commons.model.List
 import promise.model.IdentifiableList
 
-/**
- *
- */
 interface DMLFunctions<T : Identifiable<Int>> {
 
-  /**
-   *
-   */
+  fun transact(block: FastTable<T>.() -> Unit)
+
   fun querySql(sql: String): Cursor
 
-  /**
-   * @param t
-   * @return
-   */
   fun save(t: T): Long
 
-  /**
-   * @param t
-   * @return
-   */
   fun saveAsync(t: T): Single<Long>
 
-  /**
-   * @param list
-   * @return
-   */
   fun save(list: IdentifiableList<out T>): Boolean
 
-  /**
-   * @param list
-   * @return
-   */
   fun saveAsync(list: IdentifiableList<out T>): Single<Boolean>
 
-  /**
-   * @param t
-   * @return
-   */
   fun update(t: T): Boolean
 
-  /**
-   * @param t
-   * @return
-   */
   fun updateAsync(t: T): Maybe<Boolean>
 
-  /**
-   * @param t
-   * @param column
-   * @return
-   */
   fun update(t: T, column: Column<*>): Boolean
 
-  /**
-   * @param t
-   * @param column
-   * @return
-   */
   fun updateAsync(t: T, column: Column<*>): Maybe<Boolean>
 
-  /**
-   *
-   */
   fun queryBuilder(): QueryBuilder
 
-  /**
-   *
-   */
   fun query(queryBuilder: QueryBuilder): Cursor
 
-  /**
-   *
-   */
   fun queryAsync(queryBuilder: QueryBuilder): Single<Cursor>
 
-  /**
-   * @return
-   */
   fun find(): TableCrud.Extras<T>
 
-  /**
-   * @return
-   */
   fun findById(idLong: Long): T?
 
-  /**
-   * @return
-   */
   fun findOne(vararg columns: Column<*>): T?
 
-  /**
-   * @return
-   * @throws TableError
-   */
   @Throws(TableError::class)
   fun findAsync(): ReactiveTable.Extras<T>
 
-  /**
-   * @return
-   */
   fun findAll(): IdentifiableList<out T>
 
-  /**
-   * @return
-   */
   fun findAllAsync(): Maybe<IdentifiableList<out T>>
 
-  /**
-   * @param column
-   * @return
-   */
   fun findAll(vararg column: Column<*>): IdentifiableList<out T>
 
-  /**
-   * @param column
-   * @return
-   */
   fun findAllAsync(vararg column: Column<*>): Maybe<IdentifiableList<out T>>
 
-  /**
-   * @param column
-   * @return
-   */
   fun delete(column: Column<*>): Boolean
 
-  /**
-   * @param column
-   * @return
-   */
   fun deleteAsync(column: Column<*>): Maybe<Boolean>
 
-  /**
-   * @param t
-   * @return
-   */
   fun delete(t: T): Boolean
 
-  /**
-   * @param t
-   * @return
-   */
   fun deleteAsync(t: T): Maybe<Boolean>
 
-  /**
-   * @param column
-   * @param list
-   * @param <N>
-   * @return
-  </N> */
   fun <N> delete(column: Column<N>, list: List<out N>): Boolean
 
-  /**
-   * @param column
-   * @param list
-   * @param <C>
-   * @return
-  </C> */
   fun <C> deleteAsync(column: Column<C>, list: List<out C>): Maybe<Boolean>
 
-  /**
-   * @return
-   */
   fun clear(): Boolean
 
-  /**
-   * @return
-   */
   fun clearAsync(): Maybe<Boolean>
 
-  /**
-   * @return
-   */
   val lastId: Int
 
-  /**
-   * @return
-   */
   val lastIdAsync: Maybe<Int>
 }
\ No newline at end of file
diff --git a/database/src/main/java/promise/db/DatabaseCursorFactory.java b/database/src/main/java/promise/db/DatabaseCursorFactory.java
index ab02deb..04a258d 100644
--- a/database/src/main/java/promise/db/DatabaseCursorFactory.java
+++ b/database/src/main/java/promise/db/DatabaseCursorFactory.java
@@ -29,9 +29,7 @@ public class DatabaseCursorFactory implements SQLiteDatabase.CursorFactory {
 
   @Override
   public Cursor newCursor(SQLiteDatabase db, SQLiteCursorDriver masterQuery, String editTable, SQLiteQuery query) {
-    if (listener != null) {
-      listener.onLog(query.toString());
-    }
+    if (listener != null) listener.onLog(query.toString());
     return new SQLiteCursor(masterQuery, editTable, query);
   }
 
diff --git a/database/src/main/java/promise/db/FastDatabase.kt b/database/src/main/java/promise/db/FastDatabase.kt
index 40a67cb..d545654 100644
--- a/database/src/main/java/promise/db/FastDatabase.kt
+++ b/database/src/main/java/promise/db/FastDatabase.kt
@@ -31,31 +31,22 @@ abstract class FastDatabase internal constructor(
 
   abstract fun <T : TableCrud<*, in SQLiteDatabase>> obtain(tableClass: Class<out TableCrud<*, in SQLiteDatabase>>): T
 
-  /**
-   *
-   */
   abstract fun querySql(sql: String): Cursor
 
-  /**
-   *
-   */
   abstract fun query(queryBuilder: QueryBuilder): Cursor
 
-  /**
-   *
-   */
   abstract fun writableDatabase(): SQLiteDatabase
 
+  abstract fun transact(block: FastDatabase.() -> Unit)
+
+  abstract fun delete(vararg tableCruds: TableCrud<*, in SQLiteDatabase>): Boolean
+
+  abstract fun name(): String
+
   companion object {
     private val dbCache: ArrayMap<String, FastDatabase> = ArrayMap()
-
     private val lock = Any()
-
-    /**
-     *
-     */
     const val DEFAULT_NAME = "fast"
-
     @JvmOverloads
     @JvmStatic
     fun createDatabase(dbClass: Class<*>,
diff --git a/database/src/main/java/promise/db/FastDatabaseImpl.kt b/database/src/main/java/promise/db/FastDatabaseImpl.kt
index 8342f4b..64d1145 100644
--- a/database/src/main/java/promise/db/FastDatabaseImpl.kt
+++ b/database/src/main/java/promise/db/FastDatabaseImpl.kt
@@ -27,10 +27,6 @@ import promise.commons.util.Conditions
 import promise.model.IdentifiableList
 import java.util.*
 
-/**
- *
- */
-
 open class FastDatabaseImpl internal constructor(
     name: String?,
     factory: SQLiteDatabase.CursorFactory?,
@@ -44,12 +40,6 @@ open class FastDatabaseImpl internal constructor(
 
   private var databaseCreationCallback: DatabaseCreationCallback? = null
 
-  /**
-   * @param name
-   * @param version
-   * @param cursorListener
-   * @param listener
-   */
   @TargetApi(Build.VERSION_CODES.HONEYCOMB)
   private constructor(name: String?,
                       version: Int,
@@ -65,9 +55,6 @@ open class FastDatabaseImpl internal constructor(
 
   constructor(name: String?, version: Int) : this(name, version, null, null)
 
-  /**
-   * @param db
-   */
   final override fun onCreate(db: SQLiteDatabase) {
     if (databaseCreationCallback != null) {
       databaseCreationCallback!!.beforeCreate(db)
@@ -76,11 +63,6 @@ open class FastDatabaseImpl internal constructor(
     } else create(db)
   }
 
-  /**
-   * @param database
-   * @param oldVersion
-   * @param newVersion
-   */
   final override fun onUpgrade(database: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
     LogUtil.d(TAG, "onUpgrade", oldVersion, newVersion)
     if (newVersion - oldVersion == 1)
@@ -95,33 +77,18 @@ open class FastDatabaseImpl internal constructor(
     upgradeTables(database, oldVersion, newVersion)
   }
 
-  /**
-   * @param database
-   * @param oldVersion
-   * @param newVersion
-   * @return
-   */
   private fun onUpgradeDatabase(database: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
     if (migration != null) migration!!.onMigrate(this, database, oldVersion, newVersion)
   }
 
-  /**
-   * @return
-   */
-  fun name(): String = this.databaseName
+  override fun name(): String = this.databaseName
 
   private var tables: List<out FastTable<*>>? = null
 
-  /**
-   * @return
-   */
   protected fun tables(): List<TableCrud<*, in SQLiteDatabase>> =
       Conditions.checkNotNull(tables, "tables not found for this database")
           as List<TableCrud<*, in SQLiteDatabase>>
 
-  /**
-   *
-   */
   override fun <T : TableCrud<*, in SQLiteDatabase>> obtain(tableClass: Class<out TableCrud<*, in SQLiteDatabase>>): T {
     fun <T : TableCrud<*, in SQLiteDatabase>> makeTable(tableClass: Class<out TableCrud<*, in SQLiteDatabase>>): T {
       if (ClassUtil.hasAnnotation(tableClass, Table::class.java)) {
@@ -157,9 +124,6 @@ open class FastDatabaseImpl internal constructor(
     return this
   }
 
-  /**
-   * @param database
-   */
   private fun create(database: SQLiteDatabase) {
     var created = true
     for (table in Conditions.checkNotNull(tables())) created = try {
@@ -170,11 +134,6 @@ open class FastDatabaseImpl internal constructor(
     }
   }
 
-  /**
-   * @param database
-   * @param v1
-   * @param v2
-   */
   private fun upgradeTables(database: SQLiteDatabase, v1: Int, v2: Int) {
     for (table in Conditions.checkNotNull(tables())) try {
       if (v2 - v1 == 1)
@@ -191,11 +150,6 @@ open class FastDatabaseImpl internal constructor(
     }
   }
 
-  /**
-   * @param database
-   * @param tables
-   * @return
-   */
   @SafeVarargs
   override fun add(database: SQLiteDatabase, vararg tables: TableCrud<*, in SQLiteDatabase>): Boolean {
     var created = true
@@ -210,10 +164,6 @@ open class FastDatabaseImpl internal constructor(
     return created
   }
 
-  /**
-   * @param database
-   * @return
-   */
   private fun drop(database: SQLiteDatabase): Boolean {
     /*for (Map.Entry<IndexCreated, Table<, SQLiteDatabase>> entry :
         indexCreatedTableHashMap.entrySet()) {
@@ -226,12 +176,6 @@ open class FastDatabaseImpl internal constructor(
     }*/return true
   }
 
-  /**
-   * @param tableCrud
-   * @param database
-   * @return
-   * @throws DBError
-   */
   @Throws(DBError::class)
   private fun create(tableCrud: TableCrud<*, in SQLiteDatabase>, database: SQLiteDatabase): Boolean {
     try {
@@ -242,12 +186,6 @@ open class FastDatabaseImpl internal constructor(
     return true
   }
 
-  /**
-   * @param tableCrud
-   * @param database
-   * @return
-   * @throws DBError
-   */
   @Throws(DBError::class)
   private fun drop(tableCrud: TableCrud<*, in SQLiteDatabase>, database: SQLiteDatabase): Boolean {
     try {
@@ -258,19 +196,13 @@ open class FastDatabaseImpl internal constructor(
     return true
   }
 
-  override fun writableDatabase(): SQLiteDatabase {
-    return writableDatabase
-  }
+  override fun writableDatabase(): SQLiteDatabase = writableDatabase
 
   override fun querySql(sql: String): Cursor {
     LogUtil.d(TAG, "query: $sql")
     return readableDatabase.rawQuery(sql, null)
   }
 
-  /**
-   * @param queryBuilder
-   * @return
-   */
   override fun query(queryBuilder: QueryBuilder): Cursor {
     val sql = queryBuilder.build()
     val params = queryBuilder.buildParameters()
@@ -278,38 +210,15 @@ open class FastDatabaseImpl internal constructor(
     return readableDatabase.rawQuery(sql, params)
   }
 
-  /**
-   * @param tableCrud
-   * @param <T>
-   * @return
-  </T> */
   override fun <T : Identifiable<Int>> find(tableCrud: TableCrud<T, in SQLiteDatabase>): TableCrud.Extras<T> =
       checkTableExist(tableCrud).onFind(readableDatabase)
 
-  /**
-   * @param tableCrud
-   * @param <T>
-   * @return
-  </T> */
   override fun <T : Identifiable<Int>> findAll(tableCrud: TableCrud<T, in SQLiteDatabase>): IdentifiableList<out T> =
       checkTableExist(tableCrud).onFindAll(readableDatabase, true)
 
-  /**
-   * @param t
-   * @param tableCrud
-   * @param <T>
-   * @return
-  </T> */
   override fun <T : Identifiable<Int>> update(t: T, tableCrud: TableCrud<T, in SQLiteDatabase>): Boolean =
       checkTableExist(tableCrud).onUpdate(t, writableDatabase)
 
-  /**
-   * @param t
-   * @param tableCrud
-   * @param column
-   * @param <T>
-   * @return
-  </T> */
   override fun <T : Identifiable<Int>> update(t: T, tableCrud: TableCrud<T, in SQLiteDatabase>, column: Column<*>): Boolean =
       try {
         checkTableExist(tableCrud).onUpdate(t, writableDatabase, column)
@@ -318,82 +227,36 @@ open class FastDatabaseImpl internal constructor(
         false
       }
 
-  /**
-   * @param tableCrud
-   * @param columns
-   * @param <T>
-   * @return
-  </T> */
   override fun <T : Identifiable<Int>> findAll(tableCrud: TableCrud<T, in SQLiteDatabase>,
                                                vararg columns: Column<*>): IdentifiableList<out T> =
       checkTableExist(tableCrud).onFindAll(readableDatabase, *columns)
 
-  /**
-   * @param tableCrud
-   * @param t
-   * @param <T>
-   * @return
-  </T> */
   override fun <T : Identifiable<Int>> delete(tableCrud: TableCrud<T, in SQLiteDatabase>, t: T): Boolean =
       checkTableExist(tableCrud).onDelete(t, writableDatabase)
 
-  /**
-   * @param tableCrud
-   * @param column
-   * @return
-   */
   override fun delete(tableCrud: TableCrud<*, in SQLiteDatabase>, column: Column<*>): Boolean =
       checkTableExist(tableCrud).onDelete(writableDatabase, column)
 
-  /**
-   * @param tableCrud
-   * @return
-   */
   override fun delete(tableCrud: TableCrud<*, in SQLiteDatabase>): Boolean =
       checkTableExist(tableCrud).onDelete(writableDatabase)
 
-  /**
-   * @param tableCruds
-   * @return
-   */
   @SafeVarargs
-  fun delete(vararg tableCruds: TableCrud<*, in SQLiteDatabase>): Boolean {
+ override fun delete(vararg tableCruds: TableCrud<*, in SQLiteDatabase>): Boolean {
     var delete = true
     for (table in tableCruds) delete = delete && delete(table)
     return delete
   }
 
-  /**
-   * @param tableCrud
-   * @param column
-   * @param list
-   * @param <T>
-   * @return
-  </T> */
   override fun <T> delete(tableCrud: TableCrud<*, in SQLiteDatabase>, column: Column<T>, list: List<out T>): Boolean =
       checkTableExist(tableCrud).onDelete(writableDatabase, column, list)
 
-  /**
-   * @param t
-   * @param tableCrud
-   * @param <T>
-   * @return
-  </T> */
   override fun <T : Identifiable<Int>> save(t: T, tableCrud: TableCrud<T, in SQLiteDatabase>): Long =
       checkTableExist(tableCrud).onSave(t, writableDatabase)
 
-  /**
-   * @param list
-   * @param tableCrud
-   * @param <T>
-   * @return
-  </T> */
   override fun <T : Identifiable<Int>> save(list: IdentifiableList<out T>, tableCrud: TableCrud<T, in SQLiteDatabase>): Boolean =
       checkTableExist(tableCrud).onSave(list, writableDatabase)
 
-  /**
-   * @return
-   */
+
   override fun deleteAll(): Boolean = synchronized(FastDatabaseImpl::class.java) {
     var deleted = true
     try {
@@ -407,14 +270,10 @@ open class FastDatabaseImpl internal constructor(
     return deleted
   }
 
-  /**
-   * @param tableCrud
-   * @return
-   */
   override fun getLastId(tableCrud: TableCrud<*, in SQLiteDatabase>): Int =
       checkTableExist(tableCrud).onGetLastId(readableDatabase)
 
-  inline fun transact(block: FastDatabaseImpl.() -> Unit) = synchronized(this) {
+  override fun transact(block: FastDatabase.() -> Unit) = synchronized(this) {
     val db = writableDatabase
     try {
       db.beginTransaction()
@@ -425,11 +284,6 @@ open class FastDatabaseImpl internal constructor(
     }
   }
 
-  /**
-   * @param tableCrud
-   * @param <T>
-   * @return
-  </T> */
   private fun <T : Identifiable<Int>> checkTableExist(tableCrud: TableCrud<T, in SQLiteDatabase>): TableCrud<T, in SQLiteDatabase> =
       Conditions.checkNotNull(tableCrud)
 
diff --git a/database/src/main/java/promise/db/FastTable.kt b/database/src/main/java/promise/db/FastTable.kt
index 42aa8da..fd6d4c2 100644
--- a/database/src/main/java/promise/db/FastTable.kt
+++ b/database/src/main/java/promise/db/FastTable.kt
@@ -28,7 +28,7 @@ import promise.commons.model.List.fromArray
 import promise.commons.util.Conditions
 import promise.commons.util.DoubleConverter
 import promise.db.criteria.Criteria
-import promise.db.model.ITimeStamped
+import promise.model.ITimeStamped
 import promise.db.projection.Projection
 import promise.model.IdentifiableList
 import java.util.*
@@ -46,10 +46,9 @@ abstract class FastTable<T : Identifiable<Int>>
 /**
  * @param database
  */(
-    /**
-     *
-     */
+
     val database: FastDatabase) : TableCrud<T, SQLiteDatabase>, DMLFunctions<T> {
+
   companion object {
     /**
      * The create prefix in a prefix for queries that create a table structure
@@ -512,7 +511,7 @@ abstract class FastTable<T : Identifiable<Int>>
   /**
    *
    */
-  inline fun transact(block: FastTable<T>.() -> Unit) = synchronized(this) {
+  override fun transact(block: FastTable<T>.() -> Unit) = synchronized(this) {
     val db = database.writableDatabase
     try {
       db.beginTransaction()
diff --git a/database/src/main/java/promise/db/ReactiveCrud.kt b/database/src/main/java/promise/db/ReactiveCrud.kt
index 82b5f24..c228206 100644
--- a/database/src/main/java/promise/db/ReactiveCrud.kt
+++ b/database/src/main/java/promise/db/ReactiveCrud.kt
@@ -19,76 +19,34 @@ import promise.commons.model.Identifiable
 import promise.commons.model.List
 import promise.model.IdentifiableList
 
-/**
- *
- */
 interface ReactiveCrud<X> : Crud<X> {
 
   fun queryAsync(queryBuilder: QueryBuilder): Single<Cursor>
 
-  /**
-   *
-   */
   @Throws(TableError::class)
   fun <T : Identifiable<Int>> readAsync(tableCrud: TableCrud<T, in X>): ReactiveTable.Extras<T>
 
-  /**
-   *
-   */
   fun <T : Identifiable<Int>> readAllAsync(tableCrud: TableCrud<T, in X>): Maybe<IdentifiableList<out T>>
 
-  /**
-   *
-   */
   fun <T : Identifiable<Int>> readAllAsync(tableCrud: TableCrud<T, in X>, vararg column: Column<*>): Maybe<IdentifiableList<out T>>
 
-  /**
-   *
-   */
   fun <T : Identifiable<Int>> updateAsync(t: T, tableCrud: TableCrud<T, in X>, column: Column<*>): Maybe<Boolean>
 
-  /**
-   *
-   */
   fun <T : Identifiable<Int>> updateAsync(t: T, tableCrud: TableCrud<T, in X>): Maybe<Boolean>
 
-  /**
-   *
-   */
   fun <T : Identifiable<Int>> deleteAsync(tableCrud: TableCrud<T, in X>, column: Column<*>): Maybe<Boolean>
 
-  /**
-   *
-   */
   fun <T : Identifiable<Int>> deleteAsync(tableCrud: TableCrud<T, in X>, t: T): Maybe<Boolean>
 
-  /**
-   *
-   */
   fun deleteAsync(tableCrud: TableCrud<*, in X>): Maybe<Boolean>
 
-  /**
-   *
-   */
   fun <C> deleteAsync(tableCrud: TableCrud<*, in X>, column: Column<C>, list: List<out C>): Maybe<Boolean>
 
-  /**
-   *
-   */
   fun <T : Identifiable<Int>> saveAsync(t: T, tableCrud: TableCrud<T, in X>): Single<Long>
 
-  /**
-   *
-   */
   fun <T : Identifiable<Int>> saveAsync(list: IdentifiableList<out T>, tableCrud: TableCrud<T, in X>): Single<Boolean>
 
-  /**
-   *
-   */
   fun deleteAllAsync(): Maybe<Boolean>
 
-  /**
-   *
-   */
   fun <T : Identifiable<Int>> getLastIdAsync(tableCrud: TableCrud<T, in X>): Maybe<Int>
 }
\ No newline at end of file
diff --git a/database/src/main/java/promise/db/ReactiveFastDatabase.kt b/database/src/main/java/promise/db/ReactiveFastDatabase.kt
index 37349ce..2f34735 100644
--- a/database/src/main/java/promise/db/ReactiveFastDatabase.kt
+++ b/database/src/main/java/promise/db/ReactiveFastDatabase.kt
@@ -20,16 +20,11 @@ import android.database.sqlite.SQLiteDatabase
 import android.os.Build
 import io.reactivex.Maybe
 import io.reactivex.Single
-import promise.commons.data.log.LogUtil
 import promise.commons.model.Identifiable
 import promise.commons.model.List
 import promise.commons.util.DoubleConverter
 import promise.model.IdentifiableList
 
-/**
- *
- */
-
 class ReactiveFastDatabase private constructor(
     name: String?,
     factory: SQLiteDatabase.CursorFactory?,
@@ -37,14 +32,7 @@ class ReactiveFastDatabase private constructor(
     errorHandler: DatabaseErrorHandler) :
     FastDatabaseImpl(name, factory, version, errorHandler),
     ReactiveCrud<SQLiteDatabase> {
-  private val TAG: String = LogUtil.makeTag(ReactiveFastDatabase::class.java)
-
-  /**
-   * @param name
-   * @param version
-   * @param cursorListener
-   * @param listener
-   */
+
   @TargetApi(Build.VERSION_CODES.HONEYCOMB)
   internal constructor(name: String?, version: Int, cursorListener: DatabaseCursorFactory.Listener?, listener: Corrupt?) : this(
       name,
@@ -55,35 +43,16 @@ class ReactiveFastDatabase private constructor(
         listener!!.onCorrupt()
       })
 
-  /**
-   * @param version
-   */
   internal constructor(version: Int) : this(DEFAULT_NAME, version)
 
   constructor(name: String?, version: Int) : this(name, version, null, null)
 
-
-  /**
-   * @param tableCrud
-   * @param database
-   * @param <T>
-   * @return
-  </T> */
   private fun <T : Identifiable<Int>> dropAsync(tableCrud: TableCrud<T, in SQLiteDatabase>,
                                                 database: SQLiteDatabase): Single<Boolean> =
       Single.fromCallable { tableCrud.onDrop(database) }
 
-  /**
-   * @param queryBuilder
-   * @return
-   */
   override fun queryAsync(queryBuilder: QueryBuilder): Single<Cursor> = Single.fromCallable { query(queryBuilder) }
 
-  /**
-   * @param tableCrud
-   * @param <T>
-   * @return
-  </T> */
   @Throws(TableError::class)
   override fun <T : Identifiable<Int>> readAsync(tableCrud: TableCrud<T, in SQLiteDatabase>): ReactiveTable.Extras<T> =
       object : QueryExtras<T>(tableCrud, readableDatabase) {
@@ -91,101 +60,38 @@ class ReactiveFastDatabase private constructor(
         override fun deserialize(e: Cursor): T = tableCrud.deserialize(e)
       }
 
-
-  /**
-   * @param tableCrud
-   * @param <T>
-   * @return
-  </T> */
   override fun <T : Identifiable<Int>> readAllAsync(tableCrud: TableCrud<T, in SQLiteDatabase>): Maybe<IdentifiableList<out T>> =
       Maybe.fromCallable { findAll(tableCrud) }
 
-  /**
-   * @param tableCrud
-   * @param column
-   * @param <T>
-   * @return
-  </T> */
   override fun <T : Identifiable<Int>> readAllAsync(tableCrud: TableCrud<T, in SQLiteDatabase>, vararg column: Column<*>): Maybe<IdentifiableList<out T>> =
       Maybe.fromCallable { tableCrud.onFindAll(readableDatabase, *column) }
 
-  /**
-   * @param t
-   * @param tableCrud
-   * @param column
-   * @param <T>
-   * @return
-  </T> */
   override fun <T : Identifiable<Int>> updateAsync(t: T, tableCrud: TableCrud<T, in SQLiteDatabase>, column: Column<*>): Maybe<Boolean> =
       Maybe.fromCallable { tableCrud.onUpdate(t, writableDatabase, column) }
 
-  /**
-   * @param t
-   * @param tableCrud
-   * @param <T>
-   * @return
-  </T> */
   override fun <T : Identifiable<Int>> updateAsync(t: T, tableCrud: TableCrud<T, in SQLiteDatabase>): Maybe<Boolean> =
       Maybe.fromCallable { tableCrud.onUpdate(t, writableDatabase) }
 
-  /**
-   * @param tableCrud
-   * @param column
-   * @param <T>
-   * @return
-  </T> */
   override fun <T : Identifiable<Int>> deleteAsync(tableCrud: TableCrud<T, in SQLiteDatabase>, column: Column<*>): Maybe<Boolean> =
       Maybe.fromCallable { tableCrud.onDelete(writableDatabase, column) }
 
-  /**
-   * @param tableCrud
-   * @param t
-   * @param <T>
-   * @return
-  </T> */
   override fun <T : Identifiable<Int>> deleteAsync(tableCrud: TableCrud<T, in SQLiteDatabase>, t: T): Maybe<Boolean> =
       Maybe.fromCallable { tableCrud.onDelete(t, writableDatabase) }
 
-  /**
-   * @param tableCrud
-   * @return
-   */
   override fun deleteAsync(tableCrud: TableCrud<*, in SQLiteDatabase>): Maybe<Boolean> =
       Maybe.fromCallable { tableCrud.onDelete(writableDatabase) }
 
-  /**
-   * @param tableCrud
-   * @param column
-   * @param list
-   * @param <C>
-   * @return
-  </C> */
   override fun <C> deleteAsync(tableCrud: TableCrud<*, in SQLiteDatabase>,
                                column: Column<C>,
                                list: List<out C>): Maybe<Boolean> =
       Maybe.fromCallable { tableCrud.onDelete(writableDatabase, column, list) }
 
-  /**
-   * @param t
-   * @param tableCrud
-   * @param <T>
-   * @return
-  </T> */
   override fun <T : Identifiable<Int>> saveAsync(t: T, tableCrud: TableCrud<T, in SQLiteDatabase>): Single<Long> =
       Single.fromCallable { tableCrud.onSave(t, writableDatabase) }
 
-  /**
-   * @param list
-   * @param tableCrud
-   * @param <T>
-   * @return
-  </T> */
   override fun <T : Identifiable<Int>> saveAsync(list: IdentifiableList<out T>, tableCrud: TableCrud<T, in SQLiteDatabase>): Single<Boolean> =
       Single.fromCallable { tableCrud.onSave(list, writableDatabase) }
 
-  /**
-   * @return
-   */
   override fun deleteAllAsync(): Maybe<Boolean> =
       Maybe.zip(tables().map { tableCrud: TableCrud<*, in SQLiteDatabase> -> this.deleteAsync(tableCrud) }
       ) { objects: Array<Any> ->
@@ -194,121 +100,50 @@ class ReactiveFastDatabase private constructor(
         }
       }
 
-  /**
-   * @param tableCrud
-   * @param <T>
-   * @return
-  </T> */
   override fun <T : Identifiable<Int>> getLastIdAsync(tableCrud: TableCrud<T, in SQLiteDatabase>): Maybe<Int> =
       Maybe.fromCallable { tableCrud.onGetLastId(readableDatabase) }
 
-  /**
-   * @param <T>
-  </T> */
   private abstract inner class QueryExtras<T : Identifiable<Int>> internal constructor(private val tableCrud: TableCrud<T, in SQLiteDatabase>,
                                                                                        private val database: SQLiteDatabase) :
       ReactiveTable.Extras<T>, DoubleConverter<T, Cursor, ContentValues> {
-    /**
-     * @return
-     */
+
     override fun first(): Maybe<T> = Maybe.fromCallable { tableCrud.onFind(database).first() }
 
-    /**
-     * @return
-     */
     override fun last(): Maybe<T> = Maybe.fromCallable { tableCrud.onFind(database).last() }
 
-    /**
-     * @return
-     */
     override fun all(): Maybe<IdentifiableList<out T>> =
         Maybe.fromCallable { tableCrud.onFind(database).all() }
 
-    /**
-     * @param limit
-     * @return
-     */
     override fun limit(limit: Int): Maybe<IdentifiableList<out T>> =
         Maybe.fromCallable { tableCrud.onFind(database).limit(limit) }
 
-    /**
-     * @param skip
-     * @param limit
-     * @return
-     */
     override fun paginate(skip: Int, limit: Int): Maybe<IdentifiableList<out T>> =
         Maybe.fromCallable { tableCrud.onFind(database).paginate(skip, limit) }
 
-    /**
-     * @param skip
-     * @param limit
-     * @return
-     */
     override fun paginateDescending(skip: Int, limit: Int): Maybe<IdentifiableList<out T>> =
         Maybe.fromCallable { tableCrud.onFind(database).paginateDescending(skip, limit) }
 
-    /**
-     * @param column
-     * @param a
-     * @param b
-     * @return
-     */
     override fun between(column: Column<Number>, a: Number, b: Number): Maybe<IdentifiableList<out T>> =
         Maybe.fromCallable { tableCrud.onFind(database).between(column, a, b) }
 
-    /**
-     * @param column
-     * @return
-     */
     override fun where(vararg column: Column<*>): Maybe<IdentifiableList<out T>> =
         Maybe.fromCallable { tableCrud.onFind(database).where(*column) }
 
-    /**
-     * @param column
-     * @param bounds
-     * @return
-     */
     @SafeVarargs
     override fun notIn(column: Column<Number>, vararg bounds: Number): Maybe<IdentifiableList<out T>> =
         Maybe.fromCallable { tableCrud.onFind(database).notIn(column, *bounds) }
 
-    /**
-     * @param column
-     * @return
-     */
     override fun like(vararg column: Column<String>): Maybe<IdentifiableList<out T>> =
         Maybe.fromCallable { tableCrud.onFind(database).like(*column) }
 
-    /**
-     * @param column
-     * @return
-     */
     override fun orderBy(column: Column<*>): Maybe<IdentifiableList<out T>> =
         Maybe.fromCallable { tableCrud.onFind(database).orderBy(column) }
 
-    /**
-     * @param column
-     * @return
-     */
     override fun groupBy(column: Column<*>): Maybe<IdentifiableList<out T>> =
         Maybe.fromCallable { tableCrud.onFind(database).groupBy(column) }
 
-    /**
-     * @param column
-     * @param column1
-     * @return
-     */
     override fun groupAndOrderBy(column: Column<*>, column1: Column<*>): Maybe<IdentifiableList<out T>> =
         Maybe.fromCallable { tableCrud.onFind(database).groupAndOrderBy(column, column1) }
   }
 
-  /**
-   * @param name
-   * @param factory
-   * @param version
-   * @param errorHandler
-   */
-  init {
-    LogUtil.d(TAG, "fast db init")
-  }
 }
\ No newline at end of file
diff --git a/database/src/main/java/promise/db/Store.java b/database/src/main/java/promise/db/Store.java
index 78195ee..49fab0e 100644
--- a/database/src/main/java/promise/db/Store.java
+++ b/database/src/main/java/promise/db/Store.java
@@ -13,116 +13,59 @@
 
 package promise.db;
 
-
-import androidx.annotation.Nullable;
+import org.jetbrains.annotations.Nullable;
 
 import promise.commons.model.List;
 import promise.commons.tx.PromiseResult;
 
-/**
- * @param <T>
- * @param <K>
- * @param <X>
- */
 public interface Store<T, K, X extends Throwable> {
 
-  /**
-   * @param k
-   * @param callBack
-   */
   void get(K k, PromiseResult<StoreExtra<T>, X> callBack);
 
-  /**
-   * @param k
-   * @param t
-   * @param callBack
-   */
   void delete(K k, T t, PromiseResult<Boolean, X> callBack);
 
-  /**
-   * @param k
-   * @param t
-   * @param callBack
-   */
   void update(K k, T t, PromiseResult<Boolean, X> callBack);
 
-  /**
-   * @param k
-   * @param t
-   * @param callBack
-   */
   void save(K k, T t, PromiseResult<Boolean, X> callBack);
 
-  /**
-   * @param k
-   * @param callBack
-   */
   void clear(K k, PromiseResult<Boolean, X> callBack);
 
-  /**
-   * @param callBack
-   */
   void clear(PromiseResult<Boolean, X> callBack);
 
   interface StoreFilter<T> {
     <X> List<? extends T> filter(List<? extends T> list, X... x);
   }
 
-  /**
-   * @param <T>
-   */
   abstract class StoreExtra<T> {
 
-    /**
-     * @param list
-     * @param callBack
-     * @param <E>
-     */
     static <T, E extends Throwable> void getExtras(final List<? extends T> list,
                                                    StoreFilter<T> storeFilter,
                                                    PromiseResult<StoreExtra<T>, E> callBack) {
       callBack.response(
           new StoreExtra<T>() {
-            /**
-             * @return
-             */
+
             @Nullable
             @Override
             public T first() {
               return list.first();
             }
 
-            /**
-             * @return
-             */
             @Nullable
             @Override
             public T last() {
               return list.last();
             }
 
-            /**
-             * @return
-             */
             @Override
             public List<? extends T> all() {
               return list;
             }
 
-            /**
-             * @param limit
-             * @return
-             */
             @Override
             public List<? extends T> limit(int limit) {
               return list.take(limit);
             }
 
-            /**
-             * @param x
-             * @param <X>
-             * @return
-             */
             @SafeVarargs
             @Override
             public final <X> List<? extends T> where(X... x) {
@@ -131,34 +74,16 @@ public final <X> List<? extends T> where(X... x) {
           });
     }
 
-    /**
-     * @return
-     */
     @Nullable
     abstract T first();
 
-    /**
-     * @return
-     */
     abstract @Nullable
     T last();
 
-    /**
-     * @return
-     */
     abstract List<? extends T> all();
 
-    /**
-     * @param limit
-     * @return
-     */
     abstract List<? extends T> limit(int limit);
 
-    /**
-     * @param x
-     * @param <X>
-     * @return
-     */
     abstract <X> List<? extends T> where(X... x);
   }
 
diff --git a/database/src/main/java/promise/db/Utils.java b/database/src/main/java/promise/db/Utils.java
index d8916fd..715d007 100644
--- a/database/src/main/java/promise/db/Utils.java
+++ b/database/src/main/java/promise/db/Utils.java
@@ -34,34 +34,6 @@ else if (value instanceof Double)
     else
       return String.valueOf(value);
   }
-	
-	/*public static String dateToString(LocalDate date, DateTimeFormatter format) {
-		if (date == null)
-			return null;
-		
-		if(format == null)
-			format = QueryBuildConfiguration.current().getDateFormat();
-
-		try {
-			return date.toString(format);
-		} catch (Exception e) {
-			return null;
-		}
-	}
-
-	public static String dateToString(LocalDateTime date, DateTimeFormatter format) {
-		if (date == null)
-			return null;
-
-		if(format == null)
-			format = QueryBuildConfiguration.current().getDateTimeFormat();
-		
-		try {
-			return date.toString(format);
-		} catch (Exception e) {
-			return null;
-		}
-	}*/
 
   public static boolean isNullOrEmpty(String string) {
     return (string == null || string.length() <= 0);
@@ -71,12 +43,9 @@ public static boolean isNullOrWhiteSpace(String string) {
     return (string == null || string.trim().length() <= 0);
   }
 
-  public static Projection[] buildColumnProjections(Column... columns) {
+  static Projection[] buildColumnProjections(Column... columns) {
     Projection[] projections = new Projection[columns.length];
-
-    for (int i = 0; i < columns.length; i++) {
-      projections[i] = Projection.column(columns[i]);
-    }
+    for (int i = 0; i < columns.length; i++) projections[i] = Projection.column(columns[i]);
     return projections;
   }
 }
diff --git a/commons/src/main/java/promise/db/model/ITimeStamped.java b/database/src/main/java/promise/model/ITimeStamped.java
similarity index 96%
rename from commons/src/main/java/promise/db/model/ITimeStamped.java
rename to database/src/main/java/promise/model/ITimeStamped.java
index 394dd89..3b07257 100644
--- a/commons/src/main/java/promise/db/model/ITimeStamped.java
+++ b/database/src/main/java/promise/model/ITimeStamped.java
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db.model;
+package promise.model;
 
 public interface ITimeStamped {
 
diff --git a/database/src/main/java/promise/model/IdentifiableList.java b/database/src/main/java/promise/model/IdentifiableList.java
index ce3561f..1957753 100644
--- a/database/src/main/java/promise/model/IdentifiableList.java
+++ b/database/src/main/java/promise/model/IdentifiableList.java
@@ -70,32 +70,26 @@ public boolean removeWithID(int id) {
   }
 
   public boolean remove(T t) {
-    if (t instanceof ActiveRecord<?>) {
-      try {
-        ((ActiveRecord) t).delete();
-      } catch (Exception ignored) {
-      }
+    if (t instanceof ActiveRecord<?>) try {
+      ((ActiveRecord) t).delete();
+    } catch (Exception ignored) {
     }
     super.remove(getIndex(t));
     return true;
   }
 
   public void delete(T t) {
-    if (t instanceof ActiveRecord<?>) {
-      try {
-        ((ActiveRecord) t).delete();
-      } catch (Exception ignored) {
-      }
+    if (t instanceof ActiveRecord<?>) try {
+      ((ActiveRecord) t).delete();
+    } catch (Exception ignored) {
     }
     removeWithID(t.getId());
   }
 
   public void update(T t) {
-    if (t instanceof ActiveRecord<?>) {
-      try {
-        ((ActiveRecord) t).update();
-      } catch (Exception ignored) {
-      }
+    if (t instanceof ActiveRecord<?>) try {
+      ((ActiveRecord) t).update();
+    } catch (Exception ignored) {
     }
     super.set(getIndex(t), t);
   }
diff --git a/database/src/main/java/promise/model/TimeStamped.java b/database/src/main/java/promise/model/TimeStamped.java
index 9beb7dd..d7f3cbd 100644
--- a/database/src/main/java/promise/model/TimeStamped.java
+++ b/database/src/main/java/promise/model/TimeStamped.java
@@ -17,7 +17,6 @@
 import android.os.Parcelable;
 
 import promise.commons.model.Identifiable;
-import promise.db.model.ITimeStamped;
 
 public abstract class TimeStamped implements Identifiable<Integer>, ITimeStamped, Parcelable {
   private int id = 0;
diff --git a/gradle.properties b/gradle.properties
index e8e4bfb..744620d 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -22,7 +22,9 @@
 android.enableJetifier=true
 android.useAndroidX=true
 org.gradle.jvmargs=-Xmx1536m
-kapt.use.worker.api=true
+
+POM_LICENCE_URL=https\://opensource.org/licenses/MIT
+POM_LICENCE_NAME=The MIT License (MIT)
 
 # org.gradle.daemon=false
 # org.gradle.debug=true
diff --git a/settings.gradle b/settings.gradle
index fab9741..39294d0 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -12,8 +12,8 @@
  */
 
 
-include  'app'
-include 'database'
+include  ':app'
+include ':database'
 include ':compiler'
 include ':commons'
 

From 346ccfb6610814599cfdb2e082836d13fb6c8f6f Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Fri, 7 Aug 2020 17:01:04 +0300
Subject: [PATCH 13/34] removed proguard in project

---
 commons/src/main/java/promise/db/Table.java   | 47 -------------------
 commons/src/main/java/promise/db/Table.kt     | 35 ++++++++++++++
 .../main/java/promise/db/FastDatabaseImpl.kt  |  1 +
 .../src/main/java/promise/db/FastTable.kt     |  8 ++--
 4 files changed, 40 insertions(+), 51 deletions(-)
 delete mode 100644 commons/src/main/java/promise/db/Table.java
 create mode 100644 commons/src/main/java/promise/db/Table.kt

diff --git a/commons/src/main/java/promise/db/Table.java b/commons/src/main/java/promise/db/Table.java
deleted file mode 100644
index f799b05..0000000
--- a/commons/src/main/java/promise/db/Table.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Copyright 2017, Peter Vincent
- * Licensed under the Apache License, Version 2.0, Android Promise.
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package promise.db;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-@Target(ElementType.TYPE)
-@Retention(RetentionPolicy.RUNTIME)
-public @interface Table {
-  String tableName();
-  Index[] indices() default {};
-  CompoundIndex[] compoundIndexes() default {};
-  ForeignKey[] foreignKeys() default {};
-  @Target(ElementType.TYPE)
-  @Retention(RetentionPolicy.RUNTIME)
-  @interface Index {
-    String columnName();
-  }
-  @Target(ElementType.TYPE)
-  @Retention(RetentionPolicy.RUNTIME)
-  @interface CompoundIndex {
-    boolean unique() default false;
-    Index[] indexes() default {};
-  }
-
-  @Target(ElementType.TYPE)
-  @Retention(RetentionPolicy.RUNTIME)
-  @interface ForeignKey {
-    String columnName();
-    String referencedTableName();
-    String referencedColumnName();
-  }
-}
diff --git a/commons/src/main/java/promise/db/Table.kt b/commons/src/main/java/promise/db/Table.kt
new file mode 100644
index 0000000..8431799
--- /dev/null
+++ b/commons/src/main/java/promise/db/Table.kt
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package promise.db
+
+@Target(AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.RUNTIME)
+annotation class Table(val tableName: String,
+                       val indices: Array<Index> = [],
+                       val compoundIndexes: Array<CompoundIndex> = [],
+                       val foreignKeys: Array<ForeignKey> = []) {
+  @Target(AnnotationTarget.ANNOTATION_CLASS, AnnotationTarget.CLASS)
+  @Retention(AnnotationRetention.RUNTIME)
+  annotation class Index(val columnName: String)
+
+  @Target(AnnotationTarget.ANNOTATION_CLASS, AnnotationTarget.CLASS)
+  @Retention(AnnotationRetention.RUNTIME)
+  annotation class CompoundIndex(val unique: Boolean = false,
+                                 val indexes: Array<Index> = [])
+
+  @Target(AnnotationTarget.ANNOTATION_CLASS, AnnotationTarget.CLASS)
+  @Retention(AnnotationRetention.RUNTIME)
+  annotation class ForeignKey(val columnName: String,
+                              val referencedTableName: String,
+                              val referencedColumnName: String)
+}
\ No newline at end of file
diff --git a/database/src/main/java/promise/db/FastDatabaseImpl.kt b/database/src/main/java/promise/db/FastDatabaseImpl.kt
index 64d1145..76cd186 100644
--- a/database/src/main/java/promise/db/FastDatabaseImpl.kt
+++ b/database/src/main/java/promise/db/FastDatabaseImpl.kt
@@ -26,6 +26,7 @@ import promise.commons.util.ClassUtil
 import promise.commons.util.Conditions
 import promise.model.IdentifiableList
 import java.util.*
+import promise.db.Table
 
 open class FastDatabaseImpl internal constructor(
     name: String?,
diff --git a/database/src/main/java/promise/db/FastTable.kt b/database/src/main/java/promise/db/FastTable.kt
index fd6d4c2..2896a3c 100644
--- a/database/src/main/java/promise/db/FastTable.kt
+++ b/database/src/main/java/promise/db/FastTable.kt
@@ -166,7 +166,7 @@ abstract class FastTable<T : Identifiable<Int>>
     var columnNames = ""
     var indexSql = "("
     val indexes = compoundIndex.indexes
-    indexes.forEachIndexed { i, index ->
+    indexes.forEachIndexed { i: Int, index: Table.Index ->
       columnNames = if (i == indexes.size - 1) columnNames + index.columnName else "$columnNames${index.columnName}_"
       indexSql = if (i == indexes.size - 1) indexSql + index.columnName else "$indexSql${index.columnName}, "
     }
@@ -176,7 +176,7 @@ abstract class FastTable<T : Identifiable<Int>>
     } else "CREATE INDEX IF NOT EXISTS idx_$columnNames ON $nameOfTable $indexSql"
   }
 
-  private fun generateIndexQuery(index: Table.Index): String {
+  private fun generateIndexQueryForTableIndex(index: Table.Index): String {
     val indexSql = "(${index.columnName});"
     return "CREATE INDEX IF NOT EXISTS idx_${index.columnName} ON $nameOfTable $indexSql"
   }
@@ -296,14 +296,14 @@ abstract class FastTable<T : Identifiable<Int>>
 
   private fun addIndices(database: SQLiteDatabase, indexes: Array<Table.Index>) {
     indexes.forEach {
-      val indexSql = generateIndexQuery(it)
+      val indexSql = generateIndexQueryForTableIndex(it)
       LogUtil.d(TAG, indexSql)
       database.execSQL(indexSql)
     }
   }
 
   fun addIndex(database: SQLiteDatabase, index: String) {
-    val indexSql = generateIndexQuery(index)
+    val indexSql: String = generateIndexQuery(index)
     LogUtil.d(TAG, indexSql)
     database.execSQL(indexSql)
   }

From cbfcd5c6cf8901c3296acab6a6194fd2940f2128 Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Fri, 7 Aug 2020 17:34:08 +0300
Subject: [PATCH 14/34] updated commons package name

---
 app/src/main/java/promise/base/AppDatabase.kt |  2 +-
 .../java/promise/base/AppTypeConverter.kt     |  2 +-
 .../promise/base/comment/PostComment.java     |  4 +-
 app/src/main/java/promise/base/photo/Photo.kt |  7 +--
 app/src/main/java/promise/base/post/Post.java |  4 +-
 app/src/main/java/promise/base/todo/Todo.java |  4 +-
 .../promise/dbapp/DatabaseDependencies.kt     | 28 ++++++------
 .../main/java/promise/dbapp/MainActivity.kt   | 25 ++++++++---
 app/src/main/res/layout/content_main.xml      | 28 ++++++------
 .../promise/{db => database}/AddedEntity.kt   |  2 +-
 .../{db => database}/DatabaseEntity.java      |  2 +-
 .../java/promise/{db => database}/Embedded.kt |  2 +-
 .../java/promise/{db => database}/Entity.kt   |  2 +-
 .../promise/{db => database}/ForeignKey.kt    |  2 +-
 .../java/promise/{db => database}/HasMany.kt  |  2 +-
 .../java/promise/{db => database}/HasOne.kt   |  2 +-
 .../java/promise/{db => database}/Ignore.kt   |  2 +-
 .../java/promise/{db => database}/Index.kt    |  2 +-
 .../java/promise/{db => database}/Migrate.kt  |  2 +-
 .../{db => database}/MigrationOptions.kt      |  2 +-
 .../promise/{db => database}/Migrations.kt    |  2 +-
 .../java/promise/{db => database}/Number.kt   |  2 +-
 .../promise/{db => database}/PrimaryKey.kt    |  2 +-
 .../PrimaryKeyAutoIncrement.kt                |  2 +-
 .../java/promise/{db => database}/Query.kt    |  2 +-
 .../java/promise/{db => database}/Table.kt    |  2 +-
 .../java/promise/{db => database}/Text.kt     |  2 +-
 .../promise/{db => database}/TypeConverter.kt |  2 +-
 .../java/promise/{db => database}/VarChar.kt  |  2 +-
 .../ompiler/AnnotatedClassProcessor.kt        |  2 +-
 .../{db => database}/ompiler/CodeGenerator.kt |  2 +-
 .../DatabaseAbstractMethodsGenerator.kt       | 10 ++---
 .../ompiler/DatabaseAnnotationGenerator.kt    | 12 +++--
 .../DatabaseCrudStubMethodsGenerator.kt       |  4 +-
 .../DatabaseEntityAnnotatedProcessor.kt       | 14 +++---
 .../ompiler/DatabaseStaticMethodsGenerator.kt | 14 +++---
 .../ompiler/EntityAnnotatedProcessor.kt       | 12 ++---
 .../ompiler/PromiseDatabaseCompiler.kt        | 12 ++---
 .../ompiler/RelationsDaoGenerator.java        | 30 ++++++-------
 .../ompiler/RelationsDaoProcessor.kt          |  6 +--
 .../ompiler/TableAnnotationGenerator.java     | 10 ++---
 .../ompiler/TableColumnFieldsGenerator.kt     | 44 +++++++++----------
 .../TableDeserializerMethodGenerator.kt       | 20 ++++-----
 .../ompiler/TableMigrationFieldGenerator.kt   | 10 ++---
 .../TableRegisteredColumnsMethodGenerator.kt  |  2 +-
 .../ompiler/TableSerializerMethodGenerator.kt | 18 ++++----
 .../TypeConverterAnnotatedProcessor.kt        |  9 ++--
 .../ompiler/utils/JavaUtils.java              |  2 +-
 .../ompiler/utils/LogUtil.java                |  2 +-
 .../ompiler/utils/PersistableEntityUtils.kt   | 24 +++++-----
 .../{db => database}/ompiler/utils/Utils.kt   |  3 +-
 .../ompiler/ExampleUnitTest.kt                |  2 +-
 .../ompiler/PersistableEntityUtilsKtTest.kt   |  2 +-
 .../ExampleInstrumentedTest.java              |  2 +-
 database/src/main/AndroidManifest.xml         |  2 +-
 .../main/java/promise/db/FastDatabaseImpl.kt  |  2 +-
 .../src/main/java/promise/db/FastTable.kt     |  2 +
 .../java/promise/db/ReactiveFastDatabase.kt   |  1 +
 .../src/main/java/promise/db/ReactiveTable.kt |  1 +
 .../src/main/java/promise/db/TableCrud.kt     |  1 +
 .../{db => database}/ExampleUnitTest.java     |  2 +-
 61 files changed, 213 insertions(+), 210 deletions(-)
 rename commons/src/main/java/promise/{db => database}/AddedEntity.kt (96%)
 rename commons/src/main/java/promise/{db => database}/DatabaseEntity.java (97%)
 rename commons/src/main/java/promise/{db => database}/Embedded.kt (96%)
 rename commons/src/main/java/promise/{db => database}/Entity.kt (97%)
 rename commons/src/main/java/promise/{db => database}/ForeignKey.kt (96%)
 rename commons/src/main/java/promise/{db => database}/HasMany.kt (96%)
 rename commons/src/main/java/promise/{db => database}/HasOne.kt (96%)
 rename commons/src/main/java/promise/{db => database}/Ignore.kt (96%)
 rename commons/src/main/java/promise/{db => database}/Index.kt (96%)
 rename commons/src/main/java/promise/{db => database}/Migrate.kt (96%)
 rename commons/src/main/java/promise/{db => database}/MigrationOptions.kt (96%)
 rename commons/src/main/java/promise/{db => database}/Migrations.kt (96%)
 rename commons/src/main/java/promise/{db => database}/Number.kt (97%)
 rename commons/src/main/java/promise/{db => database}/PrimaryKey.kt (96%)
 rename commons/src/main/java/promise/{db => database}/PrimaryKeyAutoIncrement.kt (96%)
 rename commons/src/main/java/promise/{db => database}/Query.kt (96%)
 rename commons/src/main/java/promise/{db => database}/Table.kt (98%)
 rename commons/src/main/java/promise/{db => database}/Text.kt (97%)
 rename commons/src/main/java/promise/{db => database}/TypeConverter.kt (96%)
 rename commons/src/main/java/promise/{db => database}/VarChar.kt (97%)
 rename compiler/src/main/java/promise/{db => database}/ompiler/AnnotatedClassProcessor.kt (96%)
 rename compiler/src/main/java/promise/{db => database}/ompiler/CodeGenerator.kt (95%)
 rename compiler/src/main/java/promise/{db => database}/ompiler/DatabaseAbstractMethodsGenerator.kt (94%)
 rename compiler/src/main/java/promise/{db => database}/ompiler/DatabaseAnnotationGenerator.kt (87%)
 rename compiler/src/main/java/promise/{db => database}/ompiler/DatabaseCrudStubMethodsGenerator.kt (90%)
 rename compiler/src/main/java/promise/{db => database}/ompiler/DatabaseEntityAnnotatedProcessor.kt (93%)
 rename compiler/src/main/java/promise/{db => database}/ompiler/DatabaseStaticMethodsGenerator.kt (96%)
 rename compiler/src/main/java/promise/{db => database}/ompiler/EntityAnnotatedProcessor.kt (95%)
 rename compiler/src/main/java/promise/{db => database}/ompiler/PromiseDatabaseCompiler.kt (94%)
 rename compiler/src/main/java/promise/{db => database}/ompiler/RelationsDaoGenerator.java (97%)
 rename compiler/src/main/java/promise/{db => database}/ompiler/RelationsDaoProcessor.kt (92%)
 rename compiler/src/main/java/promise/{db => database}/ompiler/TableAnnotationGenerator.java (95%)
 rename compiler/src/main/java/promise/{db => database}/ompiler/TableColumnFieldsGenerator.kt (85%)
 rename compiler/src/main/java/promise/{db => database}/ompiler/TableDeserializerMethodGenerator.kt (86%)
 rename compiler/src/main/java/promise/{db => database}/ompiler/TableMigrationFieldGenerator.kt (94%)
 rename compiler/src/main/java/promise/{db => database}/ompiler/TableRegisteredColumnsMethodGenerator.kt (98%)
 rename compiler/src/main/java/promise/{db => database}/ompiler/TableSerializerMethodGenerator.kt (84%)
 rename compiler/src/main/java/promise/{db => database}/ompiler/TypeConverterAnnotatedProcessor.kt (91%)
 rename compiler/src/main/java/promise/{db => database}/ompiler/utils/JavaUtils.java (99%)
 rename compiler/src/main/java/promise/{db => database}/ompiler/utils/LogUtil.java (98%)
 rename compiler/src/main/java/promise/{db => database}/ompiler/utils/PersistableEntityUtils.kt (93%)
 rename compiler/src/main/java/promise/{db => database}/ompiler/utils/Utils.kt (99%)
 rename compiler/src/test/java/promise/{db => database}/ompiler/ExampleUnitTest.kt (96%)
 rename compiler/src/test/java/promise/{db => database}/ompiler/PersistableEntityUtilsKtTest.kt (95%)
 rename database/src/androidTest/java/promise/{db => database}/ExampleInstrumentedTest.java (97%)
 rename database/src/test/java/promise/{db => database}/ExampleUnitTest.java (97%)

diff --git a/app/src/main/java/promise/base/AppDatabase.kt b/app/src/main/java/promise/base/AppDatabase.kt
index 42fbb4d..cf2fbe8 100644
--- a/app/src/main/java/promise/base/AppDatabase.kt
+++ b/app/src/main/java/promise/base/AppDatabase.kt
@@ -17,7 +17,7 @@ import promise.base.comment.PostComment
 import promise.base.photo.Photo
 import promise.base.post.Post
 import promise.base.todo.Todo
-import promise.db.DatabaseEntity
+import promise.database.DatabaseEntity
 import promise.db.FastDatabase
 import promise.db.PromiseDatabase
 
diff --git a/app/src/main/java/promise/base/AppTypeConverter.kt b/app/src/main/java/promise/base/AppTypeConverter.kt
index 1472393..46888f4 100644
--- a/app/src/main/java/promise/base/AppTypeConverter.kt
+++ b/app/src/main/java/promise/base/AppTypeConverter.kt
@@ -13,7 +13,7 @@
 
 package promise.base
 
-import promise.db.TypeConverter
+import promise.database.TypeConverter
 
 @TypeConverter
 class AppTypeConverter {
diff --git a/app/src/main/java/promise/base/comment/PostComment.java b/app/src/main/java/promise/base/comment/PostComment.java
index 590de58..64cfa4a 100644
--- a/app/src/main/java/promise/base/comment/PostComment.java
+++ b/app/src/main/java/promise/base/comment/PostComment.java
@@ -7,8 +7,8 @@
 import promise.base.ID;
 import promise.base.post.Post;
 import promise.db.ActiveRecord;
-import promise.db.Entity;
-import promise.db.HasOne;
+import promise.database.Entity;
+import promise.database.HasOne;
 
 @SuppressLint("ParcelCreator")
 @Entity
diff --git a/app/src/main/java/promise/base/photo/Photo.kt b/app/src/main/java/promise/base/photo/Photo.kt
index 23be1dd..34c0adf 100644
--- a/app/src/main/java/promise/base/photo/Photo.kt
+++ b/app/src/main/java/promise/base/photo/Photo.kt
@@ -1,13 +1,10 @@
 package promise.base.photo
 
 import android.annotation.SuppressLint
-import android.os.Parcel
-import android.os.Parcelable
-import promise.base.ID
 import promise.base.post.Post
 import promise.db.ActiveRecord
-import promise.db.Entity
-import promise.db.HasOne
+import promise.database.Entity
+import promise.database.HasOne
 
 @SuppressLint("ParcelCreator")
 @Entity
diff --git a/app/src/main/java/promise/base/post/Post.java b/app/src/main/java/promise/base/post/Post.java
index b73e7ee..e6005df 100644
--- a/app/src/main/java/promise/base/post/Post.java
+++ b/app/src/main/java/promise/base/post/Post.java
@@ -10,8 +10,8 @@
 import promise.base.comment.PostComment;
 import promise.base.photo.Photo;
 import promise.db.ActiveRecord;
-import promise.db.Entity;
-import promise.db.HasMany;
+import promise.database.Entity;
+import promise.database.HasMany;
 
 @SuppressLint("ParcelCreator")
 @Entity
diff --git a/app/src/main/java/promise/base/todo/Todo.java b/app/src/main/java/promise/base/todo/Todo.java
index 6fe34c4..b5d4e30 100644
--- a/app/src/main/java/promise/base/todo/Todo.java
+++ b/app/src/main/java/promise/base/todo/Todo.java
@@ -6,8 +6,8 @@
 
 import promise.base.photo.Photo;
 import promise.db.ActiveRecord;
-import promise.db.Entity;
-import promise.db.HasOne;
+import promise.database.Entity;
+import promise.database.HasOne;
 
 @SuppressLint("ParcelCreator")
 @Entity
diff --git a/app/src/main/java/promise/dbapp/DatabaseDependencies.kt b/app/src/main/java/promise/dbapp/DatabaseDependencies.kt
index 570bb6b..c6b75a4 100644
--- a/app/src/main/java/promise/dbapp/DatabaseDependencies.kt
+++ b/app/src/main/java/promise/dbapp/DatabaseDependencies.kt
@@ -14,24 +14,22 @@
 package promise.dbapp
 
 import dagger.Module
-//import dagger.Provides
-//import promise.base.AppDatabase
-//import promise.base.AppDatabaseImpl
-//import promise.base.post.PostRelationsDao
-//import javax.inject.Singleton
+import dagger.Provides
+import promise.base.AppDatabase
+import promise.base.AppDatabaseImpl
+import promise.base.post.PostRelationsDao
+import javax.inject.Singleton
 
 @Module
 object DatabaseDependencies {
 
-//  @Provides
-//  @Singleton
-//  @JvmStatic
-//  fun provideAppDatabase(): AppDatabaseImpl = AppDatabaseImpl.createDatabase("blog_db")
-//
-//  @Provides
-//  @JvmStatic
-//  fun providePostRelationsDao(appDatabase: AppDatabaseImpl): PostRelationsDao =
-//      appDatabase.postRelationsDao
-
+  @Provides
+  @Singleton
+  @JvmStatic
+  fun provideAppDatabase(): AppDatabaseImpl = AppDatabaseImpl.createDatabase("blog_db")
 
+  @Provides
+  @JvmStatic
+  fun providePostRelationsDao(appDatabase: AppDatabaseImpl): PostRelationsDao =
+      appDatabase.postRelationsDao
 }
\ No newline at end of file
diff --git a/app/src/main/java/promise/dbapp/MainActivity.kt b/app/src/main/java/promise/dbapp/MainActivity.kt
index 0a88c63..24414f8 100644
--- a/app/src/main/java/promise/dbapp/MainActivity.kt
+++ b/app/src/main/java/promise/dbapp/MainActivity.kt
@@ -64,14 +64,27 @@ class MainActivity : DaggerAppCompatActivity() {
 
    postRelationsDao.saveWithComments(posts)
 
-   val persons = postRelationsDao.listWithComments()
+    showInfo()
 
-   complex_values_textview.text = persons.toString()
+    clear_button.setOnClickListener {
+      deleteInfo()
+      showInfo()
+    }
+  }
+
+  private fun showInfo() {
+
+    val persons = postRelationsDao.listWithComments()
 
-   persons.forEach {
-     postRelationsDao.deleteComments(it)
-     it.delete()
-   }
+    complex_values_textview.text = persons.toString()
+  }
+
+  private fun deleteInfo() {
+    val persons = postRelationsDao.listWithComments()
+    persons.forEach {
+      postRelationsDao.deleteComments(it)
+      it.delete()
+    }
   }
 
 }
diff --git a/app/src/main/res/layout/content_main.xml b/app/src/main/res/layout/content_main.xml
index ab1a145..d11903e 100644
--- a/app/src/main/res/layout/content_main.xml
+++ b/app/src/main/res/layout/content_main.xml
@@ -11,31 +11,29 @@
   ~ limitations under the License.
   -->
 
-<androidx.appcompat.widget.LinearLayoutCompat
+<ScrollView
     xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
     xmlns:tools="http://schemas.android.com/tools"
     android:layout_width="match_parent"
-    android:layout_height="match_parent"
-    android:orientation="vertical"
+    android:layout_height="wrap_content"
     app:layout_behavior="@string/appbar_scrolling_view_behavior"
     tools:context=".MainActivity"
     tools:showIn="@layout/activity_main">
-    <ScrollView
+    <androidx.appcompat.widget.LinearLayoutCompat
         android:layout_width="match_parent"
-        android:layout_height="wrap_content">
+        android:layout_height="wrap_content"
+        android:orientation="vertical">
         <TextView
             android:id="@+id/complex_values_textview"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:text="Hello World!"
-           />
-    </ScrollView>
-
-    <Button
-        android:id="@+id/clear_button"
-        android:layout_width="match_parent"
-        android:layout_height="30dp"
-        android:text="Clear" />
-
-</androidx.appcompat.widget.LinearLayoutCompat>
\ No newline at end of file
+            />
+        <Button
+            android:id="@+id/clear_button"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="Clear" />
+    </androidx.appcompat.widget.LinearLayoutCompat>
+</ScrollView>
\ No newline at end of file
diff --git a/commons/src/main/java/promise/db/AddedEntity.kt b/commons/src/main/java/promise/database/AddedEntity.kt
similarity index 96%
rename from commons/src/main/java/promise/db/AddedEntity.kt
rename to commons/src/main/java/promise/database/AddedEntity.kt
index 5052d9b..d7f001f 100644
--- a/commons/src/main/java/promise/db/AddedEntity.kt
+++ b/commons/src/main/java/promise/database/AddedEntity.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db
+package promise.database
 
 @Target(AnnotationTarget.CLASS)
 @Retention(AnnotationRetention.SOURCE)
diff --git a/commons/src/main/java/promise/db/DatabaseEntity.java b/commons/src/main/java/promise/database/DatabaseEntity.java
similarity index 97%
rename from commons/src/main/java/promise/db/DatabaseEntity.java
rename to commons/src/main/java/promise/database/DatabaseEntity.java
index c385ab5..7b9d8d0 100644
--- a/commons/src/main/java/promise/db/DatabaseEntity.java
+++ b/commons/src/main/java/promise/database/DatabaseEntity.java
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db;
+package promise.database;
 
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
diff --git a/commons/src/main/java/promise/db/Embedded.kt b/commons/src/main/java/promise/database/Embedded.kt
similarity index 96%
rename from commons/src/main/java/promise/db/Embedded.kt
rename to commons/src/main/java/promise/database/Embedded.kt
index 22add9d..713fc20 100644
--- a/commons/src/main/java/promise/db/Embedded.kt
+++ b/commons/src/main/java/promise/database/Embedded.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db
+package promise.database
 
 @Target(AnnotationTarget.FIELD)
 @Retention(AnnotationRetention.SOURCE)
diff --git a/commons/src/main/java/promise/db/Entity.kt b/commons/src/main/java/promise/database/Entity.kt
similarity index 97%
rename from commons/src/main/java/promise/db/Entity.kt
rename to commons/src/main/java/promise/database/Entity.kt
index 0148617..b50ba4d 100644
--- a/commons/src/main/java/promise/db/Entity.kt
+++ b/commons/src/main/java/promise/database/Entity.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db
+package promise.database
 
 @Target(AnnotationTarget.CLASS)
 @Retention(AnnotationRetention.SOURCE)
diff --git a/commons/src/main/java/promise/db/ForeignKey.kt b/commons/src/main/java/promise/database/ForeignKey.kt
similarity index 96%
rename from commons/src/main/java/promise/db/ForeignKey.kt
rename to commons/src/main/java/promise/database/ForeignKey.kt
index af03565..9621ab7 100644
--- a/commons/src/main/java/promise/db/ForeignKey.kt
+++ b/commons/src/main/java/promise/database/ForeignKey.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db
+package promise.database
 
 import kotlin.reflect.KClass
 
diff --git a/commons/src/main/java/promise/db/HasMany.kt b/commons/src/main/java/promise/database/HasMany.kt
similarity index 96%
rename from commons/src/main/java/promise/db/HasMany.kt
rename to commons/src/main/java/promise/database/HasMany.kt
index aee5ea5..6ec4eee 100644
--- a/commons/src/main/java/promise/db/HasMany.kt
+++ b/commons/src/main/java/promise/database/HasMany.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db
+package promise.database
 
 
 @Target(AnnotationTarget.FIELD)
diff --git a/commons/src/main/java/promise/db/HasOne.kt b/commons/src/main/java/promise/database/HasOne.kt
similarity index 96%
rename from commons/src/main/java/promise/db/HasOne.kt
rename to commons/src/main/java/promise/database/HasOne.kt
index 292eb94..c829538 100644
--- a/commons/src/main/java/promise/db/HasOne.kt
+++ b/commons/src/main/java/promise/database/HasOne.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db
+package promise.database
 
 @Target(AnnotationTarget.FIELD)
 @Retention(AnnotationRetention.SOURCE)
diff --git a/commons/src/main/java/promise/db/Ignore.kt b/commons/src/main/java/promise/database/Ignore.kt
similarity index 96%
rename from commons/src/main/java/promise/db/Ignore.kt
rename to commons/src/main/java/promise/database/Ignore.kt
index 21a990c..40a0f7d 100644
--- a/commons/src/main/java/promise/db/Ignore.kt
+++ b/commons/src/main/java/promise/database/Ignore.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db
+package promise.database
 
 @Target(AnnotationTarget.FIELD)
 @Retention(AnnotationRetention.SOURCE)
diff --git a/commons/src/main/java/promise/db/Index.kt b/commons/src/main/java/promise/database/Index.kt
similarity index 96%
rename from commons/src/main/java/promise/db/Index.kt
rename to commons/src/main/java/promise/database/Index.kt
index b0cbe20..a29c72b 100644
--- a/commons/src/main/java/promise/db/Index.kt
+++ b/commons/src/main/java/promise/database/Index.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db
+package promise.database
 
 @Target(AnnotationTarget.FIELD)
 @Retention(AnnotationRetention.SOURCE)
diff --git a/commons/src/main/java/promise/db/Migrate.kt b/commons/src/main/java/promise/database/Migrate.kt
similarity index 96%
rename from commons/src/main/java/promise/db/Migrate.kt
rename to commons/src/main/java/promise/database/Migrate.kt
index c2485d6..b6eaa33 100644
--- a/commons/src/main/java/promise/db/Migrate.kt
+++ b/commons/src/main/java/promise/database/Migrate.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db
+package promise.database
 
 @Target(AnnotationTarget.FIELD)
 @Retention(AnnotationRetention.SOURCE)
diff --git a/commons/src/main/java/promise/db/MigrationOptions.kt b/commons/src/main/java/promise/database/MigrationOptions.kt
similarity index 96%
rename from commons/src/main/java/promise/db/MigrationOptions.kt
rename to commons/src/main/java/promise/database/MigrationOptions.kt
index 572d100..77d3bea 100644
--- a/commons/src/main/java/promise/db/MigrationOptions.kt
+++ b/commons/src/main/java/promise/database/MigrationOptions.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db
+package promise.database
 
 enum class MigrationOptions {
   CREATE, DROP, CREATE_INDEX
diff --git a/commons/src/main/java/promise/db/Migrations.kt b/commons/src/main/java/promise/database/Migrations.kt
similarity index 96%
rename from commons/src/main/java/promise/db/Migrations.kt
rename to commons/src/main/java/promise/database/Migrations.kt
index 7163a45..1384049 100644
--- a/commons/src/main/java/promise/db/Migrations.kt
+++ b/commons/src/main/java/promise/database/Migrations.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db
+package promise.database
 
 @Target(AnnotationTarget.FIELD)
 @Retention(AnnotationRetention.SOURCE)
diff --git a/commons/src/main/java/promise/db/Number.kt b/commons/src/main/java/promise/database/Number.kt
similarity index 97%
rename from commons/src/main/java/promise/db/Number.kt
rename to commons/src/main/java/promise/database/Number.kt
index bdb636f..c7f7960 100644
--- a/commons/src/main/java/promise/db/Number.kt
+++ b/commons/src/main/java/promise/database/Number.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db
+package promise.database
 
 @Target(AnnotationTarget.FIELD)
 @Retention(AnnotationRetention.SOURCE)
diff --git a/commons/src/main/java/promise/db/PrimaryKey.kt b/commons/src/main/java/promise/database/PrimaryKey.kt
similarity index 96%
rename from commons/src/main/java/promise/db/PrimaryKey.kt
rename to commons/src/main/java/promise/database/PrimaryKey.kt
index 98e9100..9bed0fe 100644
--- a/commons/src/main/java/promise/db/PrimaryKey.kt
+++ b/commons/src/main/java/promise/database/PrimaryKey.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db
+package promise.database
 
 @Target(AnnotationTarget.FIELD)
 @Retention(AnnotationRetention.SOURCE)
diff --git a/commons/src/main/java/promise/db/PrimaryKeyAutoIncrement.kt b/commons/src/main/java/promise/database/PrimaryKeyAutoIncrement.kt
similarity index 96%
rename from commons/src/main/java/promise/db/PrimaryKeyAutoIncrement.kt
rename to commons/src/main/java/promise/database/PrimaryKeyAutoIncrement.kt
index 5f0a1c5..a600933 100644
--- a/commons/src/main/java/promise/db/PrimaryKeyAutoIncrement.kt
+++ b/commons/src/main/java/promise/database/PrimaryKeyAutoIncrement.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db
+package promise.database
 
 @Target(AnnotationTarget.FIELD)
 @Retention(AnnotationRetention.SOURCE)
diff --git a/commons/src/main/java/promise/db/Query.kt b/commons/src/main/java/promise/database/Query.kt
similarity index 96%
rename from commons/src/main/java/promise/db/Query.kt
rename to commons/src/main/java/promise/database/Query.kt
index 46ca108..f8a61cf 100644
--- a/commons/src/main/java/promise/db/Query.kt
+++ b/commons/src/main/java/promise/database/Query.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db
+package promise.database
 
 @Target(AnnotationTarget.FUNCTION)
 @Retention(AnnotationRetention.SOURCE)
diff --git a/commons/src/main/java/promise/db/Table.kt b/commons/src/main/java/promise/database/Table.kt
similarity index 98%
rename from commons/src/main/java/promise/db/Table.kt
rename to commons/src/main/java/promise/database/Table.kt
index 8431799..67f1615 100644
--- a/commons/src/main/java/promise/db/Table.kt
+++ b/commons/src/main/java/promise/database/Table.kt
@@ -10,7 +10,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package promise.db
+package promise.database
 
 @Target(AnnotationTarget.CLASS)
 @Retention(AnnotationRetention.RUNTIME)
diff --git a/commons/src/main/java/promise/db/Text.kt b/commons/src/main/java/promise/database/Text.kt
similarity index 97%
rename from commons/src/main/java/promise/db/Text.kt
rename to commons/src/main/java/promise/database/Text.kt
index 60d4511..c8a4c2d 100644
--- a/commons/src/main/java/promise/db/Text.kt
+++ b/commons/src/main/java/promise/database/Text.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db
+package promise.database
 
 @Target(AnnotationTarget.FIELD)
 @Retention(AnnotationRetention.SOURCE)
diff --git a/commons/src/main/java/promise/db/TypeConverter.kt b/commons/src/main/java/promise/database/TypeConverter.kt
similarity index 96%
rename from commons/src/main/java/promise/db/TypeConverter.kt
rename to commons/src/main/java/promise/database/TypeConverter.kt
index e606fc1..f95672e 100644
--- a/commons/src/main/java/promise/db/TypeConverter.kt
+++ b/commons/src/main/java/promise/database/TypeConverter.kt
@@ -10,7 +10,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package promise.db
+package promise.database
 
 
 @Target(AnnotationTarget.CLASS)
diff --git a/commons/src/main/java/promise/db/VarChar.kt b/commons/src/main/java/promise/database/VarChar.kt
similarity index 97%
rename from commons/src/main/java/promise/db/VarChar.kt
rename to commons/src/main/java/promise/database/VarChar.kt
index afe7753..6ecf994 100644
--- a/commons/src/main/java/promise/db/VarChar.kt
+++ b/commons/src/main/java/promise/database/VarChar.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db
+package promise.database
 
 @Target(AnnotationTarget.FIELD)
 @Retention(AnnotationRetention.SOURCE)
diff --git a/compiler/src/main/java/promise/db/ompiler/AnnotatedClassProcessor.kt b/compiler/src/main/java/promise/database/ompiler/AnnotatedClassProcessor.kt
similarity index 96%
rename from compiler/src/main/java/promise/db/ompiler/AnnotatedClassProcessor.kt
rename to compiler/src/main/java/promise/database/ompiler/AnnotatedClassProcessor.kt
index a1b2537..9a5c72d 100644
--- a/compiler/src/main/java/promise/db/ompiler/AnnotatedClassProcessor.kt
+++ b/compiler/src/main/java/promise/database/ompiler/AnnotatedClassProcessor.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler
+package promise.database.ompiler
 
 import com.squareup.javapoet.JavaFile
 import javax.annotation.processing.RoundEnvironment
diff --git a/compiler/src/main/java/promise/db/ompiler/CodeGenerator.kt b/compiler/src/main/java/promise/database/ompiler/CodeGenerator.kt
similarity index 95%
rename from compiler/src/main/java/promise/db/ompiler/CodeGenerator.kt
rename to compiler/src/main/java/promise/database/ompiler/CodeGenerator.kt
index ac32e65..7a5c8d2 100644
--- a/compiler/src/main/java/promise/db/ompiler/CodeGenerator.kt
+++ b/compiler/src/main/java/promise/database/ompiler/CodeGenerator.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler
+package promise.database.ompiler
 
 
 interface CodeGenerator<out T> {
diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseAbstractMethodsGenerator.kt b/compiler/src/main/java/promise/database/ompiler/DatabaseAbstractMethodsGenerator.kt
similarity index 94%
rename from compiler/src/main/java/promise/db/ompiler/DatabaseAbstractMethodsGenerator.kt
rename to compiler/src/main/java/promise/database/ompiler/DatabaseAbstractMethodsGenerator.kt
index 8c006d7..c141deb 100644
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseAbstractMethodsGenerator.kt
+++ b/compiler/src/main/java/promise/database/ompiler/DatabaseAbstractMethodsGenerator.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler
+package promise.database.ompiler
 
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
@@ -20,10 +20,10 @@ import com.squareup.javapoet.ParameterizedTypeName
 import com.squareup.javapoet.TypeVariableName
 import com.squareup.javapoet.WildcardTypeName
 import org.jetbrains.annotations.NotNull
-import promise.db.ompiler.utils.JavaUtils
-import promise.db.ompiler.utils.asTypeElement
-import promise.db.ompiler.utils.getTableClassNameString
-import promise.db.ompiler.utils.getTableEntities
+import promise.database.ompiler.utils.JavaUtils
+import promise.database.ompiler.utils.asTypeElement
+import promise.database.ompiler.utils.getTableClassNameString
+import promise.database.ompiler.utils.getTableEntities
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.ExecutableElement
diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseAnnotationGenerator.kt b/compiler/src/main/java/promise/database/ompiler/DatabaseAnnotationGenerator.kt
similarity index 87%
rename from compiler/src/main/java/promise/db/ompiler/DatabaseAnnotationGenerator.kt
rename to compiler/src/main/java/promise/database/ompiler/DatabaseAnnotationGenerator.kt
index d880916..2baccb4 100644
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseAnnotationGenerator.kt
+++ b/compiler/src/main/java/promise/database/ompiler/DatabaseAnnotationGenerator.kt
@@ -11,20 +11,18 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler
+package promise.database.ompiler
 
 import com.squareup.javapoet.AnnotationSpec
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
-import promise.db.ompiler.utils.LogUtil
-import promise.db.ompiler.utils.Utils
-import promise.db.ompiler.utils.getTableClassNameString
-import promise.db.ompiler.utils.getDatabaseVersion
-import promise.db.ompiler.utils.getTableEntities
+import promise.database.ompiler.utils.LogUtil
+import promise.database.ompiler.utils.getTableClassNameString
+import promise.database.ompiler.utils.getDatabaseVersion
+import promise.database.ompiler.utils.getTableEntities
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.TypeElement
-import javax.tools.Diagnostic
 
 class DatabaseAnnotationGenerator(
     private val processingEnv: ProcessingEnvironment,
diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseCrudStubMethodsGenerator.kt b/compiler/src/main/java/promise/database/ompiler/DatabaseCrudStubMethodsGenerator.kt
similarity index 90%
rename from compiler/src/main/java/promise/db/ompiler/DatabaseCrudStubMethodsGenerator.kt
rename to compiler/src/main/java/promise/database/ompiler/DatabaseCrudStubMethodsGenerator.kt
index 5a32f99..835f920 100644
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseCrudStubMethodsGenerator.kt
+++ b/compiler/src/main/java/promise/database/ompiler/DatabaseCrudStubMethodsGenerator.kt
@@ -11,13 +11,11 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler
+package promise.database.ompiler
 
 import com.squareup.javapoet.TypeSpec
-import promise.db.ompiler.utils.getTableEntities
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
-import javax.lang.model.element.TypeElement
 
 class DatabaseCrudStubMethodsGenerator(
     private val typeSpec: TypeSpec.Builder,
diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseEntityAnnotatedProcessor.kt b/compiler/src/main/java/promise/database/ompiler/DatabaseEntityAnnotatedProcessor.kt
similarity index 93%
rename from compiler/src/main/java/promise/db/ompiler/DatabaseEntityAnnotatedProcessor.kt
rename to compiler/src/main/java/promise/database/ompiler/DatabaseEntityAnnotatedProcessor.kt
index f50dddd..fa441bf 100644
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseEntityAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/database/ompiler/DatabaseEntityAnnotatedProcessor.kt
@@ -11,18 +11,18 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler
+package promise.database.ompiler
 
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.JavaFile
 import com.squareup.javapoet.MethodSpec
 import com.squareup.javapoet.TypeSpec
-import promise.db.DatabaseEntity
-import promise.db.ompiler.utils.JavaUtils
-import promise.db.ompiler.utils.LogUtil
-import promise.db.ompiler.utils.asTableClassName
-import promise.db.ompiler.utils.getTableClassNameString
-import promise.db.ompiler.utils.getTableEntities
+import promise.database.DatabaseEntity
+import promise.database.ompiler.utils.JavaUtils
+import promise.database.ompiler.utils.LogUtil
+import promise.database.ompiler.utils.asTableClassName
+import promise.database.ompiler.utils.getTableClassNameString
+import promise.database.ompiler.utils.getTableEntities
 import java.util.*
 import javax.annotation.processing.ProcessingEnvironment
 import javax.annotation.processing.RoundEnvironment
diff --git a/compiler/src/main/java/promise/db/ompiler/DatabaseStaticMethodsGenerator.kt b/compiler/src/main/java/promise/database/ompiler/DatabaseStaticMethodsGenerator.kt
similarity index 96%
rename from compiler/src/main/java/promise/db/ompiler/DatabaseStaticMethodsGenerator.kt
rename to compiler/src/main/java/promise/database/ompiler/DatabaseStaticMethodsGenerator.kt
index 1c64689..285b65a 100644
--- a/compiler/src/main/java/promise/db/ompiler/DatabaseStaticMethodsGenerator.kt
+++ b/compiler/src/main/java/promise/database/ompiler/DatabaseStaticMethodsGenerator.kt
@@ -11,24 +11,22 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler
+package promise.database.ompiler
 
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
 import com.squareup.javapoet.FieldSpec
 import com.squareup.javapoet.MethodSpec
 import com.squareup.javapoet.TypeSpec
-import promise.db.AddedEntity
-import promise.db.ompiler.utils.JavaUtils
-import promise.db.ompiler.utils.Utils
-import promise.db.ompiler.utils.getTableClassNameString
-import promise.db.ompiler.utils.getTableEntities
-import promise.db.ompiler.utils.toTypeName
+import promise.database.AddedEntity
+import promise.database.ompiler.utils.JavaUtils
+import promise.database.ompiler.utils.getTableClassNameString
+import promise.database.ompiler.utils.getTableEntities
+import promise.database.ompiler.utils.toTypeName
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
 import javax.lang.model.element.TypeElement
-import javax.tools.Diagnostic
 
 class DatabaseStaticMethodsGenerator(
     private val typeSpec: TypeSpec.Builder,
diff --git a/compiler/src/main/java/promise/db/ompiler/EntityAnnotatedProcessor.kt b/compiler/src/main/java/promise/database/ompiler/EntityAnnotatedProcessor.kt
similarity index 95%
rename from compiler/src/main/java/promise/db/ompiler/EntityAnnotatedProcessor.kt
rename to compiler/src/main/java/promise/database/ompiler/EntityAnnotatedProcessor.kt
index 132651c..43e966a 100644
--- a/compiler/src/main/java/promise/db/ompiler/EntityAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/database/ompiler/EntityAnnotatedProcessor.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler
+package promise.database.ompiler
 
 import com.squareup.javapoet.AnnotationSpec
 import com.squareup.javapoet.ClassName
@@ -23,11 +23,11 @@ import com.squareup.javapoet.ParameterizedTypeName
 import com.squareup.javapoet.TypeName
 import com.squareup.javapoet.TypeSpec
 import org.jetbrains.annotations.NotNull
-import promise.db.Entity
-import promise.db.ompiler.utils.JavaUtils
-import promise.db.ompiler.utils.LogUtil
-import promise.db.ompiler.utils.checkIfAnyElementNeedsTypeConverter
-import promise.db.ompiler.utils.getTableClassNameString
+import promise.database.Entity
+import promise.database.ompiler.utils.JavaUtils
+import promise.database.ompiler.utils.LogUtil
+import promise.database.ompiler.utils.checkIfAnyElementNeedsTypeConverter
+import promise.database.ompiler.utils.getTableClassNameString
 import javax.annotation.processing.ProcessingEnvironment
 import javax.annotation.processing.RoundEnvironment
 import javax.lang.model.element.Element
diff --git a/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt b/compiler/src/main/java/promise/database/ompiler/PromiseDatabaseCompiler.kt
similarity index 94%
rename from compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt
rename to compiler/src/main/java/promise/database/ompiler/PromiseDatabaseCompiler.kt
index 7dd5115..d9762b3 100644
--- a/compiler/src/main/java/promise/db/ompiler/PromiseDatabaseCompiler.kt
+++ b/compiler/src/main/java/promise/database/ompiler/PromiseDatabaseCompiler.kt
@@ -11,14 +11,14 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler
+package promise.database.ompiler
 
 import com.google.auto.service.AutoService
 import com.squareup.javapoet.JavaFile
-import promise.db.DatabaseEntity
-import promise.db.Entity
-import promise.db.TypeConverter
-import promise.db.ompiler.utils.LogUtil
+import promise.database.DatabaseEntity
+import promise.database.Entity
+import promise.database.TypeConverter
+import promise.database.ompiler.utils.LogUtil
 import javax.annotation.processing.AbstractProcessor
 import javax.annotation.processing.ProcessingEnvironment
 import javax.annotation.processing.Processor
@@ -54,7 +54,7 @@ class PromiseDatabaseCompiler : AbstractProcessor() {
       }
       javaFiles.forEach {
         it
-            .indent("\\t")
+            .indent("\t")
             .skipJavaLangImports(true)
             .addFileComment(
                 """
diff --git a/compiler/src/main/java/promise/db/ompiler/RelationsDaoGenerator.java b/compiler/src/main/java/promise/database/ompiler/RelationsDaoGenerator.java
similarity index 97%
rename from compiler/src/main/java/promise/db/ompiler/RelationsDaoGenerator.java
rename to compiler/src/main/java/promise/database/ompiler/RelationsDaoGenerator.java
index 2a22024..3022d0a 100644
--- a/compiler/src/main/java/promise/db/ompiler/RelationsDaoGenerator.java
+++ b/compiler/src/main/java/promise/database/ompiler/RelationsDaoGenerator.java
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler;
+package promise.database.ompiler;
 
 import com.squareup.javapoet.ArrayTypeName;
 import com.squareup.javapoet.ClassName;
@@ -39,20 +39,20 @@
 import javax.lang.model.util.ElementFilter;
 
 import kotlin.Pair;
-import promise.db.Entity;
-import promise.db.HasMany;
-import promise.db.HasOne;
-import promise.db.ompiler.utils.JavaUtils;
-import promise.db.ompiler.utils.LogUtil;
-import promise.db.ompiler.utils.PersistableEntityUtilsKt;
-import promise.db.ompiler.utils.Utils;
-import promise.db.ompiler.utils.UtilsKt;
-
-import static promise.db.ompiler.utils.PersistableEntityUtilsKt.asTableClassName;
-import static promise.db.ompiler.utils.PersistableEntityUtilsKt.camelCase;
-import static promise.db.ompiler.utils.PersistableEntityUtilsKt.capitalizeFirst;
-import static promise.db.ompiler.utils.PersistableEntityUtilsKt.getTableClassNameString;
-import static promise.db.ompiler.utils.PersistableEntityUtilsKt.pluralize;
+import promise.database.Entity;
+import promise.database.HasMany;
+import promise.database.HasOne;
+import promise.database.ompiler.utils.JavaUtils;
+import promise.database.ompiler.utils.LogUtil;
+import promise.database.ompiler.utils.PersistableEntityUtilsKt;
+import promise.database.ompiler.utils.Utils;
+import promise.database.ompiler.utils.UtilsKt;
+
+import static promise.database.ompiler.utils.PersistableEntityUtilsKt.asTableClassName;
+import static promise.database.ompiler.utils.PersistableEntityUtilsKt.camelCase;
+import static promise.database.ompiler.utils.PersistableEntityUtilsKt.capitalizeFirst;
+import static promise.database.ompiler.utils.PersistableEntityUtilsKt.getTableClassNameString;
+import static promise.database.ompiler.utils.PersistableEntityUtilsKt.pluralize;
 
 public class RelationsDaoGenerator implements CodeGenerator<List<JavaFile.Builder>> {
 
diff --git a/compiler/src/main/java/promise/db/ompiler/RelationsDaoProcessor.kt b/compiler/src/main/java/promise/database/ompiler/RelationsDaoProcessor.kt
similarity index 92%
rename from compiler/src/main/java/promise/db/ompiler/RelationsDaoProcessor.kt
rename to compiler/src/main/java/promise/database/ompiler/RelationsDaoProcessor.kt
index b244fc4..2510a7b 100644
--- a/compiler/src/main/java/promise/db/ompiler/RelationsDaoProcessor.kt
+++ b/compiler/src/main/java/promise/database/ompiler/RelationsDaoProcessor.kt
@@ -11,11 +11,11 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler
+package promise.database.ompiler
 
 import com.squareup.javapoet.JavaFile
-import promise.db.Entity
-import promise.db.ompiler.utils.isElementAnnotatedAsRelation
+import promise.database.Entity
+import promise.database.ompiler.utils.isElementAnnotatedAsRelation
 import javax.annotation.processing.ProcessingEnvironment
 import javax.annotation.processing.RoundEnvironment
 import javax.lang.model.element.Element
diff --git a/compiler/src/main/java/promise/db/ompiler/TableAnnotationGenerator.java b/compiler/src/main/java/promise/database/ompiler/TableAnnotationGenerator.java
similarity index 95%
rename from compiler/src/main/java/promise/db/ompiler/TableAnnotationGenerator.java
rename to compiler/src/main/java/promise/database/ompiler/TableAnnotationGenerator.java
index 362e44f..014823c 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableAnnotationGenerator.java
+++ b/compiler/src/main/java/promise/database/ompiler/TableAnnotationGenerator.java
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler;
+package promise.database.ompiler;
 
 import com.squareup.javapoet.AnnotationSpec;
 import com.squareup.javapoet.CodeBlock;
@@ -23,10 +23,10 @@
 import javax.lang.model.element.Element;
 import javax.lang.model.element.TypeElement;
 
-import promise.db.Entity;
-import promise.db.Table;
-import promise.db.ompiler.utils.LogUtil;
-import promise.db.ompiler.utils.PersistableEntityUtilsKt;
+import promise.database.Entity;
+import promise.database.Table;
+import promise.database.ompiler.utils.LogUtil;
+import promise.database.ompiler.utils.PersistableEntityUtilsKt;
 
 public class TableAnnotationGenerator implements CodeGenerator<AnnotationSpec> {
   private Element element;
diff --git a/compiler/src/main/java/promise/db/ompiler/TableColumnFieldsGenerator.kt b/compiler/src/main/java/promise/database/ompiler/TableColumnFieldsGenerator.kt
similarity index 85%
rename from compiler/src/main/java/promise/db/ompiler/TableColumnFieldsGenerator.kt
rename to compiler/src/main/java/promise/database/ompiler/TableColumnFieldsGenerator.kt
index d1779b8..416f10c 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableColumnFieldsGenerator.kt
+++ b/compiler/src/main/java/promise/database/ompiler/TableColumnFieldsGenerator.kt
@@ -11,24 +11,24 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler
+package promise.database.ompiler
 
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
 import com.squareup.javapoet.FieldSpec
 import com.squareup.javapoet.ParameterizedTypeName
 import com.squareup.javapoet.TypeName
-import promise.db.HasOne
-import promise.db.Ignore
-import promise.db.PrimaryKey
-import promise.db.PrimaryKeyAutoIncrement
-import promise.db.ompiler.utils.LogUtil
-import promise.db.ompiler.utils.checkIfHasTypeConverter
-import promise.db.ompiler.utils.getNameOfColumn
-import promise.db.ompiler.utils.isElementAnnotatedAsRelation
-import promise.db.ompiler.utils.isPersistable
-import promise.db.ompiler.utils.isSameAs
-import promise.db.ompiler.utils.toTypeName
+import promise.database.HasOne
+import promise.database.Ignore
+import promise.database.PrimaryKey
+import promise.database.PrimaryKeyAutoIncrement
+import promise.database.ompiler.utils.LogUtil
+import promise.database.ompiler.utils.checkIfHasTypeConverter
+import promise.database.ompiler.utils.getNameOfColumn
+import promise.database.ompiler.utils.isElementAnnotatedAsRelation
+import promise.database.ompiler.utils.isPersistable
+import promise.database.ompiler.utils.isSameAs
+import promise.database.ompiler.utils.toTypeName
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
@@ -136,8 +136,8 @@ class TableColumnFieldsGenerator(
         classTypeName.isSameAs(Boolean::class.java)) {
       str += ".INTEGER"
       if (element.getAnnotation(PrimaryKey::class.java) != null) str += ".PRIMARY_KEY()"
-      else if (element.getAnnotation(promise.db.Number::class.java) != null) {
-        val annotation = element.getAnnotation(promise.db.Number::class.java)
+      else if (element.getAnnotation(promise.database.Number::class.java) != null) {
+        val annotation = element.getAnnotation(promise.database.Number::class.java)
         if (annotation.default != 0) {
           str += ".DEFAULT(${annotation.default})"
         } else {
@@ -146,9 +146,9 @@ class TableColumnFieldsGenerator(
         }
       } else str += ".NULLABLE()"
     } else if (classTypeName.isSameAs(String::class.java)) {
-      if (element.getAnnotation(promise.db.VarChar::class.java) != null) {
+      if (element.getAnnotation(promise.database.VarChar::class.java) != null) {
         str += ".VARCHAR"
-        val annotation = element.getAnnotation(promise.db.VarChar::class.java)
+        val annotation = element.getAnnotation(promise.database.VarChar::class.java)
         str += if (annotation.unique && annotation.length != 0)
           ".UNIQUE(${annotation.length})"
         else if (annotation.nullable && annotation.length != 0)
@@ -157,9 +157,9 @@ class TableColumnFieldsGenerator(
           ".NOT_NULL(${annotation.length})"
         else LogUtil.e(IllegalStateException("element ${element.simpleName} is annotated as varchar without length"), element)
       } else {
-        if (element.getAnnotation(promise.db.Text::class.java) != null) {
+        if (element.getAnnotation(promise.database.Text::class.java) != null) {
           str += ".TEXT"
-          val annotation = element.getAnnotation(promise.db.Text::class.java)
+          val annotation = element.getAnnotation(promise.database.Text::class.java)
           str += if (annotation.nullable)
             ".NULLABLE()"
           else if (!annotation.nullable)
@@ -169,9 +169,9 @@ class TableColumnFieldsGenerator(
         } else str += ".TEXT.NULLABLE()"
       }
     } else {
-      if (element.getAnnotation(promise.db.VarChar::class.java) != null) {
+      if (element.getAnnotation(promise.database.VarChar::class.java) != null) {
         str += ".VARCHAR"
-        val annotation = element.getAnnotation(promise.db.VarChar::class.java)
+        val annotation = element.getAnnotation(promise.database.VarChar::class.java)
         str += if (annotation.unique && annotation.length != 0)
           ".UNIQUE(${annotation.length})"
         else if (annotation.nullable && annotation.length != 0)
@@ -180,9 +180,9 @@ class TableColumnFieldsGenerator(
           ".NOT_NULL(${annotation.length})"
         else LogUtil.e(IllegalStateException("element ${element.simpleName} is annotated as varchar without length"), element)
       } else {
-        if (element.getAnnotation(promise.db.Text::class.java) != null) {
+        if (element.getAnnotation(promise.database.Text::class.java) != null) {
           str += ".TEXT"
-          val annotation = element.getAnnotation(promise.db.Text::class.java)
+          val annotation = element.getAnnotation(promise.database.Text::class.java)
           str += if (annotation.nullable)
             ".NULLABLE()"
           else if (!annotation.nullable)
diff --git a/compiler/src/main/java/promise/db/ompiler/TableDeserializerMethodGenerator.kt b/compiler/src/main/java/promise/database/ompiler/TableDeserializerMethodGenerator.kt
similarity index 86%
rename from compiler/src/main/java/promise/db/ompiler/TableDeserializerMethodGenerator.kt
rename to compiler/src/main/java/promise/database/ompiler/TableDeserializerMethodGenerator.kt
index ca5806c..7652e34 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableDeserializerMethodGenerator.kt
+++ b/compiler/src/main/java/promise/database/ompiler/TableDeserializerMethodGenerator.kt
@@ -11,21 +11,21 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler
+package promise.database.ompiler
 
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
 import com.squareup.javapoet.MethodSpec
 import com.squareup.javapoet.TypeName
-import promise.db.ompiler.utils.ConverterTypes
-import promise.db.ompiler.utils.JavaUtils
-import promise.db.ompiler.utils.camelCase
-import promise.db.ompiler.utils.capitalizeFirst
-import promise.db.ompiler.utils.checkIfHasTypeConverter
-import promise.db.ompiler.utils.getConverterCompatibleMethod
-import promise.db.ompiler.utils.isElementAnnotatedAsRelation
-import promise.db.ompiler.utils.isSameAs
-import promise.db.ompiler.utils.toTypeName
+import promise.database.ompiler.utils.ConverterTypes
+import promise.database.ompiler.utils.JavaUtils
+import promise.database.ompiler.utils.camelCase
+import promise.database.ompiler.utils.capitalizeFirst
+import promise.database.ompiler.utils.checkIfHasTypeConverter
+import promise.database.ompiler.utils.getConverterCompatibleMethod
+import promise.database.ompiler.utils.isElementAnnotatedAsRelation
+import promise.database.ompiler.utils.isSameAs
+import promise.database.ompiler.utils.toTypeName
 import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
 
diff --git a/compiler/src/main/java/promise/db/ompiler/TableMigrationFieldGenerator.kt b/compiler/src/main/java/promise/database/ompiler/TableMigrationFieldGenerator.kt
similarity index 94%
rename from compiler/src/main/java/promise/db/ompiler/TableMigrationFieldGenerator.kt
rename to compiler/src/main/java/promise/database/ompiler/TableMigrationFieldGenerator.kt
index c1b33cc..91b421b 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableMigrationFieldGenerator.kt
+++ b/compiler/src/main/java/promise/database/ompiler/TableMigrationFieldGenerator.kt
@@ -11,17 +11,17 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler
+package promise.database.ompiler
 
 import com.squareup.javapoet.AnnotationSpec
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
 import com.squareup.javapoet.MethodSpec
 import org.jetbrains.annotations.NotNull
-import promise.db.Migrate
-import promise.db.MigrationOptions
-import promise.db.Migrations
-import promise.db.ompiler.utils.getNameOfColumn
+import promise.database.Migrate
+import promise.database.MigrationOptions
+import promise.database.Migrations
+import promise.database.ompiler.utils.getNameOfColumn
 import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
 
diff --git a/compiler/src/main/java/promise/db/ompiler/TableRegisteredColumnsMethodGenerator.kt b/compiler/src/main/java/promise/database/ompiler/TableRegisteredColumnsMethodGenerator.kt
similarity index 98%
rename from compiler/src/main/java/promise/db/ompiler/TableRegisteredColumnsMethodGenerator.kt
rename to compiler/src/main/java/promise/database/ompiler/TableRegisteredColumnsMethodGenerator.kt
index e580ab6..07455be 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableRegisteredColumnsMethodGenerator.kt
+++ b/compiler/src/main/java/promise/database/ompiler/TableRegisteredColumnsMethodGenerator.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler
+package promise.database.ompiler
 
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
diff --git a/compiler/src/main/java/promise/db/ompiler/TableSerializerMethodGenerator.kt b/compiler/src/main/java/promise/database/ompiler/TableSerializerMethodGenerator.kt
similarity index 84%
rename from compiler/src/main/java/promise/db/ompiler/TableSerializerMethodGenerator.kt
rename to compiler/src/main/java/promise/database/ompiler/TableSerializerMethodGenerator.kt
index 19bfcb6..000ef2e 100644
--- a/compiler/src/main/java/promise/db/ompiler/TableSerializerMethodGenerator.kt
+++ b/compiler/src/main/java/promise/database/ompiler/TableSerializerMethodGenerator.kt
@@ -11,19 +11,19 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler
+package promise.database.ompiler
 
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
 import com.squareup.javapoet.MethodSpec
-import promise.db.ompiler.utils.ConverterTypes
-import promise.db.ompiler.utils.JavaUtils
-import promise.db.ompiler.utils.capitalizeFirst
-import promise.db.ompiler.utils.checkIfHasTypeConverter
-import promise.db.ompiler.utils.getConverterCompatibleMethod
-import promise.db.ompiler.utils.isElementAnnotatedAsRelation
-import promise.db.ompiler.utils.isSameAs
-import promise.db.ompiler.utils.toTypeName
+import promise.database.ompiler.utils.ConverterTypes
+import promise.database.ompiler.utils.JavaUtils
+import promise.database.ompiler.utils.capitalizeFirst
+import promise.database.ompiler.utils.checkIfHasTypeConverter
+import promise.database.ompiler.utils.getConverterCompatibleMethod
+import promise.database.ompiler.utils.isElementAnnotatedAsRelation
+import promise.database.ompiler.utils.isSameAs
+import promise.database.ompiler.utils.toTypeName
 import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
 
diff --git a/compiler/src/main/java/promise/db/ompiler/TypeConverterAnnotatedProcessor.kt b/compiler/src/main/java/promise/database/ompiler/TypeConverterAnnotatedProcessor.kt
similarity index 91%
rename from compiler/src/main/java/promise/db/ompiler/TypeConverterAnnotatedProcessor.kt
rename to compiler/src/main/java/promise/database/ompiler/TypeConverterAnnotatedProcessor.kt
index 3d7a7d4..5988915 100644
--- a/compiler/src/main/java/promise/db/ompiler/TypeConverterAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/database/ompiler/TypeConverterAnnotatedProcessor.kt
@@ -11,18 +11,17 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler
+package promise.database.ompiler
 
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.JavaFile
-import promise.db.TypeConverter
-import promise.db.ompiler.utils.LogUtil
-import promise.db.ompiler.utils.Utils
+import promise.database.TypeConverter
+import promise.database.ompiler.utils.LogUtil
+import promise.database.ompiler.utils.Utils
 import java.util.*
 import javax.annotation.processing.ProcessingEnvironment
 import javax.annotation.processing.RoundEnvironment
 import javax.lang.model.element.TypeElement
-import javax.tools.Diagnostic
 
 class TypeConverterAnnotatedProcessor(private val processingEnv: ProcessingEnvironment) : AnnotatedClassProcessor() {
 
diff --git a/compiler/src/main/java/promise/db/ompiler/utils/JavaUtils.java b/compiler/src/main/java/promise/database/ompiler/utils/JavaUtils.java
similarity index 99%
rename from compiler/src/main/java/promise/db/ompiler/utils/JavaUtils.java
rename to compiler/src/main/java/promise/database/ompiler/utils/JavaUtils.java
index 805bca0..c3be0f0 100644
--- a/compiler/src/main/java/promise/db/ompiler/utils/JavaUtils.java
+++ b/compiler/src/main/java/promise/database/ompiler/utils/JavaUtils.java
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler.utils;
+package promise.database.ompiler.utils;
 
 import com.squareup.javapoet.ClassName;
 import com.squareup.javapoet.CodeBlock;
diff --git a/compiler/src/main/java/promise/db/ompiler/utils/LogUtil.java b/compiler/src/main/java/promise/database/ompiler/utils/LogUtil.java
similarity index 98%
rename from compiler/src/main/java/promise/db/ompiler/utils/LogUtil.java
rename to compiler/src/main/java/promise/database/ompiler/utils/LogUtil.java
index e4112cb..3aff843 100644
--- a/compiler/src/main/java/promise/db/ompiler/utils/LogUtil.java
+++ b/compiler/src/main/java/promise/database/ompiler/utils/LogUtil.java
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler.utils;
+package promise.database.ompiler.utils;
 
 import javax.annotation.processing.ProcessingEnvironment;
 import javax.lang.model.element.Element;
diff --git a/compiler/src/main/java/promise/db/ompiler/utils/PersistableEntityUtils.kt b/compiler/src/main/java/promise/database/ompiler/utils/PersistableEntityUtils.kt
similarity index 93%
rename from compiler/src/main/java/promise/db/ompiler/utils/PersistableEntityUtils.kt
rename to compiler/src/main/java/promise/database/ompiler/utils/PersistableEntityUtils.kt
index 812c4b3..fe16d7c 100644
--- a/compiler/src/main/java/promise/db/ompiler/utils/PersistableEntityUtils.kt
+++ b/compiler/src/main/java/promise/database/ompiler/utils/PersistableEntityUtils.kt
@@ -11,21 +11,21 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler.utils
+package promise.database.ompiler.utils
 
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.TypeName
 import com.sun.tools.javac.code.Attribute
 import org.atteo.evo.inflector.English
-import promise.db.DatabaseEntity
-import promise.db.Entity
-import promise.db.ForeignKey
-import promise.db.HasMany
-import promise.db.HasOne
-import promise.db.Index
-import promise.db.Text
-import promise.db.VarChar
-import promise.db.ompiler.TypeConverterAnnotatedProcessor
+import promise.database.DatabaseEntity
+import promise.database.Entity
+import promise.database.ForeignKey
+import promise.database.HasMany
+import promise.database.HasOne
+import promise.database.Index
+import promise.database.Text
+import promise.database.VarChar
+import promise.database.ompiler.TypeConverterAnnotatedProcessor
 import java.io.IOException
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
@@ -138,8 +138,8 @@ fun Element.getNameOfColumn(): String {
           this.toTypeName().isSameAs(Float::class.java) ||
           this.toTypeName().isSameAs(Double::class.java) ||
           this.toTypeName().isSameAs(Boolean::class.java)) &&
-      this.getAnnotation(promise.db.Number::class.java) != null) {
-    name = this.getAnnotation(promise.db.Number::class.java).columnName
+      this.getAnnotation(promise.database.Number::class.java) != null) {
+    name = this.getAnnotation(promise.database.Number::class.java).columnName
   } else if (this.toTypeName().isSameAs(String::class.java) &&
       this.getAnnotation(VarChar::class.java) != null) {
     name = this.getAnnotation(VarChar::class.java).columnName
diff --git a/compiler/src/main/java/promise/db/ompiler/utils/Utils.kt b/compiler/src/main/java/promise/database/ompiler/utils/Utils.kt
similarity index 99%
rename from compiler/src/main/java/promise/db/ompiler/utils/Utils.kt
rename to compiler/src/main/java/promise/database/ompiler/utils/Utils.kt
index 790c701..e480f92 100644
--- a/compiler/src/main/java/promise/db/ompiler/utils/Utils.kt
+++ b/compiler/src/main/java/promise/database/ompiler/utils/Utils.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler.utils
+package promise.database.ompiler.utils
 
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
@@ -38,7 +38,6 @@ import javax.lang.model.type.MirroredTypeException
 import javax.lang.model.type.TypeKind
 import javax.lang.model.type.TypeMirror
 import javax.lang.model.util.Types
-import javax.tools.Diagnostic
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.contract
 import kotlin.reflect.KClass
diff --git a/compiler/src/test/java/promise/db/ompiler/ExampleUnitTest.kt b/compiler/src/test/java/promise/database/ompiler/ExampleUnitTest.kt
similarity index 96%
rename from compiler/src/test/java/promise/db/ompiler/ExampleUnitTest.kt
rename to compiler/src/test/java/promise/database/ompiler/ExampleUnitTest.kt
index b688fe8..71f39da 100644
--- a/compiler/src/test/java/promise/db/ompiler/ExampleUnitTest.kt
+++ b/compiler/src/test/java/promise/database/ompiler/ExampleUnitTest.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler
+package promise.database.ompiler
 
 import org.junit.Assert.assertEquals
 import org.junit.Test
diff --git a/compiler/src/test/java/promise/db/ompiler/PersistableEntityUtilsKtTest.kt b/compiler/src/test/java/promise/database/ompiler/PersistableEntityUtilsKtTest.kt
similarity index 95%
rename from compiler/src/test/java/promise/db/ompiler/PersistableEntityUtilsKtTest.kt
rename to compiler/src/test/java/promise/database/ompiler/PersistableEntityUtilsKtTest.kt
index 00475a4..161d166 100644
--- a/compiler/src/test/java/promise/db/ompiler/PersistableEntityUtilsKtTest.kt
+++ b/compiler/src/test/java/promise/database/ompiler/PersistableEntityUtilsKtTest.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db.ompiler
+package promise.database.ompiler
 
 import org.junit.After
 import org.junit.Before
diff --git a/database/src/androidTest/java/promise/db/ExampleInstrumentedTest.java b/database/src/androidTest/java/promise/database/ExampleInstrumentedTest.java
similarity index 97%
rename from database/src/androidTest/java/promise/db/ExampleInstrumentedTest.java
rename to database/src/androidTest/java/promise/database/ExampleInstrumentedTest.java
index 73bb615..3a3bd23 100644
--- a/database/src/androidTest/java/promise/db/ExampleInstrumentedTest.java
+++ b/database/src/androidTest/java/promise/database/ExampleInstrumentedTest.java
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db;
+package promise.database;
 
 import android.content.Context;
 
diff --git a/database/src/main/AndroidManifest.xml b/database/src/main/AndroidManifest.xml
index aaaea4c..77b81d9 100644
--- a/database/src/main/AndroidManifest.xml
+++ b/database/src/main/AndroidManifest.xml
@@ -11,4 +11,4 @@
   ~ limitations under the License.
   -->
 
-<manifest package="promise.db" />
+<manifest package="promise.database" />
diff --git a/database/src/main/java/promise/db/FastDatabaseImpl.kt b/database/src/main/java/promise/db/FastDatabaseImpl.kt
index 76cd186..78e7e8f 100644
--- a/database/src/main/java/promise/db/FastDatabaseImpl.kt
+++ b/database/src/main/java/promise/db/FastDatabaseImpl.kt
@@ -24,9 +24,9 @@ import promise.commons.model.Identifiable
 import promise.commons.model.List
 import promise.commons.util.ClassUtil
 import promise.commons.util.Conditions
+import promise.database.Table
 import promise.model.IdentifiableList
 import java.util.*
-import promise.db.Table
 
 open class FastDatabaseImpl internal constructor(
     name: String?,
diff --git a/database/src/main/java/promise/db/FastTable.kt b/database/src/main/java/promise/db/FastTable.kt
index 2896a3c..de9d425 100644
--- a/database/src/main/java/promise/db/FastTable.kt
+++ b/database/src/main/java/promise/db/FastTable.kt
@@ -27,6 +27,8 @@ import promise.commons.model.List
 import promise.commons.model.List.fromArray
 import promise.commons.util.Conditions
 import promise.commons.util.DoubleConverter
+import promise.database.Number
+import promise.database.Table
 import promise.db.criteria.Criteria
 import promise.model.ITimeStamped
 import promise.db.projection.Projection
diff --git a/database/src/main/java/promise/db/ReactiveFastDatabase.kt b/database/src/main/java/promise/db/ReactiveFastDatabase.kt
index 2f34735..deffaa3 100644
--- a/database/src/main/java/promise/db/ReactiveFastDatabase.kt
+++ b/database/src/main/java/promise/db/ReactiveFastDatabase.kt
@@ -23,6 +23,7 @@ import io.reactivex.Single
 import promise.commons.model.Identifiable
 import promise.commons.model.List
 import promise.commons.util.DoubleConverter
+import promise.database.Number
 import promise.model.IdentifiableList
 
 class ReactiveFastDatabase private constructor(
diff --git a/database/src/main/java/promise/db/ReactiveTable.kt b/database/src/main/java/promise/db/ReactiveTable.kt
index 78d5dfc..3541b6b 100644
--- a/database/src/main/java/promise/db/ReactiveTable.kt
+++ b/database/src/main/java/promise/db/ReactiveTable.kt
@@ -14,6 +14,7 @@ package promise.db
 
 import io.reactivex.Maybe
 import promise.commons.model.Identifiable
+import promise.database.Number
 import promise.model.IdentifiableList
 
 /**
diff --git a/database/src/main/java/promise/db/TableCrud.kt b/database/src/main/java/promise/db/TableCrud.kt
index 09b3b23..e05f629 100644
--- a/database/src/main/java/promise/db/TableCrud.kt
+++ b/database/src/main/java/promise/db/TableCrud.kt
@@ -17,6 +17,7 @@ import android.database.Cursor
 import promise.commons.model.Identifiable
 import promise.commons.model.List
 import promise.commons.util.DoubleConverter
+import promise.database.Number
 import promise.model.IdentifiableList
 
 /**
diff --git a/database/src/test/java/promise/db/ExampleUnitTest.java b/database/src/test/java/promise/database/ExampleUnitTest.java
similarity index 97%
rename from database/src/test/java/promise/db/ExampleUnitTest.java
rename to database/src/test/java/promise/database/ExampleUnitTest.java
index 983ea92..53047e1 100644
--- a/database/src/test/java/promise/db/ExampleUnitTest.java
+++ b/database/src/test/java/promise/database/ExampleUnitTest.java
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.db;
+package promise.database;
 
 import org.junit.Test;
 

From 0b78c79a86fd4b4e6652322c137a828dbe7e9882 Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Fri, 7 Aug 2020 18:06:49 +0300
Subject: [PATCH 15/34] removed artifacts in database gradle

---
 compiler/build.gradle |  2 +-
 database/build.gradle | 24 ------------------------
 2 files changed, 1 insertion(+), 25 deletions(-)

diff --git a/compiler/build.gradle b/compiler/build.gradle
index da64c43..adcafd7 100644
--- a/compiler/build.gradle
+++ b/compiler/build.gradle
@@ -22,7 +22,7 @@ dependencies {
     compileOnly project(path: ':commons')
     compileOnly files(Jvm.current().getToolsJar())
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
-    implementation group: 'org.atteo', name: 'evo-inflector', version: '1.0.1'
+    implementation'org.atteo:evo-inflector:1.0.1'
     implementation 'com.squareup:javapoet:1.13.0'
     implementation "org.jetbrains.kotlin:kotlin-reflect:1.3.72"
     implementation 'com.google.auto:auto-common:0.10'
diff --git a/database/build.gradle b/database/build.gradle
index 081ca48..7453f2a 100644
--- a/database/build.gradle
+++ b/database/build.gradle
@@ -55,27 +55,3 @@ repositories {
     mavenCentral()
 }
 
-task sourcesJar(type: Jar) {
-    classifier = 'sources'
-    from android.sourceSets.main.java.sourceFiles
-}
-
-task javadoc(type: Javadoc) {
-    source = android.sourceSets.main.java.sourceFiles
-    classpath += project.files(android.getBootClasspath().join(File.pathSeparator))
-}
-
-task javadocJar(type: Jar, dependsOn: javadoc) {
-    classifier = 'javadoc'
-    from javadoc.destinationDir
-}
-
-task classesJar(type: Jar) {
-    from "$buildDir/intermediates/classes/release"
-}
-
-artifacts {
-    archives classesJar
-    archives javadocJar
-    archives sourcesJar
-}

From 25d16d6fde18fb810132ddf65546b2169408556b Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Sat, 8 Aug 2020 05:33:36 +0300
Subject: [PATCH 16/34] added supress warnings

---
 app/src/main/java/promise/base/AppDatabase.kt |  4 +-
 .../main/java/promise/base/comment/Like.java  | 67 +++++++++++++++++++
 app/src/main/java/promise/base/post/Post.java | 11 +++
 .../DatabaseEntityAnnotatedProcessor.kt       |  6 ++
 4 files changed, 87 insertions(+), 1 deletion(-)
 create mode 100644 app/src/main/java/promise/base/comment/Like.java

diff --git a/app/src/main/java/promise/base/AppDatabase.kt b/app/src/main/java/promise/base/AppDatabase.kt
index cf2fbe8..48e6a9b 100644
--- a/app/src/main/java/promise/base/AppDatabase.kt
+++ b/app/src/main/java/promise/base/AppDatabase.kt
@@ -13,6 +13,7 @@
 
 package promise.base
 
+import promise.base.comment.Like
 import promise.base.comment.PostComment
 import promise.base.photo.Photo
 import promise.base.post.Post
@@ -26,7 +27,8 @@ import promise.db.PromiseDatabase
       PostComment::class,
       Photo::class,
       Post::class,
-      Todo::class
+      Todo::class,
+      Like::class
     ]
 )
 abstract class AppDatabase(fastDatabase: FastDatabase)
diff --git a/app/src/main/java/promise/base/comment/Like.java b/app/src/main/java/promise/base/comment/Like.java
new file mode 100644
index 0000000..d42615b
--- /dev/null
+++ b/app/src/main/java/promise/base/comment/Like.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.base.comment;
+
+import android.annotation.SuppressLint;
+
+import org.jetbrains.annotations.NotNull;
+
+import promise.base.ID;
+import promise.base.post.Post;
+import promise.database.AddedEntity;
+import promise.database.Entity;
+import promise.database.HasOne;
+import promise.db.ActiveRecord;
+
+@SuppressLint("ParcelCreator")
+@Entity
+@AddedEntity(fromVersion = 1, toVersion = 2)
+public class Like extends ActiveRecord<Like> {
+	private ID uId;
+
+	@HasOne
+	private Post post;
+
+
+	@Override
+ 	public String toString(){
+		return 
+			"Comment{" +
+			",id = '" + uId + '\'' +
+
+			"}";
+		}
+
+	@NotNull
+	@Override
+	public Like getEntity() {
+		return this;
+	}
+
+	public ID getUId() {
+		return uId;
+	}
+
+	public void setUId(ID uId) {
+		this.uId = uId;
+	}
+
+	public void setPost(Post post) {
+		this.post = post;
+	}
+
+	public Post getPost() {
+		return post;
+	}
+}
diff --git a/app/src/main/java/promise/base/post/Post.java b/app/src/main/java/promise/base/post/Post.java
index e6005df..eb7a557 100644
--- a/app/src/main/java/promise/base/post/Post.java
+++ b/app/src/main/java/promise/base/post/Post.java
@@ -7,6 +7,7 @@
 import java.util.List;
 
 import promise.base.ID;
+import promise.base.comment.Like;
 import promise.base.comment.PostComment;
 import promise.base.photo.Photo;
 import promise.db.ActiveRecord;
@@ -39,6 +40,8 @@ public String toString() {
 	@HasMany
 	private List<Photo> photos;
 
+	@HasMany
+	private List<Like> likes;
 
 	public String getTitle(){
 		return title;
@@ -96,6 +99,14 @@ public void setPhotos(List<Photo> photos) {
 		this.photos = photos;
 	}
 
+	public List<Like> getLikes() {
+		return likes;
+	}
+
+	public void setLikes(List<Like> likes) {
+		this.likes = likes;
+	}
+
 	@NotNull
 	@Override
 	public Post getEntity() {
diff --git a/compiler/src/main/java/promise/database/ompiler/DatabaseEntityAnnotatedProcessor.kt b/compiler/src/main/java/promise/database/ompiler/DatabaseEntityAnnotatedProcessor.kt
index fa441bf..c01d839 100644
--- a/compiler/src/main/java/promise/database/ompiler/DatabaseEntityAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/database/ompiler/DatabaseEntityAnnotatedProcessor.kt
@@ -13,6 +13,7 @@
 
 package promise.database.ompiler
 
+import com.squareup.javapoet.AnnotationSpec
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.JavaFile
 import com.squareup.javapoet.MethodSpec
@@ -84,8 +85,12 @@ class DatabaseEntityAnnotatedProcessor(private val processingEnv: ProcessingEnvi
           .build()
     })
 
+    val supressWarningsSpec = AnnotationSpec.builder(SuppressWarnings::class.java)
+        .addMember("value" , "{\"unchecked\"}")
+
     classBuilder.superclass(ClassName.get(pack, className))
         .addAnnotation(databaseAnnotationSpec)
+        .addAnnotation(supressWarningsSpec.build())
         .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
         .addMethod(constructorMethod.build())
 
@@ -94,6 +99,7 @@ class DatabaseEntityAnnotatedProcessor(private val processingEnv: ProcessingEnvi
           .addModifiers(Modifier.PUBLIC)
           .returns(it.asTableClassName(processingEnv))
           .addCode(JavaUtils.generateGetTableStatement(processingEnv, it))
+          .addAnnotation(supressWarningsSpec.build())
           .build())
     }
 

From 352f8a37be145f2d190779fde140628df3495c89 Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Sat, 8 Aug 2020 05:43:06 +0300
Subject: [PATCH 17/34] added commons release

---
 compiler/build.gradle                                     | 2 +-
 database/build.gradle                                     | 2 +-
 database/src/main/java/promise/db/FastTable.kt            | 1 -
 database/src/main/java/promise/db/ReactiveFastDatabase.kt | 1 -
 database/src/main/java/promise/db/ReactiveTable.kt        | 1 -
 database/src/main/java/promise/db/TableCrud.kt            | 1 -
 6 files changed, 2 insertions(+), 6 deletions(-)

diff --git a/compiler/build.gradle b/compiler/build.gradle
index adcafd7..557ebab 100644
--- a/compiler/build.gradle
+++ b/compiler/build.gradle
@@ -19,7 +19,7 @@ apply plugin: 'kotlin-kapt'
 apply plugin: 'maven'
 
 dependencies {
-    compileOnly project(path: ':commons')
+    compileOnly 'com.github.android-promise.database:commons:1.0.3-alpha4'
     compileOnly files(Jvm.current().getToolsJar())
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
     implementation'org.atteo:evo-inflector:1.0.1'
diff --git a/database/build.gradle b/database/build.gradle
index 7453f2a..a8b2800 100644
--- a/database/build.gradle
+++ b/database/build.gradle
@@ -42,7 +42,7 @@ android {
 }
 
 dependencies {
-    api project(path: ':commons')
+    api 'com.github.android-promise.database:commons:1.0.3-alpha4'
     compileOnly 'io.reactivex.rxjava2:rxjava:2.2.17'
     compileOnly 'androidx.appcompat:appcompat:1.2.0'
     compileOnly 'com.github.android-promise:commons:1.1-beta02'
diff --git a/database/src/main/java/promise/db/FastTable.kt b/database/src/main/java/promise/db/FastTable.kt
index de9d425..a2fcc74 100644
--- a/database/src/main/java/promise/db/FastTable.kt
+++ b/database/src/main/java/promise/db/FastTable.kt
@@ -27,7 +27,6 @@ import promise.commons.model.List
 import promise.commons.model.List.fromArray
 import promise.commons.util.Conditions
 import promise.commons.util.DoubleConverter
-import promise.database.Number
 import promise.database.Table
 import promise.db.criteria.Criteria
 import promise.model.ITimeStamped
diff --git a/database/src/main/java/promise/db/ReactiveFastDatabase.kt b/database/src/main/java/promise/db/ReactiveFastDatabase.kt
index deffaa3..2f34735 100644
--- a/database/src/main/java/promise/db/ReactiveFastDatabase.kt
+++ b/database/src/main/java/promise/db/ReactiveFastDatabase.kt
@@ -23,7 +23,6 @@ import io.reactivex.Single
 import promise.commons.model.Identifiable
 import promise.commons.model.List
 import promise.commons.util.DoubleConverter
-import promise.database.Number
 import promise.model.IdentifiableList
 
 class ReactiveFastDatabase private constructor(
diff --git a/database/src/main/java/promise/db/ReactiveTable.kt b/database/src/main/java/promise/db/ReactiveTable.kt
index 3541b6b..78d5dfc 100644
--- a/database/src/main/java/promise/db/ReactiveTable.kt
+++ b/database/src/main/java/promise/db/ReactiveTable.kt
@@ -14,7 +14,6 @@ package promise.db
 
 import io.reactivex.Maybe
 import promise.commons.model.Identifiable
-import promise.database.Number
 import promise.model.IdentifiableList
 
 /**
diff --git a/database/src/main/java/promise/db/TableCrud.kt b/database/src/main/java/promise/db/TableCrud.kt
index e05f629..09b3b23 100644
--- a/database/src/main/java/promise/db/TableCrud.kt
+++ b/database/src/main/java/promise/db/TableCrud.kt
@@ -17,7 +17,6 @@ import android.database.Cursor
 import promise.commons.model.Identifiable
 import promise.commons.model.List
 import promise.commons.util.DoubleConverter
-import promise.database.Number
 import promise.model.IdentifiableList
 
 /**

From 5a5d8b0af1d55f8a12335878e6e0d7173e1a66c6 Mon Sep 17 00:00:00 2001
From: Peter Vincent <dev4vin@gmail.com>
Date: Sat, 8 Aug 2020 05:53:24 +0300
Subject: [PATCH 18/34] Update README.md

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index db1e09e..5385a86 100644
--- a/README.md
+++ b/README.md
@@ -468,8 +468,8 @@ android {
 
 dependencies {
      ...
-     implementation 'com.github.android-promise.database:androidpromisedatabase:1.0.2-beta6'
-     kapt 'com.github.android-promise.database:androidpromisedatabasecompiler:1.0.2-beta6'
+     implementation 'com.github.android-promise.database:database:1.0.3-alpha5'
+     kapt 'com.github.android-promise.database:compiler:1.0.3-alpha5'
      implementation 'com.github.android-promise:commons:1.1-alpha03'
 }
 ```

From 667140142f0a1f1fee9c5333e0658d38e213b517 Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Sun, 9 Aug 2020 17:25:01 +0300
Subject: [PATCH 19/34] prepare add androidx sqlite

---
 app/build.gradle                              |   1 -
 app/src/main/java/promise/base/AppDatabase.kt |   6 +-
 .../promise/base/comment/PostComment.java     |   2 +
 .../promise/base/comment/PostCommentDao.java  |  26 ++++
 .../comment/PostCommentToReplyRelation.java   |  46 ++++++
 .../promise/dbapp/DatabaseDependencies.kt     |  28 ++--
 .../main/java/promise/dbapp/MainActivity.kt   | 108 +++++++-------
 .../dbapp/test/PostCommentsDaoImpl.java       |  68 +++++++++
 .../src/main/java/promise/database/Child.kt   |  19 +++
 commons/src/main/java/promise/database/DAO.kt |  18 +++
 .../src/main/java/promise/database/Parent.kt  |  18 +++
 .../src/main/java/promise/database/Query.kt   |   2 +-
 .../main/java/promise/database/Relation.kt    |  18 +++
 compiler/build.gradle                         |   3 +-
 .../database/ompiler/DAOAnnotatedProcessor.kt | 135 ++++++++++++++++++
 .../DatabaseAbstractMethodsGenerator.kt       |  53 +++----
 .../ompiler/DatabaseAnnotationGenerator.kt    |   4 +-
 .../ompiler/EntityAnnotatedProcessor.kt       |   1 -
 .../ompiler/PromiseDatabaseCompiler.kt        |   6 +-
 .../database/ompiler/RelationsDaoProcessor.kt |   1 -
 .../TableDeserializerMethodGenerator.kt       |  17 +--
 .../TypeConverterAnnotatedProcessor.kt        |   2 +-
 .../database/ompiler/utils/JavaUtils.java     |   6 +
 database/build.gradle                         |   9 +-
 .../src/main/java/promise/db/DMLFunctions.kt  |   4 +
 .../src/main/java/promise/db/FastTable.kt     |  25 ++--
 26 files changed, 493 insertions(+), 133 deletions(-)
 create mode 100644 app/src/main/java/promise/base/comment/PostCommentDao.java
 create mode 100644 app/src/main/java/promise/base/comment/PostCommentToReplyRelation.java
 create mode 100644 app/src/main/java/promise/dbapp/test/PostCommentsDaoImpl.java
 create mode 100644 commons/src/main/java/promise/database/Child.kt
 create mode 100644 commons/src/main/java/promise/database/DAO.kt
 create mode 100644 commons/src/main/java/promise/database/Parent.kt
 create mode 100644 commons/src/main/java/promise/database/Relation.kt
 create mode 100644 compiler/src/main/java/promise/database/ompiler/DAOAnnotatedProcessor.kt

diff --git a/app/build.gradle b/app/build.gradle
index 7ae5417..4eb0d15 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -52,7 +52,6 @@ android {
 dependencies {
 
     implementation "com.android.support:recyclerview-v7:$supportLibVersion"
-
     implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
     implementation 'androidx.appcompat:appcompat:1.1.0'
diff --git a/app/src/main/java/promise/base/AppDatabase.kt b/app/src/main/java/promise/base/AppDatabase.kt
index 48e6a9b..a5ab05d 100644
--- a/app/src/main/java/promise/base/AppDatabase.kt
+++ b/app/src/main/java/promise/base/AppDatabase.kt
@@ -15,6 +15,7 @@ package promise.base
 
 import promise.base.comment.Like
 import promise.base.comment.PostComment
+import promise.base.comment.PostCommentDao
 import promise.base.photo.Photo
 import promise.base.post.Post
 import promise.base.todo.Todo
@@ -32,4 +33,7 @@ import promise.db.PromiseDatabase
     ]
 )
 abstract class AppDatabase(fastDatabase: FastDatabase)
-  : PromiseDatabase(fastDatabase)
+  : PromiseDatabase(fastDatabase) {
+
+  abstract fun getPostCommentsDao(): PostCommentDao
+}
diff --git a/app/src/main/java/promise/base/comment/PostComment.java b/app/src/main/java/promise/base/comment/PostComment.java
index 64cfa4a..0488fb2 100644
--- a/app/src/main/java/promise/base/comment/PostComment.java
+++ b/app/src/main/java/promise/base/comment/PostComment.java
@@ -18,6 +18,8 @@ public class PostComment extends ActiveRecord<PostComment> {
 	private String body;
 	private String email;
 
+	private String postCommentId;
+
 	@HasOne
 	private Post post;
 
diff --git a/app/src/main/java/promise/base/comment/PostCommentDao.java b/app/src/main/java/promise/base/comment/PostCommentDao.java
new file mode 100644
index 0000000..9bf6ff1
--- /dev/null
+++ b/app/src/main/java/promise/base/comment/PostCommentDao.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.base.comment;
+
+import java.util.List;
+
+import promise.database.DAO;
+import promise.db.criteria.Criteria;
+
+@DAO
+public abstract class PostCommentDao {
+
+  public abstract List<PostCommentToReplyRelation> getPostComments(Criteria criteria);
+
+}
diff --git a/app/src/main/java/promise/base/comment/PostCommentToReplyRelation.java b/app/src/main/java/promise/base/comment/PostCommentToReplyRelation.java
new file mode 100644
index 0000000..8061977
--- /dev/null
+++ b/app/src/main/java/promise/base/comment/PostCommentToReplyRelation.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.base.comment;
+
+import java.util.List;
+
+import promise.database.Child;
+import promise.database.Relation;
+import promise.database.Parent;
+
+@Relation
+public class PostCommentToReplyRelation {
+
+  @Parent
+  private PostComment postComment;
+
+  @Child(fieldRelatedToParent = "postCommentId")
+  private List<PostComment> postCommentReplies;
+
+  public PostComment getPostComment() {
+    return postComment;
+  }
+
+  public void setPostComment(PostComment postComment) {
+    this.postComment = postComment;
+  }
+
+  public List<PostComment> getPostCommentReplies() {
+    return postCommentReplies;
+  }
+
+  public void setPostCommentReplies(List<PostComment> postCommentReplies) {
+    this.postCommentReplies = postCommentReplies;
+  }
+}
diff --git a/app/src/main/java/promise/dbapp/DatabaseDependencies.kt b/app/src/main/java/promise/dbapp/DatabaseDependencies.kt
index c6b75a4..f75bdf0 100644
--- a/app/src/main/java/promise/dbapp/DatabaseDependencies.kt
+++ b/app/src/main/java/promise/dbapp/DatabaseDependencies.kt
@@ -14,22 +14,24 @@
 package promise.dbapp
 
 import dagger.Module
-import dagger.Provides
-import promise.base.AppDatabase
-import promise.base.AppDatabaseImpl
-import promise.base.post.PostRelationsDao
-import javax.inject.Singleton
+//import dagger.Provides
+//import promise.base.AppDatabase
+//import promise.base.AppDatabaseImpl
+//import promise.base.post.PostRelationsDao
+//import javax.inject.Singleton
 
 @Module
 object DatabaseDependencies {
+//
+// @Provides
+// @Singleton
+// @JvmStatic
+// fun provideAppDatabase(): AppDatabaseImpl = AppDatabaseImpl.createDatabase("blog_db")
+//
+// @Provides
+// @JvmStatic
+// fun providePostRelationsDao(appDatabase: AppDatabaseImpl): PostRelationsDao =
+//     appDatabase.postRelationsDao
 
-  @Provides
-  @Singleton
-  @JvmStatic
-  fun provideAppDatabase(): AppDatabaseImpl = AppDatabaseImpl.createDatabase("blog_db")
 
-  @Provides
-  @JvmStatic
-  fun providePostRelationsDao(appDatabase: AppDatabaseImpl): PostRelationsDao =
-      appDatabase.postRelationsDao
 }
\ No newline at end of file
diff --git a/app/src/main/java/promise/dbapp/MainActivity.kt b/app/src/main/java/promise/dbapp/MainActivity.kt
index 24414f8..2ee0007 100644
--- a/app/src/main/java/promise/dbapp/MainActivity.kt
+++ b/app/src/main/java/promise/dbapp/MainActivity.kt
@@ -17,19 +17,19 @@ import android.os.Bundle
 import com.google.android.material.snackbar.Snackbar
 import dagger.android.support.DaggerAppCompatActivity
 import kotlinx.android.synthetic.main.activity_main.*
-import kotlinx.android.synthetic.main.content_main.*
-import promise.base.ID
-import promise.base.comment.PostComment
-import promise.base.post.Post
-import promise.base.post.PostRelationsDao
-import promise.model.IdentifiableList
-import javax.inject.Inject
-import promise.commons.model.List
+//import kotlinx.android.synthetic.main.content_main.*
+//import promise.base.ID
+//import promise.base.comment.PostComment
+//import promise.base.post.Post
+//import promise.base.post.PostRelationsDao
+//import promise.model.IdentifiableList
+//import javax.inject.Inject
+//import promise.commons.model.List
 
 class MainActivity : DaggerAppCompatActivity() {
 
- @Inject
- lateinit var postRelationsDao: PostRelationsDao
+// @Inject
+// lateinit var postRelationsDao: PostRelationsDao
 
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
@@ -42,49 +42,49 @@ class MainActivity : DaggerAppCompatActivity() {
     }
   }
 
-  override fun onPostCreate(savedInstanceState: Bundle?) {
-    super.onPostCreate(savedInstanceState)
-  
-    val posts = IdentifiableList(List.generate(5) {
-      Post().apply {
-        uId = ID(it.toString())
-        title = "post".plus(it)
-        body = "body".plus(it)
-        userId = it
-        comments = List.generate(4) {
-          PostComment().apply {
-            name = "nm".repeat(it)
-            uId = ID((it + 1).toString())
-            body = "hbytcvbcrxgfvbtrxt"
-            email = "ejmail;jgfccghcfcvhbhcgvb"
-          }
-        }
-      }
-    })
-
-   postRelationsDao.saveWithComments(posts)
-
-    showInfo()
-
-    clear_button.setOnClickListener {
-      deleteInfo()
-      showInfo()
-    }
-  }
-
-  private fun showInfo() {
-
-    val persons = postRelationsDao.listWithComments()
-
-    complex_values_textview.text = persons.toString()
-  }
-
-  private fun deleteInfo() {
-    val persons = postRelationsDao.listWithComments()
-    persons.forEach {
-      postRelationsDao.deleteComments(it)
-      it.delete()
-    }
-  }
+//  override fun onPostCreate(savedInstanceState: Bundle?) {
+//    super.onPostCreate(savedInstanceState)
+//
+//    val posts = IdentifiableList(List.generate(5) {
+//      Post().apply {
+//        uId = ID(it.toString())
+//        title = "post".plus(it)
+//        body = "body".plus(it)
+//        userId = it
+//        comments = List.generate(4) {
+//          PostComment().apply {
+//            name = "nm".repeat(it)
+//            uId = ID((it + 1).toString())
+//            body = "hbytcvbcrxgfvbtrxt"
+//            email = "ejmail;jgfccghcfcvhbhcgvb"
+//          }
+//        }
+//      }
+//    })
+//
+//   postRelationsDao.saveWithComments(posts)
+//
+//    showInfo()
+//
+//    clear_button.setOnClickListener {
+//      deleteInfo()
+//      showInfo()
+//    }
+//  }
+//
+//  private fun showInfo() {
+//
+//    val persons = postRelationsDao.listWithComments()
+//
+//    complex_values_textview.text = persons.toString()
+//  }
+//
+//  private fun deleteInfo() {
+//    val persons = postRelationsDao.listWithComments()
+//    persons.forEach {
+//      postRelationsDao.deleteComments(it)
+//      it.delete()
+//    }
+//  }
 
 }
diff --git a/app/src/main/java/promise/dbapp/test/PostCommentsDaoImpl.java b/app/src/main/java/promise/dbapp/test/PostCommentsDaoImpl.java
new file mode 100644
index 0000000..1ff645e
--- /dev/null
+++ b/app/src/main/java/promise/dbapp/test/PostCommentsDaoImpl.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.dbapp.test;
+//
+//import android.database.Cursor;
+//
+//import java.util.ArrayList;
+//import java.util.List;
+//
+//import promise.base.comment.PostComment;
+//import promise.base.comment.PostCommentDao;
+//import promise.base.comment.PostCommentToReplyRelation;
+//import promise.base.comment.PostCommentsTable;
+//import promise.db.PromiseDatabase;
+//import promise.db.criteria.Criteria;
+//import promise.model.IdentifiableList;
+
+public class PostCommentsDaoImpl
+    //extends PostCommentDao
+{
+//
+//  private PromiseDatabase fastDatabase;
+//  private PostCommentsTable postCommentsTable;
+//
+//  public PostCommentsDaoImpl(PromiseDatabase fastDatabase) {
+//    this.fastDatabase = fastDatabase;
+//    this.postCommentsTable = (PostCommentsTable) fastDatabase.tableOf(PostComment.class);
+//  }
+//
+//  @Override
+//  public List<PostCommentToReplyRelation> getPostComments(Criteria andCriteria) {
+//    Cursor cursor = fastDatabase.getDatabaseInstance().query(
+//        postCommentsTable.queryBuilder()
+//            .whereAnd(andCriteria));
+//    return getPostCommentRepliesImpl(cursor);
+//  }
+//
+//  public List<PostComment> getPostCommentRepliesImpl(PostComment postComment) {
+//    return new ArrayList<>(postCommentsTable.findAll(PostCommentsTable.idColumn.with(postComment.getId())));
+//  }
+//
+//  private List<PostCommentToReplyRelation> getPostCommentRepliesImpl(Cursor cursor) {
+//    IdentifiableList<? extends PostComment> postComments = postCommentsTable.collection(cursor);
+//    return postComments.map(postComment -> new PostCommentToReplyRelation() {{
+//      setPostComment(postComment);
+//      setPostCommentReplies(getPostCommentRepliesImpl(postComment));
+//    }});
+//  }
+//
+//  private PostCommentToReplyRelation getPostCommentReplyImpl(Cursor cursor) {
+//    PostComment postComment = postCommentsTable.single(cursor);
+//    return new PostCommentToReplyRelation() {{
+//      setPostComment(postComment);
+//      setPostCommentReplies(getPostCommentRepliesImpl(postComment));
+//    }};
+//  }
+}
diff --git a/commons/src/main/java/promise/database/Child.kt b/commons/src/main/java/promise/database/Child.kt
new file mode 100644
index 0000000..79bed57
--- /dev/null
+++ b/commons/src/main/java/promise/database/Child.kt
@@ -0,0 +1,19 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.database
+
+@Target(AnnotationTarget.FIELD)
+@Retention(AnnotationRetention.SOURCE)
+annotation class Child(val fieldRelatedToParent: String,
+                       val parentRelatedField: String = "id")
\ No newline at end of file
diff --git a/commons/src/main/java/promise/database/DAO.kt b/commons/src/main/java/promise/database/DAO.kt
new file mode 100644
index 0000000..8da85ee
--- /dev/null
+++ b/commons/src/main/java/promise/database/DAO.kt
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.database
+
+@Target(AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.SOURCE)
+annotation class DAO
\ No newline at end of file
diff --git a/commons/src/main/java/promise/database/Parent.kt b/commons/src/main/java/promise/database/Parent.kt
new file mode 100644
index 0000000..efb32bb
--- /dev/null
+++ b/commons/src/main/java/promise/database/Parent.kt
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.database
+
+@Target(AnnotationTarget.FIELD)
+@Retention(AnnotationRetention.SOURCE)
+annotation class Parent
\ No newline at end of file
diff --git a/commons/src/main/java/promise/database/Query.kt b/commons/src/main/java/promise/database/Query.kt
index f8a61cf..82ad690 100644
--- a/commons/src/main/java/promise/database/Query.kt
+++ b/commons/src/main/java/promise/database/Query.kt
@@ -15,4 +15,4 @@ package promise.database
 
 @Target(AnnotationTarget.FUNCTION)
 @Retention(AnnotationRetention.SOURCE)
-annotation class Query(val value: String)
\ No newline at end of file
+annotation class Query(val where: String)
\ No newline at end of file
diff --git a/commons/src/main/java/promise/database/Relation.kt b/commons/src/main/java/promise/database/Relation.kt
new file mode 100644
index 0000000..a9bc2a2
--- /dev/null
+++ b/commons/src/main/java/promise/database/Relation.kt
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.database
+
+@Target(AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.SOURCE)
+annotation class Relation
\ No newline at end of file
diff --git a/compiler/build.gradle b/compiler/build.gradle
index 557ebab..b3fab05 100644
--- a/compiler/build.gradle
+++ b/compiler/build.gradle
@@ -19,7 +19,8 @@ apply plugin: 'kotlin-kapt'
 apply plugin: 'maven'
 
 dependencies {
-    compileOnly 'com.github.android-promise.database:commons:1.0.3-alpha4'
+    //compileOnly 'com.github.android-promise.database:commons:1.0.3-alpha4'
+    compileOnly project(path: ':commons')
     compileOnly files(Jvm.current().getToolsJar())
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
     implementation'org.atteo:evo-inflector:1.0.1'
diff --git a/compiler/src/main/java/promise/database/ompiler/DAOAnnotatedProcessor.kt b/compiler/src/main/java/promise/database/ompiler/DAOAnnotatedProcessor.kt
new file mode 100644
index 0000000..5487fbb
--- /dev/null
+++ b/compiler/src/main/java/promise/database/ompiler/DAOAnnotatedProcessor.kt
@@ -0,0 +1,135 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.database.ompiler
+
+import com.squareup.javapoet.AnnotationSpec
+import com.squareup.javapoet.ClassName
+import com.squareup.javapoet.JavaFile
+import com.squareup.javapoet.MethodSpec
+import com.squareup.javapoet.TypeSpec
+import org.jetbrains.annotations.NotNull
+import promise.database.DAO
+import promise.database.Parent
+import promise.database.Relation
+import promise.database.ompiler.utils.JavaUtils
+import promise.database.ompiler.utils.LogUtil
+import javax.annotation.processing.ProcessingEnvironment
+import javax.annotation.processing.RoundEnvironment
+import javax.lang.model.element.Element
+import javax.lang.model.element.ElementKind
+import javax.lang.model.element.Modifier
+import javax.lang.model.element.VariableElement
+import javax.lang.model.util.ElementFilter
+
+class DAOAnnotatedProcessor(private val processingEnv: ProcessingEnvironment) : AnnotatedClassProcessor() {
+  override fun process(environment: RoundEnvironment?): List<JavaFile.Builder?>? {
+    val javaFiles = ArrayList<JavaFile.Builder?>()
+    environment?.getElementsAnnotatedWith(DAO::class.java)
+        ?.forEach { element ->
+//          if (element.kind != ElementKind.CLASS ||
+//              element.kind != ElementKind.INTERFACE)
+//            LogUtil.e(Exception("Only classes can be annotated"), element)
+          if (!element.modifiers.contains(Modifier.ABSTRACT))
+            LogUtil.e(Exception("Class must be abstract"), element)
+//          if (element.enclosingElement != null)
+//            LogUtil.e(Exception("Class must not extend or implement any other class or interfaces"), element)
+          else javaFiles.add(processAnnotation(element))
+        }
+    return javaFiles
+  }
+
+  private fun processAnnotation(element: Element): JavaFile.Builder {
+
+    val className = element.simpleName.toString()
+    val pack = processingEnv.elementUtils.getPackageOf(element).toString()
+
+    val fileName = className + "Impl"
+
+    val classBuilder = TypeSpec.classBuilder(fileName)
+        .addModifiers(Modifier.PUBLIC)
+        .addMethod(MethodSpec.constructorBuilder()
+            .addModifiers(Modifier.PUBLIC)
+            .addParameter(
+                ClassName.get("promise.db", "PromiseDatabase")
+                    .annotated(AnnotationSpec.builder(NotNull::class.java).build()),
+                "promiseDatabase")
+            .build())
+    if (element.kind == ElementKind.INTERFACE) classBuilder.addSuperinterface(element.asType())
+    else if (element.kind == ElementKind.CLASS) classBuilder.superclass(element.asType())
+    val gen = """
+      //  private PromiseDatabase fastDatabase;
+      //  private PostCommentsTable postCommentsTable;
+      //
+      //  public PostCommentsDaoImpl(PromiseDatabase fastDatabase) {
+      //    this.fastDatabase = fastDatabase;
+      //    this.postCommentsTable = (PostCommentsTable) fastDatabase.tableOf(PostComment.class);
+      //  }
+      //
+      //  @Override
+      //  public List<PostCommentToReplyRelation> getPostComments(Criteria andCriteria) {
+      //    Cursor cursor = fastDatabase.getDatabaseInstance().query(
+      //        postCommentsTable.queryBuilder()
+      //            .whereAnd(andCriteria));
+      //    return getPostCommentRepliesImpl(cursor);
+      //  }
+      //
+      //  public List<PostComment> getPostCommentRepliesImpl(PostComment postComment) {
+      //    return new ArrayList<>(postCommentsTable.findAll(PostCommentsTable.idColumn.with(postComment.getId())));
+      //  }
+      //
+      //  private List<PostCommentToReplyRelation> getPostCommentRepliesImpl(Cursor cursor) {
+      //    IdentifiableList<? extends PostComment> postComments = postCommentsTable.collection(cursor);
+      //    return postComments.map(postComment -> new PostCommentToReplyRelation() {{
+      //      setPostComment(postComment);
+      //      setPostCommentReplies(getPostCommentRepliesImpl(postComment));
+      //    }});
+      //  }
+      //
+      //  private PostCommentToReplyRelation getPostCommentReplyImpl(Cursor cursor) {
+      //    PostComment postComment = postCommentsTable.single(cursor);
+      //    return new PostCommentToReplyRelation() {{
+      //      setPostComment(postComment);
+      //      setPostCommentReplies(getPostCommentRepliesImpl(postComment));
+      //    }};
+      //  }
+    """.trimIndent()
+    ElementFilter.methodsIn(element.enclosedElements).forEach { executableElement ->
+      val returnType = processingEnv.typeUtils.asElement(executableElement.returnType)
+      val relationType: Element
+      if (JavaUtils.isCollectionType(processingEnv, returnType as VariableElement?)) {
+        val typeMirrors = JavaUtils.getParameterizedTypeMirrors(returnType)
+        if (typeMirrors != null && typeMirrors.isNotEmpty()) {
+          relationType = processingEnv.typeUtils.asElement(typeMirrors[0])
+          if (relationType.getAnnotation(Relation::class.java) != null) {
+            var relationFields = ElementFilter.fieldsIn(relationType.enclosedElements);
+            val parentRelations = relationFields.filter {
+              it.getAnnotation(Parent::class.java) != null
+            }
+            if (parentRelations.size > 1) {
+              LogUtil.e(Exception("Relation classes can only have one field annotated with Parent"), relationType)
+            }
+            val parentRelation = parentRelations[0]
+
+
+          } else LogUtil.e(Exception("Class must be annotated as Relation"), relationType)
+        }
+      }
+      else {
+
+      }
+    }
+    return JavaFile.builder(pack, classBuilder.build())
+  }
+
+}
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/database/ompiler/DatabaseAbstractMethodsGenerator.kt b/compiler/src/main/java/promise/database/ompiler/DatabaseAbstractMethodsGenerator.kt
index c141deb..8704a09 100644
--- a/compiler/src/main/java/promise/database/ompiler/DatabaseAbstractMethodsGenerator.kt
+++ b/compiler/src/main/java/promise/database/ompiler/DatabaseAbstractMethodsGenerator.kt
@@ -20,9 +20,9 @@ import com.squareup.javapoet.ParameterizedTypeName
 import com.squareup.javapoet.TypeVariableName
 import com.squareup.javapoet.WildcardTypeName
 import org.jetbrains.annotations.NotNull
+import promise.database.DAO
 import promise.database.ompiler.utils.JavaUtils
 import promise.database.ompiler.utils.asTypeElement
-import promise.database.ompiler.utils.getTableClassNameString
 import promise.database.ompiler.utils.getTableEntities
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
@@ -31,7 +31,6 @@ import javax.lang.model.element.Modifier
 import javax.lang.model.element.TypeElement
 import javax.lang.model.type.TypeKind
 import javax.lang.model.util.ElementFilter
-import javax.tools.Diagnostic
 
 class DatabaseAbstractMethodsGenerator(
     private val element: TypeElement,
@@ -51,23 +50,15 @@ class DatabaseAbstractMethodsGenerator(
       it.parameters.isEmpty() && it.returnType.kind != TypeKind.VOID
     }.forEach { method ->
       val returnType = method.returnType
-      val methodName = method.simpleName
-
       val typeElement = returnType.asTypeElement(processingEnv)
-      val returnTypeName = method.returnType.toString()
-      val pack = processingEnv.elementUtils.getPackageOf(typeElement).toString()
-      processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "ReturnType: $pack $returnTypeName")
-      val className = ClassName.get(getPackage(element, returnTypeName), returnTypeName)
-      funSpecs.add(MethodSpec.methodBuilder(methodName.toString())
-          .addAnnotation(Override::class.java)
-          .addAnnotation(NotNull::class.java)
-          .addModifiers(Modifier.PUBLIC)
-          .returns(className)
-          .addCode(CodeBlock.builder()
-              .addStatement("return getDatabaseInstance().obtain(${className}.class)")
-              .build())
-          .build())
-
+      if (typeElement.getAnnotation(DAO::class.java) != null) {
+        val returnTypeName = method.returnType.toString()
+        val pack = processingEnv.elementUtils.getPackageOf(typeElement).toString()
+        val className = "${returnTypeName}Impl"
+        funSpecs.add(MethodSpec.overriding(method)
+            .addCode(JavaUtils.generateReturnDaoImplInstance(ClassName.get(pack, className)))
+            .build())
+      }
     }
 
     val codeBlock = CodeBlock.builder()
@@ -102,20 +93,18 @@ class DatabaseAbstractMethodsGenerator(
 
     return funSpecs
   }
-
-  private var entities: Array<TypeElement> = emptyArray()
-
-  private fun getPackage(element: TypeElement, returnTypeName: String): String {
-    if (entities.isEmpty()) entities = element.getTableEntities(processingEnv)
-    var pack = ""
-    entities.forEach {
-      if (returnTypeName == it.getTableClassNameString()) {
-        pack = processingEnv.elementUtils.getPackageOf(it).toString()
-      }
-    }
-    return pack
-
-  }
+//
+//  private fun getPackage(element: TypeElement, returnTypeName: String): String {
+//    if (entities.isEmpty()) entities = element.getTableEntities(processingEnv)
+//    var pack = ""
+//    entities.forEach {
+//      if (returnTypeName == it.getTableClassNameString()) {
+//        pack = processingEnv.elementUtils.getPackageOf(it).toString()
+//      }
+//    }
+//    return pack
+//
+//  }
 
 
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/database/ompiler/DatabaseAnnotationGenerator.kt b/compiler/src/main/java/promise/database/ompiler/DatabaseAnnotationGenerator.kt
index 2baccb4..a41b912 100644
--- a/compiler/src/main/java/promise/database/ompiler/DatabaseAnnotationGenerator.kt
+++ b/compiler/src/main/java/promise/database/ompiler/DatabaseAnnotationGenerator.kt
@@ -30,7 +30,7 @@ class DatabaseAnnotationGenerator(
 
   override fun generate(): AnnotationSpec {
     if (element is TypeElement) {
-      var stmt = " {\n"
+      var stmt = "{\n"
       var entities: Array<TypeElement>? = null
       try {
         entities = element.getTableEntities(processingEnv)
@@ -43,7 +43,7 @@ class DatabaseAnnotationGenerator(
           val className = entityClass.getTableClassNameString()
           stmt += "$className.class"
           if (index != entities.size - 1) {
-            stmt += ", \n"
+            stmt += ",\n"
           }
         }
         stmt += "\n}"
diff --git a/compiler/src/main/java/promise/database/ompiler/EntityAnnotatedProcessor.kt b/compiler/src/main/java/promise/database/ompiler/EntityAnnotatedProcessor.kt
index 43e966a..32cabb6 100644
--- a/compiler/src/main/java/promise/database/ompiler/EntityAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/database/ompiler/EntityAnnotatedProcessor.kt
@@ -40,7 +40,6 @@ class EntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment)
     val javaFiles = ArrayList<JavaFile.Builder?>()
     environment?.getElementsAnnotatedWith(Entity::class.java)
         ?.forEach { element ->
-          if (element.kind != ElementKind.CLASS) LogUtil.e(Exception("Only classes can be annotated"), element)
           val identifiableInterface = processingEnv.elementUtils.getTypeElement("promise.commons.model.Identifiable")
           val declaredInterface = JavaUtils.toWildCardType(processingEnv, identifiableInterface, 1)
           if (!JavaUtils.isSubTypeOfDeclaredType(processingEnv, element as TypeElement, declaredInterface))
diff --git a/compiler/src/main/java/promise/database/ompiler/PromiseDatabaseCompiler.kt b/compiler/src/main/java/promise/database/ompiler/PromiseDatabaseCompiler.kt
index d9762b3..4f3dd76 100644
--- a/compiler/src/main/java/promise/database/ompiler/PromiseDatabaseCompiler.kt
+++ b/compiler/src/main/java/promise/database/ompiler/PromiseDatabaseCompiler.kt
@@ -15,6 +15,7 @@ package promise.database.ompiler
 
 import com.google.auto.service.AutoService
 import com.squareup.javapoet.JavaFile
+import promise.database.DAO
 import promise.database.DatabaseEntity
 import promise.database.Entity
 import promise.database.TypeConverter
@@ -46,8 +47,8 @@ class PromiseDatabaseCompiler : AbstractProcessor() {
       processors.add(TypeConverterAnnotatedProcessor(processingEnv))
       processors.add(EntityAnnotatedProcessor(processingEnv))
       processors.add(RelationsDaoProcessor(processingEnv))
+      processors.add(DAOAnnotatedProcessor(processingEnv))
       processors.add(DatabaseEntityAnnotatedProcessor(processingEnv))
-
       processors.forEach {
         val builders = it.process(environment)
         if (builders != null) javaFiles.addAll(builders.filterNotNull())
@@ -88,7 +89,8 @@ class PromiseDatabaseCompiler : AbstractProcessor() {
   override fun getSupportedAnnotationTypes(): MutableSet<String> = mutableSetOf(
       Entity::class.java.name,
       DatabaseEntity::class.java.name,
-      TypeConverter::class.java.name
+      TypeConverter::class.java.name,
+      DAO::class.java.name
   )
 
   companion object {
diff --git a/compiler/src/main/java/promise/database/ompiler/RelationsDaoProcessor.kt b/compiler/src/main/java/promise/database/ompiler/RelationsDaoProcessor.kt
index 2510a7b..e815f85 100644
--- a/compiler/src/main/java/promise/database/ompiler/RelationsDaoProcessor.kt
+++ b/compiler/src/main/java/promise/database/ompiler/RelationsDaoProcessor.kt
@@ -39,7 +39,6 @@ class RelationsDaoProcessor(private val processingEnv: ProcessingEnvironment): A
     }
     if (fields.isNotEmpty())
       javaFiles.addAll(RelationsDaoGenerator(processingEnv, element as TypeElement, fields).generate())
-
     return javaFiles
   }
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/database/ompiler/TableDeserializerMethodGenerator.kt b/compiler/src/main/java/promise/database/ompiler/TableDeserializerMethodGenerator.kt
index 7652e34..2450d4f 100644
--- a/compiler/src/main/java/promise/database/ompiler/TableDeserializerMethodGenerator.kt
+++ b/compiler/src/main/java/promise/database/ompiler/TableDeserializerMethodGenerator.kt
@@ -17,15 +17,7 @@ import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
 import com.squareup.javapoet.MethodSpec
 import com.squareup.javapoet.TypeName
-import promise.database.ompiler.utils.ConverterTypes
-import promise.database.ompiler.utils.JavaUtils
-import promise.database.ompiler.utils.camelCase
-import promise.database.ompiler.utils.capitalizeFirst
-import promise.database.ompiler.utils.checkIfHasTypeConverter
-import promise.database.ompiler.utils.getConverterCompatibleMethod
-import promise.database.ompiler.utils.isElementAnnotatedAsRelation
-import promise.database.ompiler.utils.isSameAs
-import promise.database.ompiler.utils.toTypeName
+import promise.database.ompiler.utils.*
 import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
 
@@ -74,8 +66,11 @@ class TableDeserializerMethodGenerator(
       val executableFn = varType.getConverterCompatibleMethod(ConverterTypes.DESERIALIZER)
       if (executableFn != null)
         codeBlock.addStatement("$objectName.set${varName.capitalizeFirst()}(typeConverter.${executableFn.simpleName}(e.${getCursorReturn(TypeName.get(String::class.java))}(${colName}.getIndex(e))))")
-    } else if (varType.isElementAnnotatedAsRelation())
-      codeBlock.add(JavaUtils.generateDeserializerRelationSetStatement(objectName, varType, colName)) else codeBlock.addStatement("$objectName.set${varName.capitalizeFirst()}(e.${getCursorReturn(varType.toTypeName())}(${colName}.getIndex(e)))")
+    } else if (varType.isElementAnnotatedAsRelation()) {
+      codeBlock.add(JavaUtils.generateDeserializerRelationSetStatement(objectName, varType, colName))
+    } else {
+      codeBlock.addStatement("$objectName.set${varName.capitalizeFirst()}(e.${getCursorReturn(varType.toTypeName())}(${colName}.getIndex(e)))")
+    }
   }
 
   private fun getCursorReturn(varType: TypeName): String =
diff --git a/compiler/src/main/java/promise/database/ompiler/TypeConverterAnnotatedProcessor.kt b/compiler/src/main/java/promise/database/ompiler/TypeConverterAnnotatedProcessor.kt
index 5988915..d108525 100644
--- a/compiler/src/main/java/promise/database/ompiler/TypeConverterAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/database/ompiler/TypeConverterAnnotatedProcessor.kt
@@ -45,7 +45,7 @@ class TypeConverterAnnotatedProcessor(private val processingEnv: ProcessingEnvir
    val pack = processingEnv.elementUtils.getPackageOf(element).toString()
     return Utils.generateInstanceProviderHolder(ClassName.get(pack, className))
   }
-
+;
   companion object {
     var typeConverter: TypeElement? = null
   }
diff --git a/compiler/src/main/java/promise/database/ompiler/utils/JavaUtils.java b/compiler/src/main/java/promise/database/ompiler/utils/JavaUtils.java
index c3be0f0..43880a1 100644
--- a/compiler/src/main/java/promise/database/ompiler/utils/JavaUtils.java
+++ b/compiler/src/main/java/promise/database/ompiler/utils/JavaUtils.java
@@ -175,6 +175,12 @@ public static void generateDatabaseMigrationOverrideControlBlock(CodeBlock.Build
     codeBlock.beginControlFlow("public void onMigrate(FastDatabase database, $T sqLiteDatabase, int oldVersion, int newVersion)", ClassName.get("android.database.sqlite", "SQLiteDatabase"));
   }
 
+  public static CodeBlock generateReturnDaoImplInstance(ClassName daoImpl) {
+    return CodeBlock.builder()
+        .addStatement("return new $T(this)", daoImpl)
+        .build();
+  }
+
   // safe because both Long.class and long.class are of type Class<Long>
   @SuppressWarnings("unchecked")
   public static <T> Class<T> wrap(Class<T> c) {
diff --git a/database/build.gradle b/database/build.gradle
index a8b2800..4a494a2 100644
--- a/database/build.gradle
+++ b/database/build.gradle
@@ -31,7 +31,7 @@ android {
 
         release {
             minifyEnabled false
-            //proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
         }
     }
 
@@ -42,9 +42,12 @@ android {
 }
 
 dependencies {
-    api 'com.github.android-promise.database:commons:1.0.3-alpha4'
+    //api 'com.github.android-promise.database:commons:1.0.3-alpha4'
+    api project(path: ':commons')
+    implementation 'androidx.sqlite:sqlite:2.1.0'
+    implementation 'androidx.sqlite:sqlite-framework:2.1.0'
     compileOnly 'io.reactivex.rxjava2:rxjava:2.2.17'
-    compileOnly 'androidx.appcompat:appcompat:1.2.0'
+    implementation 'androidx.core:core-ktx:1.3.1'
     compileOnly 'com.github.android-promise:commons:1.1-beta02'
     testImplementation 'junit:junit:4.13'
     androidTestImplementation 'androidx.test:runner:1.2.0'
diff --git a/database/src/main/java/promise/db/DMLFunctions.kt b/database/src/main/java/promise/db/DMLFunctions.kt
index 7d1797c..2f38ade 100644
--- a/database/src/main/java/promise/db/DMLFunctions.kt
+++ b/database/src/main/java/promise/db/DMLFunctions.kt
@@ -28,6 +28,10 @@ interface DMLFunctions<T : Identifiable<Int>> {
 
   fun save(t: T): Long
 
+  fun single(cursor: Cursor): T
+
+  fun collection(cursor: Cursor): IdentifiableList<out T>
+
   fun saveAsync(t: T): Single<Long>
 
   fun save(list: IdentifiableList<out T>): Boolean
diff --git a/database/src/main/java/promise/db/FastTable.kt b/database/src/main/java/promise/db/FastTable.kt
index a2fcc74..b0102bd 100644
--- a/database/src/main/java/promise/db/FastTable.kt
+++ b/database/src/main/java/promise/db/FastTable.kt
@@ -97,6 +97,20 @@ abstract class FastTable<T : Identifiable<Int>>
 
   }
 
+  override fun single(cursor: Cursor): T {
+    cursor.moveToFirst()
+    return deserialize(cursor)
+  }
+
+  override fun collection(cursor: Cursor): IdentifiableList<out T> {
+    val collection = IdentifiableList<T>()
+    while (cursor.moveToNext()  && !cursor.isClosed) {
+      collection.add(getWithId(cursor))
+    }
+    cursor.close()
+    return collection
+  }
+
   open fun createEntityInstance(): T {
     throw RuntimeException("STUB ONLY SUPPORTED FOR ACTIVE RECORD ENTITIES")
   }
@@ -554,10 +568,7 @@ abstract class FastTable<T : Identifiable<Int>>
     val cursor: Cursor
     return try {
       cursor = x.rawQuery(builder.build(), builder.buildParameters())
-      val ts = IdentifiableList<T>()
-      while (cursor.moveToNext() && !cursor.isClosed) ts.add(getWithId(cursor))
-      cursor.close()
-      /*if (close) database.close();*/ts
+      collection(cursor)
     } catch (e: SQLiteException) {
       IdentifiableList<T>()
     }
@@ -583,11 +594,7 @@ abstract class FastTable<T : Identifiable<Int>>
         } else builder.orderByAscending(it)
       }
     }
-    val cursor = x.rawQuery(builder.build(), builder.buildParameters())
-    val ts = IdentifiableList<T>()
-    while (cursor.moveToNext() && !cursor.isClosed) ts.add(getWithId(cursor))
-    cursor.close()
-    /*database.close();*/return ts
+   return collection( x.rawQuery(builder.build(), builder.buildParameters()))
   }
 
   /**

From 419603fdc0f55fd91a5f288d47b2a9aa0e5600d3 Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Mon, 10 Aug 2020 10:09:18 +0300
Subject: [PATCH 20/34] migrated to sqlite framework

---
 app/src/main/java/promise/base/AppDatabase.kt |   2 +-
 .../promise/base/comment/PostComment.java     |  10 +-
 .../promise/base/comment/PostCommentDao.java  |   4 +-
 .../promise/dbapp/DatabaseDependencies.kt     |  29 +++--
 .../main/java/promise/dbapp/MainActivity.kt   | 108 +++++++++---------
 .../database/ompiler/DAOAnnotatedProcessor.kt |  50 ++++----
 .../DatabaseAbstractMethodsGenerator.kt       |   2 +-
 .../ompiler/PromiseDatabaseCompiler.kt        |   2 +-
 .../ompiler/TableMigrationFieldGenerator.kt   |   2 +-
 .../database/ompiler/utils/JavaUtils.java     |   3 +-
 database/build.gradle                         |   2 +-
 .../promise/db/DatabaseCreationCallback.kt    |   5 +-
 .../promise/db/DatabaseCursorFactory.java     |  39 -------
 .../src/main/java/promise/db/FastDatabase.kt  |  12 +-
 .../main/java/promise/db/FastDatabaseImpl.kt  |  71 ++++++------
 .../promise/db/FastDatabaseOpenHelper.java    |  75 ++++++------
 .../src/main/java/promise/db/FastTable.kt     |  93 +++++++--------
 .../src/main/java/promise/db/Migration.kt     |   3 +-
 .../java/promise/db/ReactiveFastDatabase.kt   |  46 ++++----
 19 files changed, 258 insertions(+), 300 deletions(-)
 delete mode 100644 database/src/main/java/promise/db/DatabaseCursorFactory.java

diff --git a/app/src/main/java/promise/base/AppDatabase.kt b/app/src/main/java/promise/base/AppDatabase.kt
index a5ab05d..7d514bf 100644
--- a/app/src/main/java/promise/base/AppDatabase.kt
+++ b/app/src/main/java/promise/base/AppDatabase.kt
@@ -35,5 +35,5 @@ import promise.db.PromiseDatabase
 abstract class AppDatabase(fastDatabase: FastDatabase)
   : PromiseDatabase(fastDatabase) {
 
-  abstract fun getPostCommentsDao(): PostCommentDao
+  //abstract fun getPostCommentsDao(): PostCommentDao
 }
diff --git a/app/src/main/java/promise/base/comment/PostComment.java b/app/src/main/java/promise/base/comment/PostComment.java
index 0488fb2..f5a1d76 100644
--- a/app/src/main/java/promise/base/comment/PostComment.java
+++ b/app/src/main/java/promise/base/comment/PostComment.java
@@ -18,7 +18,7 @@ public class PostComment extends ActiveRecord<PostComment> {
 	private String body;
 	private String email;
 
-	private String postCommentId;
+	private String postCommentId = "";
 
 	@HasOne
 	private Post post;
@@ -55,6 +55,14 @@ public void setPost(Post post) {
 		this.post = post;
 	}
 
+	public String getPostCommentId() {
+		return postCommentId;
+	}
+
+	public void setPostCommentId(String postCommentId) {
+		this.postCommentId = postCommentId;
+	}
+
 	@Override
  	public String toString(){
 		return 
diff --git a/app/src/main/java/promise/base/comment/PostCommentDao.java b/app/src/main/java/promise/base/comment/PostCommentDao.java
index 9bf6ff1..d702236 100644
--- a/app/src/main/java/promise/base/comment/PostCommentDao.java
+++ b/app/src/main/java/promise/base/comment/PostCommentDao.java
@@ -19,8 +19,8 @@
 import promise.db.criteria.Criteria;
 
 @DAO
-public abstract class PostCommentDao {
+public interface PostCommentDao {
 
-  public abstract List<PostCommentToReplyRelation> getPostComments(Criteria criteria);
+  List<PostCommentToReplyRelation> getPostComments(Criteria criteria);
 
 }
diff --git a/app/src/main/java/promise/dbapp/DatabaseDependencies.kt b/app/src/main/java/promise/dbapp/DatabaseDependencies.kt
index f75bdf0..7b91739 100644
--- a/app/src/main/java/promise/dbapp/DatabaseDependencies.kt
+++ b/app/src/main/java/promise/dbapp/DatabaseDependencies.kt
@@ -14,24 +14,23 @@
 package promise.dbapp
 
 import dagger.Module
-//import dagger.Provides
-//import promise.base.AppDatabase
-//import promise.base.AppDatabaseImpl
-//import promise.base.post.PostRelationsDao
-//import javax.inject.Singleton
+import dagger.Provides
+import promise.base.AppDatabaseImpl
+import promise.base.post.PostRelationsDao
+import javax.inject.Singleton
 
 @Module
 object DatabaseDependencies {
-//
-// @Provides
-// @Singleton
-// @JvmStatic
-// fun provideAppDatabase(): AppDatabaseImpl = AppDatabaseImpl.createDatabase("blog_db")
-//
-// @Provides
-// @JvmStatic
-// fun providePostRelationsDao(appDatabase: AppDatabaseImpl): PostRelationsDao =
-//     appDatabase.postRelationsDao
+
+ @Provides
+ @Singleton
+ @JvmStatic
+ fun provideAppDatabase(): AppDatabaseImpl = AppDatabaseImpl.createDatabase("blog_db")
+
+ @Provides
+ @JvmStatic
+ fun providePostRelationsDao(appDatabase: AppDatabaseImpl): PostRelationsDao =
+     appDatabase.postRelationsDao
 
 
 }
\ No newline at end of file
diff --git a/app/src/main/java/promise/dbapp/MainActivity.kt b/app/src/main/java/promise/dbapp/MainActivity.kt
index 2ee0007..ae7066c 100644
--- a/app/src/main/java/promise/dbapp/MainActivity.kt
+++ b/app/src/main/java/promise/dbapp/MainActivity.kt
@@ -17,19 +17,19 @@ import android.os.Bundle
 import com.google.android.material.snackbar.Snackbar
 import dagger.android.support.DaggerAppCompatActivity
 import kotlinx.android.synthetic.main.activity_main.*
-//import kotlinx.android.synthetic.main.content_main.*
-//import promise.base.ID
-//import promise.base.comment.PostComment
-//import promise.base.post.Post
-//import promise.base.post.PostRelationsDao
-//import promise.model.IdentifiableList
-//import javax.inject.Inject
-//import promise.commons.model.List
+import kotlinx.android.synthetic.main.content_main.*
+import promise.base.ID
+import promise.base.comment.PostComment
+import promise.base.post.Post
+import promise.base.post.PostRelationsDao
+import promise.model.IdentifiableList
+import javax.inject.Inject
+import promise.commons.model.List
 
 class MainActivity : DaggerAppCompatActivity() {
 
-// @Inject
-// lateinit var postRelationsDao: PostRelationsDao
+ @Inject
+ lateinit var postRelationsDao: PostRelationsDao
 
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
@@ -42,49 +42,49 @@ class MainActivity : DaggerAppCompatActivity() {
     }
   }
 
-//  override fun onPostCreate(savedInstanceState: Bundle?) {
-//    super.onPostCreate(savedInstanceState)
-//
-//    val posts = IdentifiableList(List.generate(5) {
-//      Post().apply {
-//        uId = ID(it.toString())
-//        title = "post".plus(it)
-//        body = "body".plus(it)
-//        userId = it
-//        comments = List.generate(4) {
-//          PostComment().apply {
-//            name = "nm".repeat(it)
-//            uId = ID((it + 1).toString())
-//            body = "hbytcvbcrxgfvbtrxt"
-//            email = "ejmail;jgfccghcfcvhbhcgvb"
-//          }
-//        }
-//      }
-//    })
-//
-//   postRelationsDao.saveWithComments(posts)
-//
-//    showInfo()
-//
-//    clear_button.setOnClickListener {
-//      deleteInfo()
-//      showInfo()
-//    }
-//  }
-//
-//  private fun showInfo() {
-//
-//    val persons = postRelationsDao.listWithComments()
-//
-//    complex_values_textview.text = persons.toString()
-//  }
-//
-//  private fun deleteInfo() {
-//    val persons = postRelationsDao.listWithComments()
-//    persons.forEach {
-//      postRelationsDao.deleteComments(it)
-//      it.delete()
-//    }
-//  }
+  override fun onPostCreate(savedInstanceState: Bundle?) {
+    super.onPostCreate(savedInstanceState)
+
+    val posts = IdentifiableList(List.generate(5) {
+      Post().apply {
+        uId = ID(it.toString())
+        title = "post".plus(it)
+        body = "body".plus(it)
+        userId = it
+        comments = List.generate(4) {
+          PostComment().apply {
+            name = "nm".repeat(it)
+            uId = ID((it + 1).toString())
+            body = "hbytcvbcrxgfvbtrxt"
+            email = "ejmail;jgfccghcfcvhbhcgvb"
+          }
+        }
+      }
+    })
+
+   postRelationsDao.saveWithComments(posts)
+
+    showInfo()
+
+    clear_button.setOnClickListener {
+      deleteInfo()
+      showInfo()
+    }
+  }
+
+  private fun showInfo() {
+
+    val persons = postRelationsDao.listWithComments()
+
+    complex_values_textview.text = persons.toString()
+  }
+
+  private fun deleteInfo() {
+    val persons = postRelationsDao.listWithComments()
+    persons.forEach {
+      postRelationsDao.deleteComments(it)
+      it.delete()
+    }
+  }
 
 }
diff --git a/compiler/src/main/java/promise/database/ompiler/DAOAnnotatedProcessor.kt b/compiler/src/main/java/promise/database/ompiler/DAOAnnotatedProcessor.kt
index 5487fbb..570c679 100644
--- a/compiler/src/main/java/promise/database/ompiler/DAOAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/database/ompiler/DAOAnnotatedProcessor.kt
@@ -104,31 +104,31 @@ class DAOAnnotatedProcessor(private val processingEnv: ProcessingEnvironment) :
       //    }};
       //  }
     """.trimIndent()
-    ElementFilter.methodsIn(element.enclosedElements).forEach { executableElement ->
-      val returnType = processingEnv.typeUtils.asElement(executableElement.returnType)
-      val relationType: Element
-      if (JavaUtils.isCollectionType(processingEnv, returnType as VariableElement?)) {
-        val typeMirrors = JavaUtils.getParameterizedTypeMirrors(returnType)
-        if (typeMirrors != null && typeMirrors.isNotEmpty()) {
-          relationType = processingEnv.typeUtils.asElement(typeMirrors[0])
-          if (relationType.getAnnotation(Relation::class.java) != null) {
-            var relationFields = ElementFilter.fieldsIn(relationType.enclosedElements);
-            val parentRelations = relationFields.filter {
-              it.getAnnotation(Parent::class.java) != null
-            }
-            if (parentRelations.size > 1) {
-              LogUtil.e(Exception("Relation classes can only have one field annotated with Parent"), relationType)
-            }
-            val parentRelation = parentRelations[0]
-
-
-          } else LogUtil.e(Exception("Class must be annotated as Relation"), relationType)
-        }
-      }
-      else {
-
-      }
-    }
+//    ElementFilter.methodsIn(element.enclosedElements).forEach { executableElement ->
+//      val returnType = processingEnv.typeUtils.asElement(executableElement.returnType)
+//      val relationType: Element
+//      if (JavaUtils.isCollectionType(processingEnv, returnType as VariableElement?)) {
+//        val typeMirrors = JavaUtils.getParameterizedTypeMirrors(returnType)
+//        if (typeMirrors != null && typeMirrors.isNotEmpty()) {
+//          relationType = processingEnv.typeUtils.asElement(typeMirrors[0])
+//          if (relationType.getAnnotation(Relation::class.java) != null) {
+//            var relationFields = ElementFilter.fieldsIn(relationType.enclosedElements);
+//            val parentRelations = relationFields.filter {
+//              it.getAnnotation(Parent::class.java) != null
+//            }
+//            if (parentRelations.size > 1) {
+//              LogUtil.e(Exception("Relation classes can only have one field annotated with Parent"), relationType)
+//            }
+//            val parentRelation = parentRelations[0]
+//
+//
+//          } else LogUtil.e(Exception("Class must be annotated as Relation"), relationType)
+//        }
+//      }
+//      else {
+//
+//      }
+//    }
     return JavaFile.builder(pack, classBuilder.build())
   }
 
diff --git a/compiler/src/main/java/promise/database/ompiler/DatabaseAbstractMethodsGenerator.kt b/compiler/src/main/java/promise/database/ompiler/DatabaseAbstractMethodsGenerator.kt
index 8704a09..4b81353 100644
--- a/compiler/src/main/java/promise/database/ompiler/DatabaseAbstractMethodsGenerator.kt
+++ b/compiler/src/main/java/promise/database/ompiler/DatabaseAbstractMethodsGenerator.kt
@@ -52,7 +52,7 @@ class DatabaseAbstractMethodsGenerator(
       val returnType = method.returnType
       val typeElement = returnType.asTypeElement(processingEnv)
       if (typeElement.getAnnotation(DAO::class.java) != null) {
-        val returnTypeName = method.returnType.toString()
+        val returnTypeName = typeElement.simpleName.toString()
         val pack = processingEnv.elementUtils.getPackageOf(typeElement).toString()
         val className = "${returnTypeName}Impl"
         funSpecs.add(MethodSpec.overriding(method)
diff --git a/compiler/src/main/java/promise/database/ompiler/PromiseDatabaseCompiler.kt b/compiler/src/main/java/promise/database/ompiler/PromiseDatabaseCompiler.kt
index 4f3dd76..5061ab9 100644
--- a/compiler/src/main/java/promise/database/ompiler/PromiseDatabaseCompiler.kt
+++ b/compiler/src/main/java/promise/database/ompiler/PromiseDatabaseCompiler.kt
@@ -47,7 +47,7 @@ class PromiseDatabaseCompiler : AbstractProcessor() {
       processors.add(TypeConverterAnnotatedProcessor(processingEnv))
       processors.add(EntityAnnotatedProcessor(processingEnv))
       processors.add(RelationsDaoProcessor(processingEnv))
-      processors.add(DAOAnnotatedProcessor(processingEnv))
+      //processors.add(DAOAnnotatedProcessor(processingEnv))
       processors.add(DatabaseEntityAnnotatedProcessor(processingEnv))
       processors.forEach {
         val builders = it.process(environment)
diff --git a/compiler/src/main/java/promise/database/ompiler/TableMigrationFieldGenerator.kt b/compiler/src/main/java/promise/database/ompiler/TableMigrationFieldGenerator.kt
index 91b421b..ae2d789 100644
--- a/compiler/src/main/java/promise/database/ompiler/TableMigrationFieldGenerator.kt
+++ b/compiler/src/main/java/promise/database/ompiler/TableMigrationFieldGenerator.kt
@@ -83,7 +83,7 @@ class TableMigrationFieldGenerator(
 
     return MethodSpec.methodBuilder("onUpgrade")
         .addParameter(
-            ClassName.get("android.database.sqlite", "SQLiteDatabase")
+            ClassName.get("androidx.sqlite.db", "SupportSQLiteDatabase")
                 .annotated(AnnotationSpec.builder(NotNull::class.java).build()),
             "x")
         .addParameter(Integer::class.javaPrimitiveType, "v1")
diff --git a/compiler/src/main/java/promise/database/ompiler/utils/JavaUtils.java b/compiler/src/main/java/promise/database/ompiler/utils/JavaUtils.java
index 43880a1..2e87050 100644
--- a/compiler/src/main/java/promise/database/ompiler/utils/JavaUtils.java
+++ b/compiler/src/main/java/promise/database/ompiler/utils/JavaUtils.java
@@ -172,7 +172,8 @@ public static void generateCatchSQliteExceptionBlockForDeserializer(CodeBlock.Bu
 
   public static void generateDatabaseMigrationOverrideControlBlock(CodeBlock.Builder codeBlock) {
     codeBlock.add("@Override \n");
-    codeBlock.beginControlFlow("public void onMigrate(FastDatabase database, $T sqLiteDatabase, int oldVersion, int newVersion)", ClassName.get("android.database.sqlite", "SQLiteDatabase"));
+    codeBlock.beginControlFlow("public void onMigrate(FastDatabase database, $T sqLiteDatabase, int oldVersion, int newVersion)",
+        ClassName.get("androidx.sqlite.db", "SupportSQLiteDatabase"));
   }
 
   public static CodeBlock generateReturnDaoImplInstance(ClassName daoImpl) {
diff --git a/database/build.gradle b/database/build.gradle
index 4a494a2..95f1aad 100644
--- a/database/build.gradle
+++ b/database/build.gradle
@@ -44,7 +44,7 @@ android {
 dependencies {
     //api 'com.github.android-promise.database:commons:1.0.3-alpha4'
     api project(path: ':commons')
-    implementation 'androidx.sqlite:sqlite:2.1.0'
+    api 'androidx.sqlite:sqlite:2.1.0'
     implementation 'androidx.sqlite:sqlite-framework:2.1.0'
     compileOnly 'io.reactivex.rxjava2:rxjava:2.2.17'
     implementation 'androidx.core:core-ktx:1.3.1'
diff --git a/database/src/main/java/promise/db/DatabaseCreationCallback.kt b/database/src/main/java/promise/db/DatabaseCreationCallback.kt
index b323880..dc38b00 100644
--- a/database/src/main/java/promise/db/DatabaseCreationCallback.kt
+++ b/database/src/main/java/promise/db/DatabaseCreationCallback.kt
@@ -14,11 +14,12 @@
 package promise.db
 
 import android.database.sqlite.SQLiteDatabase
+import androidx.sqlite.db.SupportSQLiteDatabase
 
 interface DatabaseCreationCallback {
 
-  fun beforeCreate(database: SQLiteDatabase)
+  fun beforeCreate(database: SupportSQLiteDatabase)
 
-  fun afterCreate(database: SQLiteDatabase)
+  fun afterCreate(database: SupportSQLiteDatabase)
 
 }
\ No newline at end of file
diff --git a/database/src/main/java/promise/db/DatabaseCursorFactory.java b/database/src/main/java/promise/db/DatabaseCursorFactory.java
deleted file mode 100644
index 04a258d..0000000
--- a/database/src/main/java/promise/db/DatabaseCursorFactory.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright 2017, Peter Vincent
- * Licensed under the Apache License, Version 2.0, Android Promise.
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package promise.db;
-
-import android.database.Cursor;
-import android.database.sqlite.SQLiteCursor;
-import android.database.sqlite.SQLiteCursorDriver;
-import android.database.sqlite.SQLiteDatabase;
-import android.database.sqlite.SQLiteQuery;
-
-public class DatabaseCursorFactory implements SQLiteDatabase.CursorFactory {
-
-  private Listener listener;
-
-  DatabaseCursorFactory(Listener listener) {
-    this.listener = listener;
-  }
-
-  @Override
-  public Cursor newCursor(SQLiteDatabase db, SQLiteCursorDriver masterQuery, String editTable, SQLiteQuery query) {
-    if (listener != null) listener.onLog(query.toString());
-    return new SQLiteCursor(masterQuery, editTable, query);
-  }
-
-  public interface Listener {
-    void onLog(String query);
-  }
-}
diff --git a/database/src/main/java/promise/db/FastDatabase.kt b/database/src/main/java/promise/db/FastDatabase.kt
index d545654..dbfbafd 100644
--- a/database/src/main/java/promise/db/FastDatabase.kt
+++ b/database/src/main/java/promise/db/FastDatabase.kt
@@ -17,29 +17,29 @@ import android.database.Cursor
 import android.database.DatabaseErrorHandler
 import android.database.sqlite.SQLiteDatabase
 import androidx.collection.ArrayMap
+import androidx.sqlite.db.SupportSQLiteDatabase
 import promise.commons.makeInstance
 import promise.commons.model.List
 import promise.commons.util.ClassUtil
 
 abstract class FastDatabase internal constructor(
     name: String?,
-    factory: SQLiteDatabase.CursorFactory?,
     version: Int,
-    errorHandler: DatabaseErrorHandler) : FastDatabaseOpenHelper(name, factory, version, errorHandler), Crud<SQLiteDatabase> {
+    errorHandler: DatabaseErrorHandler) : FastDatabaseOpenHelper(name, version, errorHandler), Crud<SupportSQLiteDatabase> {
 
-  abstract fun add(database: SQLiteDatabase, vararg tables: TableCrud<*, in SQLiteDatabase>): Boolean
+  abstract fun add(database: SupportSQLiteDatabase, vararg tables: TableCrud<*, in SupportSQLiteDatabase>): Boolean
 
-  abstract fun <T : TableCrud<*, in SQLiteDatabase>> obtain(tableClass: Class<out TableCrud<*, in SQLiteDatabase>>): T
+  abstract fun <T : TableCrud<*, in SupportSQLiteDatabase>> obtain(tableClass: Class<out TableCrud<*, in SupportSQLiteDatabase>>): T
 
   abstract fun querySql(sql: String): Cursor
 
   abstract fun query(queryBuilder: QueryBuilder): Cursor
 
-  abstract fun writableDatabase(): SQLiteDatabase
+  abstract fun writableDatabase(): SupportSQLiteDatabase
 
   abstract fun transact(block: FastDatabase.() -> Unit)
 
-  abstract fun delete(vararg tableCruds: TableCrud<*, in SQLiteDatabase>): Boolean
+  abstract fun delete(vararg tableCruds: TableCrud<*, in SupportSQLiteDatabase>): Boolean
 
   abstract fun name(): String
 
diff --git a/database/src/main/java/promise/db/FastDatabaseImpl.kt b/database/src/main/java/promise/db/FastDatabaseImpl.kt
index 78e7e8f..4c94b54 100644
--- a/database/src/main/java/promise/db/FastDatabaseImpl.kt
+++ b/database/src/main/java/promise/db/FastDatabaseImpl.kt
@@ -15,9 +15,9 @@ package promise.db
 import android.annotation.TargetApi
 import android.database.Cursor
 import android.database.DatabaseErrorHandler
-import android.database.sqlite.SQLiteDatabase
 import android.os.Build
 import androidx.collection.ArrayMap
+import androidx.sqlite.db.SupportSQLiteDatabase
 import promise.commons.createInstance
 import promise.commons.data.log.LogUtil
 import promise.commons.model.Identifiable
@@ -30,10 +30,9 @@ import java.util.*
 
 open class FastDatabaseImpl internal constructor(
     name: String?,
-    factory: SQLiteDatabase.CursorFactory?,
     version: Int,
     errorHandler: DatabaseErrorHandler)
-  : FastDatabase(name, factory, version, errorHandler) {
+  : FastDatabase(name, version, errorHandler) {
 
   private val cacheMap: ArrayMap<String, Any> = ArrayMap()
 
@@ -44,19 +43,17 @@ open class FastDatabaseImpl internal constructor(
   @TargetApi(Build.VERSION_CODES.HONEYCOMB)
   private constructor(name: String?,
                       version: Int,
-                      cursorListener: DatabaseCursorFactory.Listener?,
                       listener: Corrupt?) : this(
       name,
-      DatabaseCursorFactory(cursorListener),
       version,
       DatabaseErrorHandler {
         assert(listener != null)
         listener!!.onCorrupt()
       })
 
-  constructor(name: String?, version: Int) : this(name, version, null, null)
+  constructor(name: String?, version: Int) : this(name, version,  null)
 
-  final override fun onCreate(db: SQLiteDatabase) {
+  final override fun onCreate(db: SupportSQLiteDatabase) {
     if (databaseCreationCallback != null) {
       databaseCreationCallback!!.beforeCreate(db)
       create(db)
@@ -64,7 +61,7 @@ open class FastDatabaseImpl internal constructor(
     } else create(db)
   }
 
-  final override fun onUpgrade(database: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
+  final override fun onUpgrade(database: SupportSQLiteDatabase, oldVersion: Int, newVersion: Int) {
     LogUtil.d(TAG, "onUpgrade", oldVersion, newVersion)
     if (newVersion - oldVersion == 1)
       onUpgradeDatabase(database, oldVersion, newVersion)
@@ -78,7 +75,7 @@ open class FastDatabaseImpl internal constructor(
     upgradeTables(database, oldVersion, newVersion)
   }
 
-  private fun onUpgradeDatabase(database: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
+  private fun onUpgradeDatabase(database: SupportSQLiteDatabase, oldVersion: Int, newVersion: Int) {
     if (migration != null) migration!!.onMigrate(this, database, oldVersion, newVersion)
   }
 
@@ -86,12 +83,12 @@ open class FastDatabaseImpl internal constructor(
 
   private var tables: List<out FastTable<*>>? = null
 
-  protected fun tables(): List<TableCrud<*, in SQLiteDatabase>> =
+  protected fun tables(): List<TableCrud<*, in SupportSQLiteDatabase>> =
       Conditions.checkNotNull(tables, "tables not found for this database")
-          as List<TableCrud<*, in SQLiteDatabase>>
+          as List<TableCrud<*, in SupportSQLiteDatabase>>
 
-  override fun <T : TableCrud<*, in SQLiteDatabase>> obtain(tableClass: Class<out TableCrud<*, in SQLiteDatabase>>): T {
-    fun <T : TableCrud<*, in SQLiteDatabase>> makeTable(tableClass: Class<out TableCrud<*, in SQLiteDatabase>>): T {
+  override fun <T : TableCrud<*, in SupportSQLiteDatabase>> obtain(tableClass: Class<out TableCrud<*, in SupportSQLiteDatabase>>): T {
+    fun <T : TableCrud<*, in SupportSQLiteDatabase>> makeTable(tableClass: Class<out TableCrud<*, in SupportSQLiteDatabase>>): T {
       if (ClassUtil.hasAnnotation(tableClass, Table::class.java)) {
         val table = tableClass.getAnnotation(Table::class.java)!!
         if (cacheMap.containsKey(table.tableName)) return cacheMap[table.tableName] as T
@@ -125,7 +122,7 @@ open class FastDatabaseImpl internal constructor(
     return this
   }
 
-  private fun create(database: SQLiteDatabase) {
+  private fun create(database: SupportSQLiteDatabase) {
     var created = true
     for (table in Conditions.checkNotNull(tables())) created = try {
       created && create(table, database)
@@ -135,7 +132,7 @@ open class FastDatabaseImpl internal constructor(
     }
   }
 
-  private fun upgradeTables(database: SQLiteDatabase, v1: Int, v2: Int) {
+  private fun upgradeTables(database: SupportSQLiteDatabase, v1: Int, v2: Int) {
     for (table in Conditions.checkNotNull(tables())) try {
       if (v2 - v1 == 1)
         checkTableExist(table).onUpgrade(database, v1, v2)
@@ -152,7 +149,7 @@ open class FastDatabaseImpl internal constructor(
   }
 
   @SafeVarargs
-  override fun add(database: SQLiteDatabase, vararg tables: TableCrud<*, in SQLiteDatabase>): Boolean {
+  override fun add(database: SupportSQLiteDatabase, vararg tables: TableCrud<*, in SupportSQLiteDatabase>): Boolean {
     var created = true
     for (table in tables) {
       created = try {
@@ -165,8 +162,8 @@ open class FastDatabaseImpl internal constructor(
     return created
   }
 
-  private fun drop(database: SQLiteDatabase): Boolean {
-    /*for (Map.Entry<IndexCreated, Table<, SQLiteDatabase>> entry :
+  private fun drop(database: SupportSQLiteDatabase): Boolean {
+    /*for (Map.Entry<IndexCreated, Table<, SupportSQLiteDatabase>> entry :
         indexCreatedTableHashMap.entrySet()) {
       try {
         dropped = dropped && drop(checkTableExist(entry.getValue()), database);
@@ -178,7 +175,7 @@ open class FastDatabaseImpl internal constructor(
   }
 
   @Throws(DBError::class)
-  private fun create(tableCrud: TableCrud<*, in SQLiteDatabase>, database: SQLiteDatabase): Boolean {
+  private fun create(tableCrud: TableCrud<*, in SupportSQLiteDatabase>, database: SupportSQLiteDatabase): Boolean {
     try {
       tableCrud.onCreate(database)
     } catch (e: TableError) {
@@ -188,7 +185,7 @@ open class FastDatabaseImpl internal constructor(
   }
 
   @Throws(DBError::class)
-  private fun drop(tableCrud: TableCrud<*, in SQLiteDatabase>, database: SQLiteDatabase): Boolean {
+  private fun drop(tableCrud: TableCrud<*, in SupportSQLiteDatabase>, database: SupportSQLiteDatabase): Boolean {
     try {
       checkTableExist(tableCrud).onDrop(database)
     } catch (e: TableError) {
@@ -197,30 +194,30 @@ open class FastDatabaseImpl internal constructor(
     return true
   }
 
-  override fun writableDatabase(): SQLiteDatabase = writableDatabase
+  override fun writableDatabase(): SupportSQLiteDatabase = writableDatabase
 
   override fun querySql(sql: String): Cursor {
     LogUtil.d(TAG, "query: $sql")
-    return readableDatabase.rawQuery(sql, null)
+    return readableDatabase.query(sql, null)
   }
 
   override fun query(queryBuilder: QueryBuilder): Cursor {
     val sql = queryBuilder.build()
     val params = queryBuilder.buildParameters()
     LogUtil.d(TAG, "query: $sql", " params: " + Arrays.toString(params))
-    return readableDatabase.rawQuery(sql, params)
+    return readableDatabase.query(sql, params)
   }
 
-  override fun <T : Identifiable<Int>> find(tableCrud: TableCrud<T, in SQLiteDatabase>): TableCrud.Extras<T> =
+  override fun <T : Identifiable<Int>> find(tableCrud: TableCrud<T, in SupportSQLiteDatabase>): TableCrud.Extras<T> =
       checkTableExist(tableCrud).onFind(readableDatabase)
 
-  override fun <T : Identifiable<Int>> findAll(tableCrud: TableCrud<T, in SQLiteDatabase>): IdentifiableList<out T> =
+  override fun <T : Identifiable<Int>> findAll(tableCrud: TableCrud<T, in SupportSQLiteDatabase>): IdentifiableList<out T> =
       checkTableExist(tableCrud).onFindAll(readableDatabase, true)
 
-  override fun <T : Identifiable<Int>> update(t: T, tableCrud: TableCrud<T, in SQLiteDatabase>): Boolean =
+  override fun <T : Identifiable<Int>> update(t: T, tableCrud: TableCrud<T, in SupportSQLiteDatabase>): Boolean =
       checkTableExist(tableCrud).onUpdate(t, writableDatabase)
 
-  override fun <T : Identifiable<Int>> update(t: T, tableCrud: TableCrud<T, in SQLiteDatabase>, column: Column<*>): Boolean =
+  override fun <T : Identifiable<Int>> update(t: T, tableCrud: TableCrud<T, in SupportSQLiteDatabase>, column: Column<*>): Boolean =
       try {
         checkTableExist(tableCrud).onUpdate(t, writableDatabase, column)
       } catch (tableError: TableError) {
@@ -228,33 +225,33 @@ open class FastDatabaseImpl internal constructor(
         false
       }
 
-  override fun <T : Identifiable<Int>> findAll(tableCrud: TableCrud<T, in SQLiteDatabase>,
+  override fun <T : Identifiable<Int>> findAll(tableCrud: TableCrud<T, in SupportSQLiteDatabase>,
                                                vararg columns: Column<*>): IdentifiableList<out T> =
       checkTableExist(tableCrud).onFindAll(readableDatabase, *columns)
 
-  override fun <T : Identifiable<Int>> delete(tableCrud: TableCrud<T, in SQLiteDatabase>, t: T): Boolean =
+  override fun <T : Identifiable<Int>> delete(tableCrud: TableCrud<T, in SupportSQLiteDatabase>, t: T): Boolean =
       checkTableExist(tableCrud).onDelete(t, writableDatabase)
 
-  override fun delete(tableCrud: TableCrud<*, in SQLiteDatabase>, column: Column<*>): Boolean =
+  override fun delete(tableCrud: TableCrud<*, in SupportSQLiteDatabase>, column: Column<*>): Boolean =
       checkTableExist(tableCrud).onDelete(writableDatabase, column)
 
-  override fun delete(tableCrud: TableCrud<*, in SQLiteDatabase>): Boolean =
+  override fun delete(tableCrud: TableCrud<*, in SupportSQLiteDatabase>): Boolean =
       checkTableExist(tableCrud).onDelete(writableDatabase)
 
   @SafeVarargs
- override fun delete(vararg tableCruds: TableCrud<*, in SQLiteDatabase>): Boolean {
+ override fun delete(vararg tableCruds: TableCrud<*, in SupportSQLiteDatabase>): Boolean {
     var delete = true
     for (table in tableCruds) delete = delete && delete(table)
     return delete
   }
 
-  override fun <T> delete(tableCrud: TableCrud<*, in SQLiteDatabase>, column: Column<T>, list: List<out T>): Boolean =
+  override fun <T> delete(tableCrud: TableCrud<*, in SupportSQLiteDatabase>, column: Column<T>, list: List<out T>): Boolean =
       checkTableExist(tableCrud).onDelete(writableDatabase, column, list)
 
-  override fun <T : Identifiable<Int>> save(t: T, tableCrud: TableCrud<T, in SQLiteDatabase>): Long =
+  override fun <T : Identifiable<Int>> save(t: T, tableCrud: TableCrud<T, in SupportSQLiteDatabase>): Long =
       checkTableExist(tableCrud).onSave(t, writableDatabase)
 
-  override fun <T : Identifiable<Int>> save(list: IdentifiableList<out T>, tableCrud: TableCrud<T, in SQLiteDatabase>): Boolean =
+  override fun <T : Identifiable<Int>> save(list: IdentifiableList<out T>, tableCrud: TableCrud<T, in SupportSQLiteDatabase>): Boolean =
       checkTableExist(tableCrud).onSave(list, writableDatabase)
 
 
@@ -271,7 +268,7 @@ open class FastDatabaseImpl internal constructor(
     return deleted
   }
 
-  override fun getLastId(tableCrud: TableCrud<*, in SQLiteDatabase>): Int =
+  override fun getLastId(tableCrud: TableCrud<*, in SupportSQLiteDatabase>): Int =
       checkTableExist(tableCrud).onGetLastId(readableDatabase)
 
   override fun transact(block: FastDatabase.() -> Unit) = synchronized(this) {
@@ -285,7 +282,7 @@ open class FastDatabaseImpl internal constructor(
     }
   }
 
-  private fun <T : Identifiable<Int>> checkTableExist(tableCrud: TableCrud<T, in SQLiteDatabase>): TableCrud<T, in SQLiteDatabase> =
+  private fun <T : Identifiable<Int>> checkTableExist(tableCrud: TableCrud<T, in SupportSQLiteDatabase>): TableCrud<T, in SupportSQLiteDatabase> =
       Conditions.checkNotNull(tableCrud)
 
   companion object {
diff --git a/database/src/main/java/promise/db/FastDatabaseOpenHelper.java b/database/src/main/java/promise/db/FastDatabaseOpenHelper.java
index a118add..22c463d 100644
--- a/database/src/main/java/promise/db/FastDatabaseOpenHelper.java
+++ b/database/src/main/java/promise/db/FastDatabaseOpenHelper.java
@@ -14,76 +14,67 @@
 package promise.db;
 
 import android.database.DatabaseErrorHandler;
-import android.database.sqlite.SQLiteDatabase;
-import android.database.sqlite.SQLiteOpenHelper;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
+import androidx.sqlite.db.SupportSQLiteDatabase;
+import androidx.sqlite.db.SupportSQLiteOpenHelper;
+import androidx.sqlite.db.framework.FrameworkSQLiteOpenHelperFactory;
 
 import promise.commons.AndroidPromise;
 
-public abstract class FastDatabaseOpenHelper extends SQLiteOpenHelper {
+public abstract class FastDatabaseOpenHelper extends SupportSQLiteOpenHelper.Callback {
+
+  private SupportSQLiteOpenHelper helper;
+
+  private DatabaseErrorHandler errorHandler;
 
   public FastDatabaseOpenHelper(@Nullable String name,
-                                @Nullable SQLiteDatabase.CursorFactory factory,
                                 int version,
                                 @Nullable DatabaseErrorHandler errorHandler) {
-    super(AndroidPromise.instance().context(), name, factory, version, errorHandler);
+    super(version);
+    SupportSQLiteOpenHelper.Factory factory = new FrameworkSQLiteOpenHelperFactory();
+    this.errorHandler = errorHandler;
+    SupportSQLiteOpenHelper.Configuration configuration = SupportSQLiteOpenHelper.Configuration
+        .builder(AndroidPromise.instance().context())
+        .name(name)
+        .callback(this)
+        .build();
+
+    this.helper = factory.create(configuration);
+   // super(AndroidPromise.instance().context(), name, version, errorHandler);
+  }
+
+  public void onCorruption(SupportSQLiteDatabase db) {
+    //if (this.errorHandler != null) this.errorHandler.onCorruption(db);
   }
 
+
   @Override
-  public final void onConfigure(SQLiteDatabase db) {
+  public final void onConfigure(SupportSQLiteDatabase db) {
     super.onConfigure(db);
   }
 
   @Override
-  public final void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+  public final void onDowngrade(SupportSQLiteDatabase db, int oldVersion, int newVersion) {
     super.onDowngrade(db, oldVersion, newVersion);
   }
 
   @Override
-  public final void onOpen(SQLiteDatabase db) {
+  public final void onOpen(@NonNull SupportSQLiteDatabase db) {
     super.onOpen(db);
     db.execSQL("PRAGMA foreign_keys = ON");
   }
 
-  @Override
-  public final void setIdleConnectionTimeout(long idleConnectionTimeoutMs) {
-    super.setIdleConnectionTimeout(idleConnectionTimeoutMs);
-  }
-
-  @Override
-  public final void setLookasideConfig(int slotSize, int slotCount) {
-    super.setLookasideConfig(slotSize, slotCount);
+  public final SupportSQLiteDatabase getReadableDatabase() {
+    return helper.getReadableDatabase();
   }
 
-  @Override
-  public final void setOpenParams(@NonNull SQLiteDatabase.OpenParams openParams) {
-    super.setOpenParams(openParams);
+  public final SupportSQLiteDatabase getWritableDatabase() {
+    return helper.getWritableDatabase();
   }
 
-  @Override
-  public final void setWriteAheadLoggingEnabled(boolean enabled) {
-    super.setWriteAheadLoggingEnabled(enabled);
-  }
-
-  @Override
-  public final SQLiteDatabase getReadableDatabase() {
-    return super.getReadableDatabase();
-  }
-
-  @Override
-  public final SQLiteDatabase getWritableDatabase() {
-    return super.getWritableDatabase();
-  }
-
-  @Override
-  public final String getDatabaseName() {
-    return super.getDatabaseName();
-  }
-
-  @Override
-  public final synchronized void close() {
-    super.close();
+  public String getDatabaseName() {
+    return helper.getDatabaseName();
   }
 }
diff --git a/database/src/main/java/promise/db/FastTable.kt b/database/src/main/java/promise/db/FastTable.kt
index b0102bd..0e05687 100644
--- a/database/src/main/java/promise/db/FastTable.kt
+++ b/database/src/main/java/promise/db/FastTable.kt
@@ -16,9 +16,10 @@ import android.annotation.SuppressLint
 import android.content.ContentValues
 import android.database.Cursor
 import android.database.SQLException
-import android.database.sqlite.SQLiteDatabase
+import android.database.sqlite.SQLiteDatabase.CONFLICT_ROLLBACK
 import android.database.sqlite.SQLiteException
 import android.text.TextUtils
+import androidx.sqlite.db.SupportSQLiteDatabase
 import io.reactivex.Maybe
 import io.reactivex.Single
 import promise.commons.data.log.LogUtil
@@ -48,7 +49,7 @@ abstract class FastTable<T : Identifiable<Int>>
  * @param database
  */(
 
-    val database: FastDatabase) : TableCrud<T, SQLiteDatabase>, DMLFunctions<T> {
+    val database: FastDatabase) : TableCrud<T, SupportSQLiteDatabase>, DMLFunctions<T> {
 
   companion object {
     /**
@@ -201,7 +202,7 @@ abstract class FastTable<T : Identifiable<Int>>
     return "CREATE INDEX IF NOT EXISTS idx_${index} ON $nameOfTable $indexSql"
   }
 
-  fun addForeignKet(x: SQLiteDatabase,
+  fun addForeignKet(x: SupportSQLiteDatabase,
                     column: Column<*>,
                     referenceTable: String,
                     referenceColumn: Column<*>) {
@@ -228,7 +229,7 @@ abstract class FastTable<T : Identifiable<Int>>
    * @throws TableError if theirs a query error
    */
   @Throws(TableError::class)
-  override fun onCreate(x: SQLiteDatabase): Boolean {
+  override fun onCreate(x: SupportSQLiteDatabase): Boolean {
     var sql = CREATE_PREFIX
     /*
      * add the opening braces after select prefix, see {@link FastTable#CREATE_PREFIX}
@@ -272,9 +273,9 @@ abstract class FastTable<T : Identifiable<Int>>
    * @throws TableError
    */
   @Throws(TableError::class)
-  override fun onUpgrade(x: SQLiteDatabase, v1: Int, v2: Int) {
+  override fun onUpgrade(x: SupportSQLiteDatabase, v1: Int, v2: Int) {
     val builder: QueryBuilder = queryBuilder()
-    @SuppressLint("Recycle") val c = x.rawQuery(builder.build(), builder.buildParameters())
+    @SuppressLint("Recycle") val c = x.query(builder.build(), builder.buildParameters())
     val set: Set<String> = HashSet(fromArray(*c.columnNames))
     if (!set.contains(createdAt.name)) addColumns(x, createdAt)
     if (!set.contains(updatedAt.name)) addColumns(x, updatedAt)
@@ -288,7 +289,7 @@ abstract class FastTable<T : Identifiable<Int>>
    * @throws TableError if theirs an sql error
    */
   @Throws(TableError::class)
-  fun addColumns(database: SQLiteDatabase, vararg columns: Column<*>) {
+  fun addColumns(database: SupportSQLiteDatabase, vararg columns: Column<*>) {
     for (column in columns) {
       val alterSql = "$ALTER_COMMAND `$name` ADD $column;"
       try {
@@ -301,7 +302,7 @@ abstract class FastTable<T : Identifiable<Int>>
   }
 
   @Throws(TableError::class)
-  private fun addCompoundIndices(database: SQLiteDatabase, indexes: Array<Table.CompoundIndex>) {
+  private fun addCompoundIndices(database: SupportSQLiteDatabase, indexes: Array<Table.CompoundIndex>) {
     indexes.forEach {
       val indexSql = generateCompoundIndexQuery(it)
       LogUtil.d(TAG, indexSql)
@@ -309,7 +310,7 @@ abstract class FastTable<T : Identifiable<Int>>
     }
   }
 
-  private fun addIndices(database: SQLiteDatabase, indexes: Array<Table.Index>) {
+  private fun addIndices(database: SupportSQLiteDatabase, indexes: Array<Table.Index>) {
     indexes.forEach {
       val indexSql = generateIndexQueryForTableIndex(it)
       LogUtil.d(TAG, indexSql)
@@ -317,7 +318,7 @@ abstract class FastTable<T : Identifiable<Int>>
     }
   }
 
-  fun addIndex(database: SQLiteDatabase, index: String) {
+  fun addIndex(database: SupportSQLiteDatabase, index: String) {
     val indexSql: String = generateIndexQuery(index)
     LogUtil.d(TAG, indexSql)
     database.execSQL(indexSql)
@@ -332,7 +333,7 @@ abstract class FastTable<T : Identifiable<Int>>
    * @throws TableError if theirs an sql error
    */
   @Throws(TableError::class)
-  fun dropColumns(database: SQLiteDatabase, vararg columns: Column<*>): Boolean {
+  fun dropColumns(database: SupportSQLiteDatabase, vararg columns: Column<*>): Boolean {
     for (column in columns) {
       val alterSql = ALTER_COMMAND + " `" + name + "` " + "DROP COLUMN " + column.name + ";"
       try {
@@ -543,7 +544,7 @@ abstract class FastTable<T : Identifiable<Int>>
    * @param x readable sql database
    * @return an extras instance for more concise reads
    */
-  override fun onFind(x: SQLiteDatabase): TableCrud.Extras<T> =
+  override fun onFind(x: SupportSQLiteDatabase): TableCrud.Extras<T> =
       object : QueryExtras<T>(x) {
         /**
          *
@@ -563,11 +564,11 @@ abstract class FastTable<T : Identifiable<Int>>
    * @param close    close the connection if this is true
    * @return a list of records
    */
-  override fun onFindAll(x: SQLiteDatabase, close: Boolean): IdentifiableList<out T> {
+  override fun onFindAll(x: SupportSQLiteDatabase, close: Boolean): IdentifiableList<out T> {
     val builder: QueryBuilder = queryBuilder()
     val cursor: Cursor
     return try {
-      cursor = x.rawQuery(builder.build(), builder.buildParameters())
+      cursor = x.query(builder.build(), builder.buildParameters())
       collection(cursor)
     } catch (e: SQLiteException) {
       IdentifiableList<T>()
@@ -584,7 +585,7 @@ abstract class FastTable<T : Identifiable<Int>>
    * @param column  the fields to infer where and order by conditions
    * @return list of records satisfying the criteria
    */
-  override fun onFindAll(x: SQLiteDatabase, vararg column: Column<*>): IdentifiableList<out T> {
+  override fun onFindAll(x: SupportSQLiteDatabase, vararg column: Column<*>): IdentifiableList<out T> {
     val builder: QueryBuilder = queryBuilder().takeAll()
     column.forEach {
       if (it.value() != null) builder.whereAnd(Criteria.equals(it, it.value()))
@@ -594,7 +595,7 @@ abstract class FastTable<T : Identifiable<Int>>
         } else builder.orderByAscending(it)
       }
     }
-   return collection( x.rawQuery(builder.build(), builder.buildParameters()))
+   return collection( x.query(builder.build(), builder.buildParameters()))
   }
 
   /**
@@ -606,13 +607,13 @@ abstract class FastTable<T : Identifiable<Int>>
    * @return true if instance is updated
    */
   @Throws(TableError::class)
-  override fun onUpdate(t: T, x: SQLiteDatabase, column: Column<*>): Boolean {
+  override fun onUpdate(t: T, x: SupportSQLiteDatabase, column: Column<*>): Boolean {
     val whereArg: String = if (column.operand != null && column.value() != null)
       column.name + column.operand + column.value()
     else throw TableError("Cant update the record, missing updating information")
     val values = serialize(t)
     values.put(updatedAt.name, System.currentTimeMillis())
-    return x.update(name, values, whereArg, null) >= 0
+    return x.update(name, CONFLICT_ROLLBACK, values, whereArg, null) > 0;
   }
 
   /**
@@ -622,7 +623,7 @@ abstract class FastTable<T : Identifiable<Int>>
    * @param x writable sql database
    * @return true if updated
    */
-  override fun onUpdate(t: T, x: SQLiteDatabase): Boolean = try {
+  override fun onUpdate(t: T, x: SupportSQLiteDatabase): Boolean = try {
     onUpdate(t, x, id.with(t.getId()))
   } catch (tableError: TableError) {
     false
@@ -638,7 +639,7 @@ abstract class FastTable<T : Identifiable<Int>>
    * @param <C>      the type of matching, must not be derived data type
    * @return true if all rows are deleted
   </C> */
-  override fun <C> onDelete(x: SQLiteDatabase, column: Column<C>, list: List<out C>): Boolean {
+  override fun <C> onDelete(x: SupportSQLiteDatabase, column: Column<C>, list: List<out C>): Boolean {
     val deleted: Boolean
     var where = ""
     var i = 0
@@ -661,7 +662,7 @@ abstract class FastTable<T : Identifiable<Int>>
    * @param column   field to match
    * @return true if row is deleted
    */
-  override fun onDelete(x: SQLiteDatabase, column: Column<*>): Boolean {
+  override fun onDelete(x: SupportSQLiteDatabase, column: Column<*>): Boolean {
     val where = column.name + column.operand + column.value()
     return x.delete(name, where, null) >= 0
   }
@@ -673,7 +674,7 @@ abstract class FastTable<T : Identifiable<Int>>
    * @param x writable sql database
    * @return true if item is deleted
    */
-  override fun onDelete(t: T, x: SQLiteDatabase): Boolean =
+  override fun onDelete(t: T, x: SupportSQLiteDatabase): Boolean =
       onDelete(x, id.with(t.getId()))
 
   /**
@@ -682,7 +683,7 @@ abstract class FastTable<T : Identifiable<Int>>
    * @param x writable sql database
    * @return true if all rows are deleted
    */
-  override fun onDelete(x: SQLiteDatabase): Boolean =
+  override fun onDelete(x: SupportSQLiteDatabase): Boolean =
       !TextUtils.isEmpty(name) && x.delete(name, null, null) >= 0
 
   /**
@@ -693,12 +694,12 @@ abstract class FastTable<T : Identifiable<Int>>
    * @param x writable sql database
    * @return id of the row affected
    */
-  override fun onSave(t: T, x: SQLiteDatabase): Long {
+  override fun onSave(t: T, x: SupportSQLiteDatabase): Long {
     if (t.getId() != 0 && onUpdate(t, x)) return t.getId().toLong()
     val values = serialize(t)
     values.put(createdAt.name, System.currentTimeMillis())
     values.put(updatedAt.name, System.currentTimeMillis())
-    return x.insert(name, null, values)
+    return x.insert(name, CONFLICT_ROLLBACK, values)
   }
 
   /**
@@ -708,7 +709,7 @@ abstract class FastTable<T : Identifiable<Int>>
    * @param x writable sql database
    * @return true if all the items are saved
    */
-  override fun onSave(list: IdentifiableList<out T>, x: SQLiteDatabase): Boolean {
+  override fun onSave(list: IdentifiableList<out T>, x: SupportSQLiteDatabase): Boolean {
     var saved = true
     var i = 0
     val listSize = list.size
@@ -728,7 +729,7 @@ abstract class FastTable<T : Identifiable<Int>>
    * @throws TableError if theirs an sql error
    */
   @Throws(TableError::class)
-  override fun onDrop(x: SQLiteDatabase): Boolean {
+  override fun onDrop(x: SupportSQLiteDatabase): Boolean {
     val sql = "$DROP_PREFIX$name;"
     try {
       x.execSQL(sql)
@@ -745,9 +746,9 @@ abstract class FastTable<T : Identifiable<Int>>
    * @param x readable sql database
    * @return the id
    */
-  override fun onGetLastId(x: SQLiteDatabase): Int {
+  override fun onGetLastId(x: SupportSQLiteDatabase): Int {
     val builder: QueryBuilder = queryBuilder().select(Projection.count(id).`as`("num"))
-    @SuppressLint("Recycle") val cursor = x.rawQuery(builder.build(), builder.buildParameters())
+    @SuppressLint("Recycle") val cursor = x.query(builder.build(), builder.buildParameters())
     return cursor.getInt(id.index)
   }
 
@@ -756,7 +757,7 @@ abstract class FastTable<T : Identifiable<Int>>
    *
    * @param database readable database instance
    */
-  fun backup(database: SQLiteDatabase) {
+  fun backup(database: SupportSQLiteDatabase) {
     backup = IdentifiableList()
     backup!!.addAll(onFindAll(database, false))
   }
@@ -766,7 +767,7 @@ abstract class FastTable<T : Identifiable<Int>>
    *
    * @param database writable database
    */
-  fun restore(database: SQLiteDatabase) {
+  fun restore(database: SupportSQLiteDatabase) {
     if (backup != null && !backup!!.isEmpty()) {
       onSave(backup!!, database)
       backup!!.clear()
@@ -804,9 +805,9 @@ abstract class FastTable<T : Identifiable<Int>>
       /**
        * the database instance to readAsync fromm
        */
-      private val database: SQLiteDatabase) : TableCrud.Extras<Q>, DoubleConverter<Q, Cursor, ContentValues> {
+      private val database: SupportSQLiteDatabase) : TableCrud.Extras<Q>, DoubleConverter<Q, Cursor, ContentValues> {
 
-    fun database(): SQLiteDatabase = database
+    fun database(): SupportSQLiteDatabase = database
 
     /**
      * get a record pre populated with id and timestamps from each readAsync
@@ -836,7 +837,7 @@ abstract class FastTable<T : Identifiable<Int>>
       val cursor: Cursor
       return try {
         val builder: QueryBuilder = queryBuilder().take(1)
-        cursor = database.rawQuery(builder.build(), builder.buildParameters())
+        cursor = database.query(builder.build(), builder.buildParameters())
         cursor.moveToFirst()
         getWithId(cursor)
       } catch (e: SQLiteException) {
@@ -854,7 +855,7 @@ abstract class FastTable<T : Identifiable<Int>>
       val cursor: Cursor
       return try {
         val builder: QueryBuilder = queryBuilder().orderByDescending(id).take(1)
-        cursor = database.rawQuery(builder.build(), builder.buildParameters())
+        cursor = database.query(builder.build(), builder.buildParameters())
         cursor.moveToFirst()
         getWithId(cursor)
       } catch (e: SQLiteException) {
@@ -872,7 +873,7 @@ abstract class FastTable<T : Identifiable<Int>>
       val cursor: Cursor
       return try {
         val builder: QueryBuilder = queryBuilder().takeAll()
-        cursor = database.rawQuery(builder.build(), builder.buildParameters())
+        cursor = database.query(builder.build(), builder.buildParameters())
         val ts = IdentifiableList<Q>()
         while (cursor.moveToNext() && !cursor.isClosed) ts.add(getWithId(cursor))
         ts
@@ -891,7 +892,7 @@ abstract class FastTable<T : Identifiable<Int>>
       val cursor: Cursor
       return try {
         val builder: QueryBuilder = queryBuilder().take(limit)
-        cursor = database.rawQuery(builder.build(), builder.buildParameters())
+        cursor = database.query(builder.build(), builder.buildParameters())
         val ts = IdentifiableList<Q>()
         while (cursor.moveToNext() && !cursor.isClosed) ts.add(getWithId(cursor))
         ts
@@ -912,7 +913,7 @@ abstract class FastTable<T : Identifiable<Int>>
       val cursor: Cursor
       return try {
         val builder: QueryBuilder = queryBuilder().take(limit).skip(skip)
-        cursor = database.rawQuery(builder.build(), builder.buildParameters())
+        cursor = database.query(builder.build(), builder.buildParameters())
         val ts = IdentifiableList<Q>()
         while (cursor.moveToNext() && !cursor.isClosed) ts.add(getWithId(cursor))
         ts
@@ -926,7 +927,7 @@ abstract class FastTable<T : Identifiable<Int>>
       val cursor: Cursor
       return try {
         val builder: QueryBuilder = queryBuilder().orderByDescending(id).take(limit).skip(skip)
-        cursor = database.rawQuery(builder.build(), builder.buildParameters())
+        cursor = database.query(builder.build(), builder.buildParameters())
         val ts = IdentifiableList<Q>()
         while (cursor.moveToNext() && !cursor.isClosed) ts.add(getWithId(cursor))
         ts
@@ -948,7 +949,7 @@ abstract class FastTable<T : Identifiable<Int>>
       val cursor: Cursor
       return try {
         val builder: QueryBuilder = queryBuilder().takeAll().whereAnd(Criteria.between(column, a, b))
-        cursor = database.rawQuery(builder.build(), builder.buildParameters())
+        cursor = database.query(builder.build(), builder.buildParameters())
         val ts = IdentifiableList<Q>()
         while (cursor.moveToNext() && !cursor.isClosed) ts.add(getWithId(cursor))
         ts
@@ -969,7 +970,7 @@ abstract class FastTable<T : Identifiable<Int>>
       return try {
         val builder: QueryBuilder = queryBuilder().takeAll()
         for (column1 in column) if (column1.value() != null) builder.whereAnd(Criteria.equals(column1, column1.value()))
-        cursor = database.rawQuery(builder.build(), builder.buildParameters())
+        cursor = database.query(builder.build(), builder.buildParameters())
         val ts = IdentifiableList<Q>()
         while (cursor.moveToNext() && !cursor.isClosed) ts.add(getWithId(cursor))
         ts
@@ -994,7 +995,7 @@ abstract class FastTable<T : Identifiable<Int>>
       val builder: QueryBuilder = queryBuilder().takeAll()
           .whereAnd(Criteria.notIn(column, items))
       return try {
-        cursor = database.rawQuery(builder.build(), builder.buildParameters())
+        cursor = database.query(builder.build(), builder.buildParameters())
         val ts = IdentifiableList<Q>()
         while (cursor.moveToNext() && !cursor.isClosed) {
           val t = getWithId(cursor)
@@ -1019,7 +1020,7 @@ abstract class FastTable<T : Identifiable<Int>>
       val builder: QueryBuilder = queryBuilder().takeAll()
       for (column1 in column) builder.whereAnd(Criteria.contains(column1, column1.value().toString()))
       return try {
-        cursor = database.rawQuery(builder.build(), builder.buildParameters())
+        cursor = database.query(builder.build(), builder.buildParameters())
         val ts = IdentifiableList<Q>()
         while (cursor.moveToNext() && !cursor.isClosed) {
           val t = getWithId(cursor)
@@ -1046,7 +1047,7 @@ abstract class FastTable<T : Identifiable<Int>>
         builder.orderByDescending(column)
       } else builder.orderByAscending(column)
       return try {
-        cursor = database.rawQuery(builder.build(), builder.buildParameters())
+        cursor = database.query(builder.build(), builder.buildParameters())
         val ts = IdentifiableList<Q>()
         while (cursor.moveToNext() && !cursor.isClosed) {
           val t = getWithId(cursor)
@@ -1070,7 +1071,7 @@ abstract class FastTable<T : Identifiable<Int>>
       val cursor: Cursor
       val builder: QueryBuilder = queryBuilder().takeAll().groupBy(column)
       return try {
-        cursor = database.rawQuery(builder.build(), builder.buildParameters())
+        cursor = database.query(builder.build(), builder.buildParameters())
         val ts = IdentifiableList<Q>()
         while (cursor.moveToNext() && !cursor.isClosed) {
           val t = getWithId(cursor)
@@ -1098,7 +1099,7 @@ abstract class FastTable<T : Identifiable<Int>>
         builder.orderByDescending(column1)
       } else builder.orderByAscending(column1)
       return try {
-        cursor = database.rawQuery(builder.build(), builder.buildParameters())
+        cursor = database.query(builder.build(), builder.buildParameters())
         val ts = IdentifiableList<Q>()
         while (cursor.moveToNext() && !cursor.isClosed) {
           val t = getWithId(cursor)
diff --git a/database/src/main/java/promise/db/Migration.kt b/database/src/main/java/promise/db/Migration.kt
index eb6f625..4373b61 100644
--- a/database/src/main/java/promise/db/Migration.kt
+++ b/database/src/main/java/promise/db/Migration.kt
@@ -14,10 +14,11 @@
 package promise.db
 
 import android.database.sqlite.SQLiteDatabase
+import androidx.sqlite.db.SupportSQLiteDatabase
 
 interface Migration {
   fun onMigrate(database: FastDatabase,
-                sqLiteDatabase: SQLiteDatabase,
+                sqLiteDatabase: SupportSQLiteDatabase,
                 oldVersion: Int,
                 newVersion: Int)
 }
diff --git a/database/src/main/java/promise/db/ReactiveFastDatabase.kt b/database/src/main/java/promise/db/ReactiveFastDatabase.kt
index 2f34735..0d2a2bc 100644
--- a/database/src/main/java/promise/db/ReactiveFastDatabase.kt
+++ b/database/src/main/java/promise/db/ReactiveFastDatabase.kt
@@ -16,8 +16,8 @@ import android.annotation.TargetApi
 import android.content.ContentValues
 import android.database.Cursor
 import android.database.DatabaseErrorHandler
-import android.database.sqlite.SQLiteDatabase
 import android.os.Build
+import androidx.sqlite.db.SupportSQLiteDatabase
 import io.reactivex.Maybe
 import io.reactivex.Single
 import promise.commons.model.Identifiable
@@ -27,16 +27,14 @@ import promise.model.IdentifiableList
 
 class ReactiveFastDatabase private constructor(
     name: String?,
-    factory: SQLiteDatabase.CursorFactory?,
     version: Int,
     errorHandler: DatabaseErrorHandler) :
-    FastDatabaseImpl(name, factory, version, errorHandler),
-    ReactiveCrud<SQLiteDatabase> {
+    FastDatabaseImpl(name, version, errorHandler),
+    ReactiveCrud<SupportSQLiteDatabase> {
 
   @TargetApi(Build.VERSION_CODES.HONEYCOMB)
-  internal constructor(name: String?, version: Int, cursorListener: DatabaseCursorFactory.Listener?, listener: Corrupt?) : this(
+  internal constructor(name: String?, version: Int, listener: Corrupt?) : this(
       name,
-      DatabaseCursorFactory(cursorListener),
       version,
       DatabaseErrorHandler {
         assert(listener != null)
@@ -45,66 +43,66 @@ class ReactiveFastDatabase private constructor(
 
   internal constructor(version: Int) : this(DEFAULT_NAME, version)
 
-  constructor(name: String?, version: Int) : this(name, version, null, null)
+  constructor(name: String?, version: Int) : this(name, version,  null)
 
-  private fun <T : Identifiable<Int>> dropAsync(tableCrud: TableCrud<T, in SQLiteDatabase>,
-                                                database: SQLiteDatabase): Single<Boolean> =
+  private fun <T : Identifiable<Int>> dropAsync(tableCrud: TableCrud<T, in SupportSQLiteDatabase>,
+                                                database: SupportSQLiteDatabase): Single<Boolean> =
       Single.fromCallable { tableCrud.onDrop(database) }
 
   override fun queryAsync(queryBuilder: QueryBuilder): Single<Cursor> = Single.fromCallable { query(queryBuilder) }
 
   @Throws(TableError::class)
-  override fun <T : Identifiable<Int>> readAsync(tableCrud: TableCrud<T, in SQLiteDatabase>): ReactiveTable.Extras<T> =
+  override fun <T : Identifiable<Int>> readAsync(tableCrud: TableCrud<T, in SupportSQLiteDatabase>): ReactiveTable.Extras<T> =
       object : QueryExtras<T>(tableCrud, readableDatabase) {
         override fun serialize(t: T): ContentValues = tableCrud.serialize(t)
         override fun deserialize(e: Cursor): T = tableCrud.deserialize(e)
       }
 
-  override fun <T : Identifiable<Int>> readAllAsync(tableCrud: TableCrud<T, in SQLiteDatabase>): Maybe<IdentifiableList<out T>> =
+  override fun <T : Identifiable<Int>> readAllAsync(tableCrud: TableCrud<T, in SupportSQLiteDatabase>): Maybe<IdentifiableList<out T>> =
       Maybe.fromCallable { findAll(tableCrud) }
 
-  override fun <T : Identifiable<Int>> readAllAsync(tableCrud: TableCrud<T, in SQLiteDatabase>, vararg column: Column<*>): Maybe<IdentifiableList<out T>> =
+  override fun <T : Identifiable<Int>> readAllAsync(tableCrud: TableCrud<T, in SupportSQLiteDatabase>, vararg column: Column<*>): Maybe<IdentifiableList<out T>> =
       Maybe.fromCallable { tableCrud.onFindAll(readableDatabase, *column) }
 
-  override fun <T : Identifiable<Int>> updateAsync(t: T, tableCrud: TableCrud<T, in SQLiteDatabase>, column: Column<*>): Maybe<Boolean> =
+  override fun <T : Identifiable<Int>> updateAsync(t: T, tableCrud: TableCrud<T, in SupportSQLiteDatabase>, column: Column<*>): Maybe<Boolean> =
       Maybe.fromCallable { tableCrud.onUpdate(t, writableDatabase, column) }
 
-  override fun <T : Identifiable<Int>> updateAsync(t: T, tableCrud: TableCrud<T, in SQLiteDatabase>): Maybe<Boolean> =
+  override fun <T : Identifiable<Int>> updateAsync(t: T, tableCrud: TableCrud<T, in SupportSQLiteDatabase>): Maybe<Boolean> =
       Maybe.fromCallable { tableCrud.onUpdate(t, writableDatabase) }
 
-  override fun <T : Identifiable<Int>> deleteAsync(tableCrud: TableCrud<T, in SQLiteDatabase>, column: Column<*>): Maybe<Boolean> =
+  override fun <T : Identifiable<Int>> deleteAsync(tableCrud: TableCrud<T, in SupportSQLiteDatabase>, column: Column<*>): Maybe<Boolean> =
       Maybe.fromCallable { tableCrud.onDelete(writableDatabase, column) }
 
-  override fun <T : Identifiable<Int>> deleteAsync(tableCrud: TableCrud<T, in SQLiteDatabase>, t: T): Maybe<Boolean> =
+  override fun <T : Identifiable<Int>> deleteAsync(tableCrud: TableCrud<T, in SupportSQLiteDatabase>, t: T): Maybe<Boolean> =
       Maybe.fromCallable { tableCrud.onDelete(t, writableDatabase) }
 
-  override fun deleteAsync(tableCrud: TableCrud<*, in SQLiteDatabase>): Maybe<Boolean> =
+  override fun deleteAsync(tableCrud: TableCrud<*, in SupportSQLiteDatabase>): Maybe<Boolean> =
       Maybe.fromCallable { tableCrud.onDelete(writableDatabase) }
 
-  override fun <C> deleteAsync(tableCrud: TableCrud<*, in SQLiteDatabase>,
+  override fun <C> deleteAsync(tableCrud: TableCrud<*, in SupportSQLiteDatabase>,
                                column: Column<C>,
                                list: List<out C>): Maybe<Boolean> =
       Maybe.fromCallable { tableCrud.onDelete(writableDatabase, column, list) }
 
-  override fun <T : Identifiable<Int>> saveAsync(t: T, tableCrud: TableCrud<T, in SQLiteDatabase>): Single<Long> =
+  override fun <T : Identifiable<Int>> saveAsync(t: T, tableCrud: TableCrud<T, in SupportSQLiteDatabase>): Single<Long> =
       Single.fromCallable { tableCrud.onSave(t, writableDatabase) }
 
-  override fun <T : Identifiable<Int>> saveAsync(list: IdentifiableList<out T>, tableCrud: TableCrud<T, in SQLiteDatabase>): Single<Boolean> =
+  override fun <T : Identifiable<Int>> saveAsync(list: IdentifiableList<out T>, tableCrud: TableCrud<T, in SupportSQLiteDatabase>): Single<Boolean> =
       Single.fromCallable { tableCrud.onSave(list, writableDatabase) }
 
   override fun deleteAllAsync(): Maybe<Boolean> =
-      Maybe.zip(tables().map { tableCrud: TableCrud<*, in SQLiteDatabase> -> this.deleteAsync(tableCrud) }
+      Maybe.zip(tables().map { tableCrud: TableCrud<*, in SupportSQLiteDatabase> -> this.deleteAsync(tableCrud) }
       ) { objects: Array<Any> ->
         List.fromArray<Any>(*objects).allMatch { aBoolean: Any ->
           aBoolean is Boolean && aBoolean
         }
       }
 
-  override fun <T : Identifiable<Int>> getLastIdAsync(tableCrud: TableCrud<T, in SQLiteDatabase>): Maybe<Int> =
+  override fun <T : Identifiable<Int>> getLastIdAsync(tableCrud: TableCrud<T, in SupportSQLiteDatabase>): Maybe<Int> =
       Maybe.fromCallable { tableCrud.onGetLastId(readableDatabase) }
 
-  private abstract inner class QueryExtras<T : Identifiable<Int>> internal constructor(private val tableCrud: TableCrud<T, in SQLiteDatabase>,
-                                                                                       private val database: SQLiteDatabase) :
+  private abstract inner class QueryExtras<T : Identifiable<Int>> internal constructor(private val tableCrud: TableCrud<T, in SupportSQLiteDatabase>,
+                                                                                       private val database: SupportSQLiteDatabase) :
       ReactiveTable.Extras<T>, DoubleConverter<T, Cursor, ContentValues> {
 
     override fun first(): Maybe<T> = Maybe.fromCallable { tableCrud.onFind(database).first() }

From 3a482897bfe3f3c79c9cb0acae13a92a3ded52a5 Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Mon, 10 Aug 2020 11:24:56 +0300
Subject: [PATCH 21/34] refactor dager deps

---
 .../java/promise/base/post/PostRepository.kt  | 68 +++++++++++++++++++
 .../promise/dbapp/ActivityBuildersModule.kt   |  6 +-
 .../main/java/promise/dbapp/AppComponent.kt   |  4 ++
 .../promise/dbapp/DatabaseDependencies.kt     |  6 +-
 .../main/java/promise/dbapp/MainActivity.kt   | 39 ++---------
 .../main/java/promise/dbapp/ReposModule.kt    | 26 +++++++
 6 files changed, 113 insertions(+), 36 deletions(-)
 create mode 100644 app/src/main/java/promise/base/post/PostRepository.kt
 create mode 100644 app/src/main/java/promise/dbapp/ReposModule.kt

diff --git a/app/src/main/java/promise/base/post/PostRepository.kt b/app/src/main/java/promise/base/post/PostRepository.kt
new file mode 100644
index 0000000..8fbb41d
--- /dev/null
+++ b/app/src/main/java/promise/base/post/PostRepository.kt
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.base.post
+
+import promise.base.ID
+import promise.base.comment.PostComment
+import promise.model.IdentifiableList
+import javax.inject.Inject
+import javax.inject.Singleton
+
+interface PostRepository {
+
+  fun savePost(post: Post)
+
+  fun getPosts(): List<Post>
+
+  fun deletePosts()
+}
+
+@Singleton
+class PostRepositoryImpl @Inject constructor(
+    private var postRelationsDao: PostRelationsDao,
+    private var postsTable: PostsTable) : PostRepository {
+  init {
+    val posts = IdentifiableList(promise.commons.model.List.generate(5) {
+      Post().apply {
+        uId = ID(it.toString())
+        title = "post".plus(it)
+        body = "body".plus(it)
+        userId = it
+        comments = promise.commons.model.List.generate(4) {
+          PostComment().apply {
+            name = "nm".repeat(it)
+            uId = ID((it + 1).toString())
+            body = "hbytcvbcrxgfvbtrxt"
+            email = "ejmail;jgfccghcfcvhbhcgvb"
+          }
+        }
+      }
+    })
+
+    postRelationsDao.saveWithComments(posts)
+  }
+
+  override fun savePost(post: Post) {
+    postsTable.save(post)
+  }
+
+  override fun getPosts(): List<Post> = postRelationsDao.listWithComments()
+  override fun deletePosts() {
+    val persons = postRelationsDao.listWithComments()
+    persons.forEach {
+      postRelationsDao.deleteComments(it)
+      it.delete()
+    }
+  }
+}
\ No newline at end of file
diff --git a/app/src/main/java/promise/dbapp/ActivityBuildersModule.kt b/app/src/main/java/promise/dbapp/ActivityBuildersModule.kt
index eb210f9..747e490 100644
--- a/app/src/main/java/promise/dbapp/ActivityBuildersModule.kt
+++ b/app/src/main/java/promise/dbapp/ActivityBuildersModule.kt
@@ -18,6 +18,10 @@ import dagger.android.ContributesAndroidInjector
 
 @Module
 abstract class ActivityBuildersModule {
-  @ContributesAndroidInjector
+  @ContributesAndroidInjector (
+      modules = [
+        ReposModule::class
+      ]
+  )
   abstract fun contributeMainActivity(): MainActivity
 }
\ No newline at end of file
diff --git a/app/src/main/java/promise/dbapp/AppComponent.kt b/app/src/main/java/promise/dbapp/AppComponent.kt
index 0982d25..3cd63cf 100644
--- a/app/src/main/java/promise/dbapp/AppComponent.kt
+++ b/app/src/main/java/promise/dbapp/AppComponent.kt
@@ -17,6 +17,8 @@ import dagger.BindsInstance
 import dagger.Component
 import dagger.android.AndroidInjector
 import dagger.android.support.AndroidSupportInjectionModule
+import promise.base.post.PostRelationsDao
+import promise.base.post.PostsTable
 import javax.inject.Singleton
 
 @Component(
@@ -29,6 +31,8 @@ import javax.inject.Singleton
 @Singleton
 interface AppComponent : AndroidInjector<App> {
 
+//  fun postsTable(): PostsTable
+//  fun postRelationsDao(): PostRelationsDao
   @Component.Builder
   interface Builder {
 
diff --git a/app/src/main/java/promise/dbapp/DatabaseDependencies.kt b/app/src/main/java/promise/dbapp/DatabaseDependencies.kt
index 7b91739..e866ae7 100644
--- a/app/src/main/java/promise/dbapp/DatabaseDependencies.kt
+++ b/app/src/main/java/promise/dbapp/DatabaseDependencies.kt
@@ -17,6 +17,7 @@ import dagger.Module
 import dagger.Provides
 import promise.base.AppDatabaseImpl
 import promise.base.post.PostRelationsDao
+import promise.base.post.PostsTable
 import javax.inject.Singleton
 
 @Module
@@ -31,6 +32,9 @@ object DatabaseDependencies {
  @JvmStatic
  fun providePostRelationsDao(appDatabase: AppDatabaseImpl): PostRelationsDao =
      appDatabase.postRelationsDao
-
+ @Provides
+ @JvmStatic
+ fun providePostTable(appDatabase: AppDatabaseImpl): PostsTable =
+     appDatabase.postsTable
 
 }
\ No newline at end of file
diff --git a/app/src/main/java/promise/dbapp/MainActivity.kt b/app/src/main/java/promise/dbapp/MainActivity.kt
index ae7066c..56defe5 100644
--- a/app/src/main/java/promise/dbapp/MainActivity.kt
+++ b/app/src/main/java/promise/dbapp/MainActivity.kt
@@ -18,18 +18,13 @@ import com.google.android.material.snackbar.Snackbar
 import dagger.android.support.DaggerAppCompatActivity
 import kotlinx.android.synthetic.main.activity_main.*
 import kotlinx.android.synthetic.main.content_main.*
-import promise.base.ID
-import promise.base.comment.PostComment
-import promise.base.post.Post
-import promise.base.post.PostRelationsDao
-import promise.model.IdentifiableList
+import promise.base.post.PostRepository
 import javax.inject.Inject
-import promise.commons.model.List
 
 class MainActivity : DaggerAppCompatActivity() {
 
- @Inject
- lateinit var postRelationsDao: PostRelationsDao
+  @Inject
+  lateinit var postRepository: PostRepository
 
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
@@ -45,24 +40,6 @@ class MainActivity : DaggerAppCompatActivity() {
   override fun onPostCreate(savedInstanceState: Bundle?) {
     super.onPostCreate(savedInstanceState)
 
-    val posts = IdentifiableList(List.generate(5) {
-      Post().apply {
-        uId = ID(it.toString())
-        title = "post".plus(it)
-        body = "body".plus(it)
-        userId = it
-        comments = List.generate(4) {
-          PostComment().apply {
-            name = "nm".repeat(it)
-            uId = ID((it + 1).toString())
-            body = "hbytcvbcrxgfvbtrxt"
-            email = "ejmail;jgfccghcfcvhbhcgvb"
-          }
-        }
-      }
-    })
-
-   postRelationsDao.saveWithComments(posts)
 
     showInfo()
 
@@ -73,18 +50,12 @@ class MainActivity : DaggerAppCompatActivity() {
   }
 
   private fun showInfo() {
-
-    val persons = postRelationsDao.listWithComments()
-
+    val persons = postRepository.getPosts()
     complex_values_textview.text = persons.toString()
   }
 
   private fun deleteInfo() {
-    val persons = postRelationsDao.listWithComments()
-    persons.forEach {
-      postRelationsDao.deleteComments(it)
-      it.delete()
-    }
+    postRepository.deletePosts()
   }
 
 }
diff --git a/app/src/main/java/promise/dbapp/ReposModule.kt b/app/src/main/java/promise/dbapp/ReposModule.kt
new file mode 100644
index 0000000..f2eb78a
--- /dev/null
+++ b/app/src/main/java/promise/dbapp/ReposModule.kt
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.dbapp
+
+import dagger.Binds
+import dagger.Module
+import promise.base.post.PostRepository
+import promise.base.post.PostRepositoryImpl
+
+@Module
+abstract class ReposModule {
+
+  @Binds
+  abstract fun bindPostsRepository(postRepositoryImpl: PostRepositoryImpl): PostRepository
+}
\ No newline at end of file

From e581b5b527d556718578891bd045ec3c31b0acc8 Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Mon, 10 Aug 2020 12:18:34 +0300
Subject: [PATCH 22/34] updated readme

---
 README.md | 25 ++++++++++++-------------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/README.md b/README.md
index 5385a86..e49c2db 100644
--- a/README.md
+++ b/README.md
@@ -3,19 +3,18 @@
 
 # Table of Contents
 
-**[Sample Application](##SampleApplication)**<br>
-***[Entity Classes](***EntityClasses)***<br>
-***[Database Class](###DatabaseClass)***<br>
-***[TypeConverter Class](###DatabaseClass)***<br>
-***[Entity Relations](###EntityRelations)***<br>
-***[Database Initialization](###DatabaseInitialization)***<br>
+**[Sample](##Sample)**<br>
+***[Entity](***Entity)***<br>
+***[Database](###Database)***<br>
+***[TypeConverter](###TypeConverter)***<br>
+***[Relations](###Relations)***<br>
+***[Initialization](###Initialization)***<br>
 ***[Migrations](###Migrations)***<br>
 **[Setup](##Setup)**<br>
-**[Initialization](##Initialization)**<br>
 **[Next Steps, Credits, Feedback, License](#next-steps)**<br>
 
-## Sample Application
-### Entity Classes
+## Sample
+### Entity
 Pojo classes to be persisted are annotated with @Entity
 The classes can either implement Identifiable<Integer> or extend from ActiveRecord
 This classes must hava a no args constructor or no constructors at all
@@ -87,7 +86,7 @@ public class Post extends ActiveRecord<Post> {
 
 > BOOLEAN fields MUST NOT start with `is`
 
-### Database Class
+### Database
 Database classe is annotated with @DatabaseEntity and contain a list
 of persistable entity classes
 The class must be abstract and extend from PromiseDatabase
@@ -107,7 +106,7 @@ abstract class AppDatabase(fastDatabase: FastDatabase)
 
 Rebuild your project to generate database implementation
 
-### TypeConverter Class
+### TypeConverter
 A type converter is a utility that helps to convert fields not directly persistable to persistable,
 For instance the Post entity has named uId with a type
 ```kotlin
@@ -131,7 +130,7 @@ Conversion methods in a type converter should have only one parameter and must r
 
 > Without a type converter provision, the compiler will not generate columns for non persistable fields
 
-### Entity Relations
+### Relations
 
 #### HasOne Relation
 Denotes one entity has one other entity, a sample
@@ -285,7 +284,7 @@ val posts = IdentifiableList(List.generate(5) {
 ```
 
 
-### Database Initialization
+### Initialization
 The compiler generates a database class for creating your database implementation and accesing tables
 and relation daos, sampled code from generated database file below
 

From 7f948cdec538d350b678ddcc01a26815607e7bb9 Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Wed, 12 Aug 2020 11:36:54 +0300
Subject: [PATCH 23/34] added yml migration file

---
 .../promise/base/comment/PostComment.java     |   6 +
 .../java/promise/base/post/PostRepository.kt  |  78 +--
 .../promise/dbapp/DatabaseDependencies.kt     |  28 +-
 .../main/java/promise/dbapp/MainActivity.kt   |  46 +-
 .../main/java/promise/dbapp/ReposModule.kt    |   8 +-
 compiler/build.gradle                         |   2 +
 .../AnnotatedClassProcessor.kt                |   2 +-
 .../{ompiler => compiler}/CodeGenerator.kt    |   2 +-
 .../DAOAnnotatedProcessor.kt                  |   6 +-
 .../DatabaseAbstractMethodsGenerator.kt       |   8 +-
 .../DatabaseAnnotationGenerator.kt            |  13 +-
 .../DatabaseCrudStubMethodsGenerator.kt       |   2 +-
 .../DatabaseEntityAnnotatedProcessor.kt       |  58 +-
 .../compiler/DatabaseMetaDataWriter.kt        |  83 +++
 .../DatabaseStaticMethodsGenerator.kt         |  24 +-
 .../EntityAnnotatedProcessor.kt               |  27 +-
 .../PromiseDatabaseCompiler.kt                |  24 +-
 .../RelationsDaoGenerator.java                |  24 +-
 .../RelationsDaoProcessor.kt                  |   4 +-
 .../TableAnnotationGenerator.java             |   7 +-
 .../TableColumnFieldsGenerator.kt             |  16 +-
 .../TableDeserializerMethodGenerator.kt       |  11 +-
 .../database/compiler/TableMetaDataWriter.kt  | 110 ++++
 .../TableMigrationFieldGenerator.kt           |  91 +--
 .../TableRegisteredColumnsMethodGenerator.kt  |   2 +-
 .../TableSerializerMethodGenerator.kt         |  18 +-
 .../TypeConverterAnnotatedProcessor.kt        |   8 +-
 .../compiler/migration/DatabaseMetaData.kt    |  19 +
 .../compiler/migration/TableMetaData.kt       |  31 ++
 .../compiler/migration/TableMigration.kt      |  39 ++
 .../compiler/migration/VersionChange.kt       |  33 ++
 .../database/compiler/utils/Arrangeable.java  |  52 ++
 .../database/compiler/utils/Category.java     |  42 ++
 .../utils/JavaUtils.java                      |   2 +-
 .../promise/database/compiler/utils/List.java | 527 ++++++++++++++++++
 .../{ompiler => compiler}/utils/LogUtil.java  |  11 +-
 .../utils/PersistableEntityUtils.kt           |   4 +-
 .../{ompiler => compiler}/utils/Utils.kt      |   6 +-
 .../compiler/utils/function/BIConsumer.java   |  18 +
 .../compiler/utils/function/Combiner.java     |  19 +
 .../utils/function/FilterFunction.java        |  18 +
 .../utils/function/FilterFunction2.java       |  20 +
 .../utils/function/GroupFunction.java         |  18 +
 .../utils/function/GroupFunction2.java        |  25 +
 .../utils/function/GroupFunction3.java        |  22 +
 .../compiler/utils/function/JoinFunction.java |  18 +
 .../compiler/utils/function/MapFunction.java  |  18 +
 .../utils/function/MapIndexFunction.java      |  18 +
 .../utils/function/ReduceFunction.java        |  22 +
 .../db/management/DatabaseMigration.kt        |  25 +
 .../promise/db/management/TableMetaData.kt    |  25 +
 schemas/promise.base.AppDatabase.yml          | 185 ++++++
 52 files changed, 1682 insertions(+), 243 deletions(-)
 rename compiler/src/main/java/promise/database/{ompiler => compiler}/AnnotatedClassProcessor.kt (95%)
 rename compiler/src/main/java/promise/database/{ompiler => compiler}/CodeGenerator.kt (95%)
 rename compiler/src/main/java/promise/database/{ompiler => compiler}/DAOAnnotatedProcessor.kt (97%)
 rename compiler/src/main/java/promise/database/{ompiler => compiler}/DatabaseAbstractMethodsGenerator.kt (95%)
 rename compiler/src/main/java/promise/database/{ompiler => compiler}/DatabaseAnnotationGenerator.kt (86%)
 rename compiler/src/main/java/promise/database/{ompiler => compiler}/DatabaseCrudStubMethodsGenerator.kt (97%)
 rename compiler/src/main/java/promise/database/{ompiler => compiler}/DatabaseEntityAnnotatedProcessor.kt (69%)
 create mode 100644 compiler/src/main/java/promise/database/compiler/DatabaseMetaDataWriter.kt
 rename compiler/src/main/java/promise/database/{ompiler => compiler}/DatabaseStaticMethodsGenerator.kt (94%)
 rename compiler/src/main/java/promise/database/{ompiler => compiler}/EntityAnnotatedProcessor.kt (86%)
 rename compiler/src/main/java/promise/database/{ompiler => compiler}/PromiseDatabaseCompiler.kt (76%)
 rename compiler/src/main/java/promise/database/{ompiler => compiler}/RelationsDaoGenerator.java (97%)
 rename compiler/src/main/java/promise/database/{ompiler => compiler}/RelationsDaoProcessor.kt (94%)
 rename compiler/src/main/java/promise/database/{ompiler => compiler}/TableAnnotationGenerator.java (95%)
 rename compiler/src/main/java/promise/database/{ompiler => compiler}/TableColumnFieldsGenerator.kt (95%)
 rename compiler/src/main/java/promise/database/{ompiler => compiler}/TableDeserializerMethodGenerator.kt (86%)
 create mode 100644 compiler/src/main/java/promise/database/compiler/TableMetaDataWriter.kt
 rename compiler/src/main/java/promise/database/{ompiler => compiler}/TableMigrationFieldGenerator.kt (52%)
 rename compiler/src/main/java/promise/database/{ompiler => compiler}/TableRegisteredColumnsMethodGenerator.kt (98%)
 rename compiler/src/main/java/promise/database/{ompiler => compiler}/TableSerializerMethodGenerator.kt (84%)
 rename compiler/src/main/java/promise/database/{ompiler => compiler}/TypeConverterAnnotatedProcessor.kt (92%)
 create mode 100644 compiler/src/main/java/promise/database/compiler/migration/DatabaseMetaData.kt
 create mode 100644 compiler/src/main/java/promise/database/compiler/migration/TableMetaData.kt
 create mode 100644 compiler/src/main/java/promise/database/compiler/migration/TableMigration.kt
 create mode 100644 compiler/src/main/java/promise/database/compiler/migration/VersionChange.kt
 create mode 100644 compiler/src/main/java/promise/database/compiler/utils/Arrangeable.java
 create mode 100644 compiler/src/main/java/promise/database/compiler/utils/Category.java
 rename compiler/src/main/java/promise/database/{ompiler => compiler}/utils/JavaUtils.java (99%)
 create mode 100644 compiler/src/main/java/promise/database/compiler/utils/List.java
 rename compiler/src/main/java/promise/database/{ompiler => compiler}/utils/LogUtil.java (87%)
 rename compiler/src/main/java/promise/database/{ompiler => compiler}/utils/PersistableEntityUtils.kt (98%)
 rename compiler/src/main/java/promise/database/{ompiler => compiler}/utils/Utils.kt (98%)
 create mode 100644 compiler/src/main/java/promise/database/compiler/utils/function/BIConsumer.java
 create mode 100644 compiler/src/main/java/promise/database/compiler/utils/function/Combiner.java
 create mode 100644 compiler/src/main/java/promise/database/compiler/utils/function/FilterFunction.java
 create mode 100644 compiler/src/main/java/promise/database/compiler/utils/function/FilterFunction2.java
 create mode 100644 compiler/src/main/java/promise/database/compiler/utils/function/GroupFunction.java
 create mode 100644 compiler/src/main/java/promise/database/compiler/utils/function/GroupFunction2.java
 create mode 100644 compiler/src/main/java/promise/database/compiler/utils/function/GroupFunction3.java
 create mode 100644 compiler/src/main/java/promise/database/compiler/utils/function/JoinFunction.java
 create mode 100644 compiler/src/main/java/promise/database/compiler/utils/function/MapFunction.java
 create mode 100644 compiler/src/main/java/promise/database/compiler/utils/function/MapIndexFunction.java
 create mode 100644 compiler/src/main/java/promise/database/compiler/utils/function/ReduceFunction.java
 create mode 100644 database/src/main/java/promise/db/management/DatabaseMigration.kt
 create mode 100644 database/src/main/java/promise/db/management/TableMetaData.kt
 create mode 100644 schemas/promise.base.AppDatabase.yml

diff --git a/app/src/main/java/promise/base/comment/PostComment.java b/app/src/main/java/promise/base/comment/PostComment.java
index f5a1d76..c18c1db 100644
--- a/app/src/main/java/promise/base/comment/PostComment.java
+++ b/app/src/main/java/promise/base/comment/PostComment.java
@@ -6,6 +6,8 @@
 
 import promise.base.ID;
 import promise.base.post.Post;
+import promise.database.Migrate;
+import promise.database.MigrationOptions;
 import promise.db.ActiveRecord;
 import promise.database.Entity;
 import promise.database.HasOne;
@@ -14,13 +16,17 @@
 @Entity
 public class PostComment extends ActiveRecord<PostComment> {
 	private String name;
+	@Migrate(fromVersion = 1, toVersion = 2, action = MigrationOptions.CREATE)
 	private ID uId;
 	private String body;
+  @Migrate(fromVersion = 3, toVersion = 4, action = MigrationOptions.CREATE_INDEX)
 	private String email;
 
+	@Migrate(fromVersion = 1, toVersion = 2, action = MigrationOptions.CREATE)
 	private String postCommentId = "";
 
 	@HasOne
+  @Migrate(fromVersion = 3, toVersion = 4, action = MigrationOptions.DROP)
 	private Post post;
 
 	public void setName(String name){
diff --git a/app/src/main/java/promise/base/post/PostRepository.kt b/app/src/main/java/promise/base/post/PostRepository.kt
index 8fbb41d..57d9526 100644
--- a/app/src/main/java/promise/base/post/PostRepository.kt
+++ b/app/src/main/java/promise/base/post/PostRepository.kt
@@ -27,42 +27,42 @@ interface PostRepository {
 
   fun deletePosts()
 }
-
-@Singleton
-class PostRepositoryImpl @Inject constructor(
-    private var postRelationsDao: PostRelationsDao,
-    private var postsTable: PostsTable) : PostRepository {
-  init {
-    val posts = IdentifiableList(promise.commons.model.List.generate(5) {
-      Post().apply {
-        uId = ID(it.toString())
-        title = "post".plus(it)
-        body = "body".plus(it)
-        userId = it
-        comments = promise.commons.model.List.generate(4) {
-          PostComment().apply {
-            name = "nm".repeat(it)
-            uId = ID((it + 1).toString())
-            body = "hbytcvbcrxgfvbtrxt"
-            email = "ejmail;jgfccghcfcvhbhcgvb"
-          }
-        }
-      }
-    })
-
-    postRelationsDao.saveWithComments(posts)
-  }
-
-  override fun savePost(post: Post) {
-    postsTable.save(post)
-  }
-
-  override fun getPosts(): List<Post> = postRelationsDao.listWithComments()
-  override fun deletePosts() {
-    val persons = postRelationsDao.listWithComments()
-    persons.forEach {
-      postRelationsDao.deleteComments(it)
-      it.delete()
-    }
-  }
-}
\ No newline at end of file
+//
+//@Singleton
+//class PostRepositoryImpl @Inject constructor(
+//    private var postRelationsDao: PostRelationsDao,
+//    private var postsTable: PostsTable) : PostRepository {
+//  init {
+//    val posts = IdentifiableList(promise.commons.model.List.generate(5) {
+//      Post().apply {
+//        uId = ID(it.toString())
+//        title = "post".plus(it)
+//        body = "body".plus(it)
+//        userId = it
+//        comments = promise.commons.model.List.generate(4) {
+//          PostComment().apply {
+//            name = "nm".repeat(it)
+//            uId = ID((it + 1).toString())
+//            body = "hbytcvbcrxgfvbtrxt"
+//            email = "ejmail;jgfccghcfcvhbhcgvb"
+//          }
+//        }
+//      }
+//    })
+//
+//    postRelationsDao.saveWithComments(posts)
+//  }
+//
+//  override fun savePost(post: Post) {
+//    postsTable.save(post)
+//  }
+//
+//  override fun getPosts(): List<Post> = postRelationsDao.listWithComments()
+//  override fun deletePosts() {
+//    val persons = postRelationsDao.listWithComments()
+//    persons.forEach {
+//      postRelationsDao.deleteComments(it)
+//      it.delete()
+//    }
+//  }
+//}
\ No newline at end of file
diff --git a/app/src/main/java/promise/dbapp/DatabaseDependencies.kt b/app/src/main/java/promise/dbapp/DatabaseDependencies.kt
index e866ae7..1e391a1 100644
--- a/app/src/main/java/promise/dbapp/DatabaseDependencies.kt
+++ b/app/src/main/java/promise/dbapp/DatabaseDependencies.kt
@@ -22,19 +22,19 @@ import javax.inject.Singleton
 
 @Module
 object DatabaseDependencies {
-
- @Provides
- @Singleton
- @JvmStatic
- fun provideAppDatabase(): AppDatabaseImpl = AppDatabaseImpl.createDatabase("blog_db")
-
- @Provides
- @JvmStatic
- fun providePostRelationsDao(appDatabase: AppDatabaseImpl): PostRelationsDao =
-     appDatabase.postRelationsDao
- @Provides
- @JvmStatic
- fun providePostTable(appDatabase: AppDatabaseImpl): PostsTable =
-     appDatabase.postsTable
+//
+// @Provides
+// @Singleton
+// @JvmStatic
+// fun provideAppDatabase(): AppDatabaseImpl = AppDatabaseImpl.createDatabase("blog_db")
+//
+// @Provides
+// @JvmStatic
+// fun providePostRelationsDao(appDatabase: AppDatabaseImpl): PostRelationsDao =
+//     appDatabase.postRelationsDao
+// @Provides
+// @JvmStatic
+// fun providePostTable(appDatabase: AppDatabaseImpl): PostsTable =
+//     appDatabase.postsTable
 
 }
\ No newline at end of file
diff --git a/app/src/main/java/promise/dbapp/MainActivity.kt b/app/src/main/java/promise/dbapp/MainActivity.kt
index 56defe5..3b623c8 100644
--- a/app/src/main/java/promise/dbapp/MainActivity.kt
+++ b/app/src/main/java/promise/dbapp/MainActivity.kt
@@ -22,9 +22,9 @@ import promise.base.post.PostRepository
 import javax.inject.Inject
 
 class MainActivity : DaggerAppCompatActivity() {
-
-  @Inject
-  lateinit var postRepository: PostRepository
+//
+//  @Inject
+//  lateinit var postRepository: PostRepository
 
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
@@ -37,25 +37,25 @@ class MainActivity : DaggerAppCompatActivity() {
     }
   }
 
-  override fun onPostCreate(savedInstanceState: Bundle?) {
-    super.onPostCreate(savedInstanceState)
-
-
-    showInfo()
-
-    clear_button.setOnClickListener {
-      deleteInfo()
-      showInfo()
-    }
-  }
-
-  private fun showInfo() {
-    val persons = postRepository.getPosts()
-    complex_values_textview.text = persons.toString()
-  }
-
-  private fun deleteInfo() {
-    postRepository.deletePosts()
-  }
+//  override fun onPostCreate(savedInstanceState: Bundle?) {
+//    super.onPostCreate(savedInstanceState)
+//
+//
+//    showInfo()
+//
+//    clear_button.setOnClickListener {
+//      deleteInfo()
+//      showInfo()
+//    }
+//  }
+//
+//  private fun showInfo() {
+//    val persons = postRepository.getPosts()
+//    complex_values_textview.text = persons.toString()
+//  }
+//
+//  private fun deleteInfo() {
+//    postRepository.deletePosts()
+//  }
 
 }
diff --git a/app/src/main/java/promise/dbapp/ReposModule.kt b/app/src/main/java/promise/dbapp/ReposModule.kt
index f2eb78a..126e2a2 100644
--- a/app/src/main/java/promise/dbapp/ReposModule.kt
+++ b/app/src/main/java/promise/dbapp/ReposModule.kt
@@ -16,11 +16,11 @@ package promise.dbapp
 import dagger.Binds
 import dagger.Module
 import promise.base.post.PostRepository
-import promise.base.post.PostRepositoryImpl
+//import promise.base.post.PostRepositoryImpl
 
 @Module
 abstract class ReposModule {
-
-  @Binds
-  abstract fun bindPostsRepository(postRepositoryImpl: PostRepositoryImpl): PostRepository
+//
+//  @Binds
+//  abstract fun bindPostsRepository(postRepositoryImpl: PostRepositoryImpl): PostRepository
 }
\ No newline at end of file
diff --git a/compiler/build.gradle b/compiler/build.gradle
index b3fab05..97fdd42 100644
--- a/compiler/build.gradle
+++ b/compiler/build.gradle
@@ -22,6 +22,8 @@ dependencies {
     //compileOnly 'com.github.android-promise.database:commons:1.0.3-alpha4'
     compileOnly project(path: ':commons')
     compileOnly files(Jvm.current().getToolsJar())
+    implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:2.9.0'
+    implementation 'com.fasterxml.jackson.core:jackson-databind:2.9.0'
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
     implementation'org.atteo:evo-inflector:1.0.1'
     implementation 'com.squareup:javapoet:1.13.0'
diff --git a/compiler/src/main/java/promise/database/ompiler/AnnotatedClassProcessor.kt b/compiler/src/main/java/promise/database/compiler/AnnotatedClassProcessor.kt
similarity index 95%
rename from compiler/src/main/java/promise/database/ompiler/AnnotatedClassProcessor.kt
rename to compiler/src/main/java/promise/database/compiler/AnnotatedClassProcessor.kt
index 9a5c72d..c04770a 100644
--- a/compiler/src/main/java/promise/database/ompiler/AnnotatedClassProcessor.kt
+++ b/compiler/src/main/java/promise/database/compiler/AnnotatedClassProcessor.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.database.ompiler
+package promise.database.compiler
 
 import com.squareup.javapoet.JavaFile
 import javax.annotation.processing.RoundEnvironment
diff --git a/compiler/src/main/java/promise/database/ompiler/CodeGenerator.kt b/compiler/src/main/java/promise/database/compiler/CodeGenerator.kt
similarity index 95%
rename from compiler/src/main/java/promise/database/ompiler/CodeGenerator.kt
rename to compiler/src/main/java/promise/database/compiler/CodeGenerator.kt
index 7a5c8d2..ff743f5 100644
--- a/compiler/src/main/java/promise/database/ompiler/CodeGenerator.kt
+++ b/compiler/src/main/java/promise/database/compiler/CodeGenerator.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.database.ompiler
+package promise.database.compiler
 
 
 interface CodeGenerator<out T> {
diff --git a/compiler/src/main/java/promise/database/ompiler/DAOAnnotatedProcessor.kt b/compiler/src/main/java/promise/database/compiler/DAOAnnotatedProcessor.kt
similarity index 97%
rename from compiler/src/main/java/promise/database/ompiler/DAOAnnotatedProcessor.kt
rename to compiler/src/main/java/promise/database/compiler/DAOAnnotatedProcessor.kt
index 570c679..776e559 100644
--- a/compiler/src/main/java/promise/database/ompiler/DAOAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/database/compiler/DAOAnnotatedProcessor.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.database.ompiler
+package promise.database.compiler
 
 import com.squareup.javapoet.AnnotationSpec
 import com.squareup.javapoet.ClassName
@@ -22,8 +22,8 @@ import org.jetbrains.annotations.NotNull
 import promise.database.DAO
 import promise.database.Parent
 import promise.database.Relation
-import promise.database.ompiler.utils.JavaUtils
-import promise.database.ompiler.utils.LogUtil
+import promise.database.compiler.utils.JavaUtils
+import promise.database.compiler.utils.LogUtil
 import javax.annotation.processing.ProcessingEnvironment
 import javax.annotation.processing.RoundEnvironment
 import javax.lang.model.element.Element
diff --git a/compiler/src/main/java/promise/database/ompiler/DatabaseAbstractMethodsGenerator.kt b/compiler/src/main/java/promise/database/compiler/DatabaseAbstractMethodsGenerator.kt
similarity index 95%
rename from compiler/src/main/java/promise/database/ompiler/DatabaseAbstractMethodsGenerator.kt
rename to compiler/src/main/java/promise/database/compiler/DatabaseAbstractMethodsGenerator.kt
index 4b81353..55e8dc5 100644
--- a/compiler/src/main/java/promise/database/ompiler/DatabaseAbstractMethodsGenerator.kt
+++ b/compiler/src/main/java/promise/database/compiler/DatabaseAbstractMethodsGenerator.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.database.ompiler
+package promise.database.compiler
 
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
@@ -21,9 +21,9 @@ import com.squareup.javapoet.TypeVariableName
 import com.squareup.javapoet.WildcardTypeName
 import org.jetbrains.annotations.NotNull
 import promise.database.DAO
-import promise.database.ompiler.utils.JavaUtils
-import promise.database.ompiler.utils.asTypeElement
-import promise.database.ompiler.utils.getTableEntities
+import promise.database.compiler.utils.JavaUtils
+import promise.database.compiler.utils.asTypeElement
+import promise.database.compiler.utils.getTableEntities
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.ExecutableElement
diff --git a/compiler/src/main/java/promise/database/ompiler/DatabaseAnnotationGenerator.kt b/compiler/src/main/java/promise/database/compiler/DatabaseAnnotationGenerator.kt
similarity index 86%
rename from compiler/src/main/java/promise/database/ompiler/DatabaseAnnotationGenerator.kt
rename to compiler/src/main/java/promise/database/compiler/DatabaseAnnotationGenerator.kt
index a41b912..3119301 100644
--- a/compiler/src/main/java/promise/database/ompiler/DatabaseAnnotationGenerator.kt
+++ b/compiler/src/main/java/promise/database/compiler/DatabaseAnnotationGenerator.kt
@@ -11,15 +11,15 @@
  * limitations under the License.
  */
 
-package promise.database.ompiler
+package promise.database.compiler
 
 import com.squareup.javapoet.AnnotationSpec
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
-import promise.database.ompiler.utils.LogUtil
-import promise.database.ompiler.utils.getTableClassNameString
-import promise.database.ompiler.utils.getDatabaseVersion
-import promise.database.ompiler.utils.getTableEntities
+import promise.database.compiler.utils.LogUtil
+import promise.database.compiler.utils.getTableClassNameString
+import promise.database.compiler.utils.getDatabaseVersion
+import promise.database.compiler.utils.getTableEntities
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.TypeElement
@@ -34,8 +34,7 @@ class DatabaseAnnotationGenerator(
       var entities: Array<TypeElement>? = null
       try {
         entities = element.getTableEntities(processingEnv)
-      } catch (e: Throwable) {
-        LogUtil.e(e)
+      } catch (e: Throwable) { LogUtil.e(e)
       }
       val version = element.getDatabaseVersion()
       try {
diff --git a/compiler/src/main/java/promise/database/ompiler/DatabaseCrudStubMethodsGenerator.kt b/compiler/src/main/java/promise/database/compiler/DatabaseCrudStubMethodsGenerator.kt
similarity index 97%
rename from compiler/src/main/java/promise/database/ompiler/DatabaseCrudStubMethodsGenerator.kt
rename to compiler/src/main/java/promise/database/compiler/DatabaseCrudStubMethodsGenerator.kt
index 835f920..318cb41 100644
--- a/compiler/src/main/java/promise/database/ompiler/DatabaseCrudStubMethodsGenerator.kt
+++ b/compiler/src/main/java/promise/database/compiler/DatabaseCrudStubMethodsGenerator.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.database.ompiler
+package promise.database.compiler
 
 import com.squareup.javapoet.TypeSpec
 import javax.annotation.processing.ProcessingEnvironment
diff --git a/compiler/src/main/java/promise/database/ompiler/DatabaseEntityAnnotatedProcessor.kt b/compiler/src/main/java/promise/database/compiler/DatabaseEntityAnnotatedProcessor.kt
similarity index 69%
rename from compiler/src/main/java/promise/database/ompiler/DatabaseEntityAnnotatedProcessor.kt
rename to compiler/src/main/java/promise/database/compiler/DatabaseEntityAnnotatedProcessor.kt
index c01d839..a7a13c1 100644
--- a/compiler/src/main/java/promise/database/ompiler/DatabaseEntityAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/database/compiler/DatabaseEntityAnnotatedProcessor.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.database.ompiler
+package promise.database.compiler
 
 import com.squareup.javapoet.AnnotationSpec
 import com.squareup.javapoet.ClassName
@@ -19,11 +19,11 @@ import com.squareup.javapoet.JavaFile
 import com.squareup.javapoet.MethodSpec
 import com.squareup.javapoet.TypeSpec
 import promise.database.DatabaseEntity
-import promise.database.ompiler.utils.JavaUtils
-import promise.database.ompiler.utils.LogUtil
-import promise.database.ompiler.utils.asTableClassName
-import promise.database.ompiler.utils.getTableClassNameString
-import promise.database.ompiler.utils.getTableEntities
+import promise.database.compiler.utils.JavaUtils
+import promise.database.compiler.utils.LogUtil
+import promise.database.compiler.utils.asTableClassName
+import promise.database.compiler.utils.getTableClassNameString
+import promise.database.compiler.utils.getTableEntities
 import java.util.*
 import javax.annotation.processing.ProcessingEnvironment
 import javax.annotation.processing.RoundEnvironment
@@ -33,29 +33,35 @@ import javax.lang.model.element.Modifier
 import javax.lang.model.element.TypeElement
 import javax.tools.Diagnostic
 
-class DatabaseEntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment) : AnnotatedClassProcessor() {
-
-  override fun process(environment: RoundEnvironment?): List<JavaFile.Builder?>? {
-    val databases = environment?.getElementsAnnotatedWith(DatabaseEntity::class.java) ?: emptySet()
-    if (databases.size > 1)
-      LogUtil.e(Exception("There can only be one database in the module"))
-    else if (databases.size == 1) {
-      val element = databases.first()
-      if (element.kind != ElementKind.CLASS) {
-        LogUtil.e(Exception("Only classes can be annotated"), element)
-        return null
+class DatabaseEntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment,
+                                       private val database: TypeElement) : AnnotatedClassProcessor() {
+
+  companion object {
+    fun getDatabaseElement(environment: RoundEnvironment?, processingEnv: ProcessingEnvironment): TypeElement? {
+      val databases = environment?.getElementsAnnotatedWith(DatabaseEntity::class.java) ?: emptySet()
+      if (databases.size > 1)
+        LogUtil.e(Exception("There can only be one database in the module"))
+      else if (databases.size == 1) {
+        val element = databases.first()
+        if (element.kind != ElementKind.CLASS) {
+          LogUtil.e(Exception("Only classes can be annotated"), element)
+          return null
+        }
+        if (element.kind == ElementKind.CLASS && !(element as TypeElement).modifiers.contains(Modifier.ABSTRACT))
+          LogUtil.e(Exception("Database class must be abstract"), element)
+        val promiseDatabaseType = JavaUtils.getDeclaredType(processingEnv,
+            processingEnv.elementUtils.getTypeElement("promise.db.PromiseDatabase"))
+        if (!JavaUtils.isSubTypeOfDeclaredType(processingEnv, element, promiseDatabaseType))
+          LogUtil.e(Exception("Database class must extend from promise.db.PromiseDatabase"), element)
+        return element as TypeElement?
       }
-      if (element.kind == ElementKind.CLASS && !(element as TypeElement).modifiers.contains(Modifier.ABSTRACT))
-        LogUtil.e(Exception("Database class must be abstract"), element)
-      val promiseDatabaseType = JavaUtils.getDeclaredType(processingEnv,
-          processingEnv.elementUtils.getTypeElement("promise.db.PromiseDatabase"))
-      if (!JavaUtils.isSubTypeOfDeclaredType(processingEnv, element, promiseDatabaseType))
-        LogUtil.e(Exception("Database class must extend from promise.db.PromiseDatabase"), element)
-      return Collections.singletonList(processElement(element))
+      return null
     }
-    return null
   }
 
+  override fun process(environment: RoundEnvironment?): List<JavaFile.Builder?>? =
+      Collections.singletonList(processElement(database))
+
   private fun processElement(element: Element): JavaFile.Builder {
     processingEnv.messager.printMessage(Diagnostic.Kind.OTHER, "DatabaseProcessor Processing: ${element.simpleName}")
 
@@ -105,7 +111,7 @@ class DatabaseEntityAnnotatedProcessor(private val processingEnv: ProcessingEnvi
 
     DatabaseStaticMethodsGenerator(classBuilder, element, processingEnv).generate()
 
-    val abstractFuncsBuilder = DatabaseAbstractMethodsGenerator((element as TypeElement), processingEnv)
+    val abstractFuncsBuilder = DatabaseAbstractMethodsGenerator(element, processingEnv)
 
     abstractFuncsBuilder.generate()?.forEach {
       classBuilder.addMethod(it)
diff --git a/compiler/src/main/java/promise/database/compiler/DatabaseMetaDataWriter.kt b/compiler/src/main/java/promise/database/compiler/DatabaseMetaDataWriter.kt
new file mode 100644
index 0000000..5700e4a
--- /dev/null
+++ b/compiler/src/main/java/promise/database/compiler/DatabaseMetaDataWriter.kt
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.database.compiler
+
+import com.fasterxml.jackson.annotation.JsonInclude
+import com.fasterxml.jackson.core.JsonProcessingException
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.dataformat.yaml.YAMLFactory
+import promise.database.compiler.migration.DatabaseMetaData
+import promise.database.compiler.utils.LogUtil
+import promise.database.compiler.utils.getDatabaseVersion
+import java.io.File
+import java.io.FileReader
+import java.io.FileWriter
+import java.io.IOException
+import javax.lang.model.element.TypeElement
+
+class DatabaseMetaDataWriter(
+    private val databaseElement: TypeElement,
+    private val schemasPath: String) {
+
+  var currentDatabaseMetaData: DatabaseMetaData? = null
+
+  fun loadCurrentMetaData() {
+    try {
+      val file = File(schemasPath)
+      if (file.exists()) {
+        val om = ObjectMapper(YAMLFactory())
+        //xmlMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+        val fileWriter = FileReader(file)
+        currentDatabaseMetaData = om.readValue(fileWriter,  DatabaseMetaData::class.java)
+        fileWriter.close()
+      }
+      else currentDatabaseMetaData = DatabaseMetaData()
+    } catch (e: JsonProcessingException) {
+      LogUtil.e(e)
+    } catch (e: IOException) {
+      LogUtil.e(e)
+    }
+
+  }
+
+  fun process(
+      //elements: Map<Element, String>
+  ) {
+    val databaseMetaData = DatabaseMetaData()
+    if (TableMetaDataWriter.tableMetaData.isNotEmpty()) {
+      databaseMetaData.tableMetaData = TableMetaDataWriter.tableMetaData
+    }
+    databaseMetaData.dbVersion = databaseElement.getDatabaseVersion()
+    serializeToXML(databaseMetaData)
+  }
+
+  private fun serializeToXML(obj: Any) {
+    try {
+      val file = File(schemasPath)
+      file.delete()
+      file.createNewFile()
+      val om = ObjectMapper(YAMLFactory())
+      // serialize our Object into XML string
+      val ymlString = om.writeValueAsString(obj)
+      // write XML string to file
+      val fileWriter = FileWriter(file)
+      fileWriter.write(ymlString)
+      fileWriter.close()
+    } catch (e: JsonProcessingException) {
+      LogUtil.e(e)
+    } catch (e: IOException) {
+      LogUtil.e(e)
+    }
+  }
+}
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/database/ompiler/DatabaseStaticMethodsGenerator.kt b/compiler/src/main/java/promise/database/compiler/DatabaseStaticMethodsGenerator.kt
similarity index 94%
rename from compiler/src/main/java/promise/database/ompiler/DatabaseStaticMethodsGenerator.kt
rename to compiler/src/main/java/promise/database/compiler/DatabaseStaticMethodsGenerator.kt
index 285b65a..756d97a 100644
--- a/compiler/src/main/java/promise/database/ompiler/DatabaseStaticMethodsGenerator.kt
+++ b/compiler/src/main/java/promise/database/compiler/DatabaseStaticMethodsGenerator.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.database.ompiler
+package promise.database.compiler
 
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
@@ -19,10 +19,10 @@ import com.squareup.javapoet.FieldSpec
 import com.squareup.javapoet.MethodSpec
 import com.squareup.javapoet.TypeSpec
 import promise.database.AddedEntity
-import promise.database.ompiler.utils.JavaUtils
-import promise.database.ompiler.utils.getTableClassNameString
-import promise.database.ompiler.utils.getTableEntities
-import promise.database.ompiler.utils.toTypeName
+import promise.database.compiler.utils.JavaUtils
+import promise.database.compiler.utils.getTableClassNameString
+import promise.database.compiler.utils.getTableEntities
+import promise.database.compiler.utils.toTypeName
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
@@ -33,11 +33,15 @@ class DatabaseStaticMethodsGenerator(
     private val element: Element,
     private val processingEnv: ProcessingEnvironment) : CodeGenerator<String> {
 
+  private val tableMetaDataWriter = PromiseDatabaseCompiler.databaseMetaDataWriter
+
   override fun generate(): String {
     val className = element.simpleName.toString()
     val classnameImpl = "${className}Impl"
     val pack = processingEnv.elementUtils.getPackageOf(element).toString()
 
+    tableMetaDataWriter.process()
+
     val entities = (element as TypeElement).getTableEntities(processingEnv)
         .filter {
           it.getAnnotation(AddedEntity::class.java) != null
@@ -67,13 +71,13 @@ class DatabaseStaticMethodsGenerator(
 
     if (TypeConverterAnnotatedProcessor.typeConverter != null)
       typeSpec.addField(FieldSpec.builder(
-        TypeConverterAnnotatedProcessor.typeConverter!!.toTypeName(),
-        "typeConverter")
-        .addModifiers(Modifier.PRIVATE)
-        .addJavadoc("""
+          TypeConverterAnnotatedProcessor.typeConverter!!.toTypeName(),
+          "typeConverter")
+          .addModifiers(Modifier.PRIVATE)
+          .addJavadoc("""
           TypeConverter instance
         """.trimIndent())
-        .build())
+          .build())
 
     typeSpec.addField(FieldSpec.builder(Boolean::class.javaPrimitiveType, "initialized")
         .initializer("false")
diff --git a/compiler/src/main/java/promise/database/ompiler/EntityAnnotatedProcessor.kt b/compiler/src/main/java/promise/database/compiler/EntityAnnotatedProcessor.kt
similarity index 86%
rename from compiler/src/main/java/promise/database/ompiler/EntityAnnotatedProcessor.kt
rename to compiler/src/main/java/promise/database/compiler/EntityAnnotatedProcessor.kt
index 32cabb6..00a197b 100644
--- a/compiler/src/main/java/promise/database/ompiler/EntityAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/database/compiler/EntityAnnotatedProcessor.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.database.ompiler
+package promise.database.compiler
 
 import com.squareup.javapoet.AnnotationSpec
 import com.squareup.javapoet.ClassName
@@ -24,24 +24,28 @@ import com.squareup.javapoet.TypeName
 import com.squareup.javapoet.TypeSpec
 import org.jetbrains.annotations.NotNull
 import promise.database.Entity
-import promise.database.ompiler.utils.JavaUtils
-import promise.database.ompiler.utils.LogUtil
-import promise.database.ompiler.utils.checkIfAnyElementNeedsTypeConverter
-import promise.database.ompiler.utils.getTableClassNameString
+import promise.database.compiler.utils.JavaUtils
+import promise.database.compiler.utils.LogUtil
+import promise.database.compiler.utils.checkIfAnyElementNeedsTypeConverter
+import promise.database.compiler.utils.getTableClassNameString
+import promise.database.compiler.utils.getTableEntities
 import javax.annotation.processing.ProcessingEnvironment
 import javax.annotation.processing.RoundEnvironment
 import javax.lang.model.element.Element
-import javax.lang.model.element.ElementKind
 import javax.lang.model.element.Modifier
 import javax.lang.model.element.TypeElement
 
-class EntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment) : AnnotatedClassProcessor() {
+class EntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment,
+                               private val database: TypeElement) : AnnotatedClassProcessor() {
+
+  private val entities = database.getTableEntities(processingEnv)
+
   override fun process(environment: RoundEnvironment?): List<JavaFile.Builder?>? {
     val javaFiles = ArrayList<JavaFile.Builder?>()
     environment?.getElementsAnnotatedWith(Entity::class.java)
         ?.forEach { element ->
           val identifiableInterface = processingEnv.elementUtils.getTypeElement("promise.commons.model.Identifiable")
-          val declaredInterface = JavaUtils.toWildCardType(processingEnv, identifiableInterface, 1)
+          val declaredInterface =JavaUtils.toWildCardType(processingEnv, identifiableInterface, 1)
           if (!JavaUtils.isSubTypeOfDeclaredType(processingEnv, element as TypeElement, declaredInterface))
             LogUtil.e(Exception("The Entity class ${element.simpleName} must implement Identifiable"), element)
           else javaFiles.add(processAnnotation(element))
@@ -50,7 +54,8 @@ class EntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment)
   }
 
   private fun processAnnotation(element: Element): JavaFile.Builder {
-
+    if (!entities.map { it.asType().toString() }.contains(element.asType().toString()))
+      LogUtil.e(Exception("Entity class ${element.simpleName} is not registered in database"), database)
     val className = element.simpleName.toString()
     val pack = processingEnv.elementUtils.getPackageOf(element).toString()
 
@@ -79,7 +84,7 @@ class EntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment)
     classBuilder.addAnnotation(tableAnnotationSpec)
 
     val activeRecordType = processingEnv.elementUtils.getTypeElement("promise.db.ActiveRecord")
-    val declaredActiveRecordType = JavaUtils.toWildCardType(processingEnv, activeRecordType, 1)
+    val declaredActiveRecordType =JavaUtils.toWildCardType(processingEnv, activeRecordType, 1)
 
     if (JavaUtils.isSubTypeOfDeclaredType(processingEnv, (element as TypeElement), declaredActiveRecordType))
       classBuilder.addMethod(MethodSpec.methodBuilder("createEntityInstance")
@@ -149,7 +154,7 @@ class EntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment)
     columnSpecs.forEach {
       elemMap[it.key.first] = it.key.second
     }
-    val migrationGenerator = TableMigrationFieldGenerator(elemMap)
+    val migrationGenerator = TableMigrationFieldGenerator(element, elemMap)
     val migrationFunc = migrationGenerator.generate()
     if (migrationFunc != null) classBuilder.addMethod(migrationFunc)
 
diff --git a/compiler/src/main/java/promise/database/ompiler/PromiseDatabaseCompiler.kt b/compiler/src/main/java/promise/database/compiler/PromiseDatabaseCompiler.kt
similarity index 76%
rename from compiler/src/main/java/promise/database/ompiler/PromiseDatabaseCompiler.kt
rename to compiler/src/main/java/promise/database/compiler/PromiseDatabaseCompiler.kt
index 5061ab9..66bcfe2 100644
--- a/compiler/src/main/java/promise/database/ompiler/PromiseDatabaseCompiler.kt
+++ b/compiler/src/main/java/promise/database/compiler/PromiseDatabaseCompiler.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.database.ompiler
+package promise.database.compiler
 
 import com.google.auto.service.AutoService
 import com.squareup.javapoet.JavaFile
@@ -19,7 +19,8 @@ import promise.database.DAO
 import promise.database.DatabaseEntity
 import promise.database.Entity
 import promise.database.TypeConverter
-import promise.database.ompiler.utils.LogUtil
+import promise.database.compiler.utils.LogUtil
+import java.io.File
 import javax.annotation.processing.AbstractProcessor
 import javax.annotation.processing.ProcessingEnvironment
 import javax.annotation.processing.Processor
@@ -28,6 +29,9 @@ import javax.annotation.processing.SupportedOptions
 import javax.annotation.processing.SupportedSourceVersion
 import javax.lang.model.SourceVersion
 import javax.lang.model.element.TypeElement
+import javax.tools.JavaFileManager
+import javax.tools.StandardJavaFileManager
+import javax.tools.StandardLocation
 
 @AutoService(Processor::class)
 @SupportedSourceVersion(SourceVersion.RELEASE_8)
@@ -42,13 +46,22 @@ class PromiseDatabaseCompiler : AbstractProcessor() {
   override fun process(mutableSet: MutableSet<out TypeElement>?, environment: RoundEnvironment?): Boolean {
     if (mutableSet == null || mutableSet.isEmpty()) return false
     try {
+      val database = DatabaseEntityAnnotatedProcessor.getDatabaseElement(environment, processingEnv)
+      if (database != null) {
+        val pkg = processingEnv.elementUtils.getPackageOf(database).toString()
+        val projectFolder = File(File(File("${pkg}${File.separator}${database.simpleName}.java").parent).parent).parent
+//        val resource = processingEnv.filer.createResource(StandardJavaFileManager.getLocation(StandardLocation),
+//            "schemas", database.asType().toString() + ".yml")
+//        val schemaPath = resource.toUri().path
+        databaseMetaDataWriter = DatabaseMetaDataWriter(database, "${projectFolder}${File.separator}schemas${File.separator}${database.asType()}.yml")
+      } else LogUtil.e(Exception("No database class found in module"))
       val javaFiles: ArrayList<JavaFile.Builder> = ArrayList()
       val processors: ArrayList<AnnotatedClassProcessor> = ArrayList()
       processors.add(TypeConverterAnnotatedProcessor(processingEnv))
-      processors.add(EntityAnnotatedProcessor(processingEnv))
+      processors.add(EntityAnnotatedProcessor(processingEnv, database!!))
       processors.add(RelationsDaoProcessor(processingEnv))
       //processors.add(DAOAnnotatedProcessor(processingEnv))
-      processors.add(DatabaseEntityAnnotatedProcessor(processingEnv))
+      processors.add(DatabaseEntityAnnotatedProcessor(processingEnv, database))
       processors.forEach {
         val builders = it.process(environment)
         if (builders != null) javaFiles.addAll(builders.filterNotNull())
@@ -81,7 +94,7 @@ class PromiseDatabaseCompiler : AbstractProcessor() {
       }
       return true
     } catch (e: Throwable) {
-      LogUtil.e(e)
+      LogUtil.eTrace(e)
       return false
     }
   }
@@ -95,6 +108,7 @@ class PromiseDatabaseCompiler : AbstractProcessor() {
 
   companion object {
     const val KAPT_JAVA_GENERATED_OPTION_NAME = "kapt.java.generated"
+    lateinit var databaseMetaDataWriter: DatabaseMetaDataWriter
   }
 
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/database/ompiler/RelationsDaoGenerator.java b/compiler/src/main/java/promise/database/compiler/RelationsDaoGenerator.java
similarity index 97%
rename from compiler/src/main/java/promise/database/ompiler/RelationsDaoGenerator.java
rename to compiler/src/main/java/promise/database/compiler/RelationsDaoGenerator.java
index 3022d0a..ab317da 100644
--- a/compiler/src/main/java/promise/database/ompiler/RelationsDaoGenerator.java
+++ b/compiler/src/main/java/promise/database/compiler/RelationsDaoGenerator.java
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.database.ompiler;
+package promise.database.compiler;
 
 import com.squareup.javapoet.ArrayTypeName;
 import com.squareup.javapoet.ClassName;
@@ -42,17 +42,17 @@
 import promise.database.Entity;
 import promise.database.HasMany;
 import promise.database.HasOne;
-import promise.database.ompiler.utils.JavaUtils;
-import promise.database.ompiler.utils.LogUtil;
-import promise.database.ompiler.utils.PersistableEntityUtilsKt;
-import promise.database.ompiler.utils.Utils;
-import promise.database.ompiler.utils.UtilsKt;
-
-import static promise.database.ompiler.utils.PersistableEntityUtilsKt.asTableClassName;
-import static promise.database.ompiler.utils.PersistableEntityUtilsKt.camelCase;
-import static promise.database.ompiler.utils.PersistableEntityUtilsKt.capitalizeFirst;
-import static promise.database.ompiler.utils.PersistableEntityUtilsKt.getTableClassNameString;
-import static promise.database.ompiler.utils.PersistableEntityUtilsKt.pluralize;
+import promise.database.compiler.utils.JavaUtils;
+import promise.database.compiler.utils.LogUtil;
+import promise.database.compiler.utils.PersistableEntityUtilsKt;
+import promise.database.compiler.utils.Utils;
+import promise.database.compiler.utils.UtilsKt;
+
+import static promise.database.compiler.utils.PersistableEntityUtilsKt.asTableClassName;
+import static promise.database.compiler.utils.PersistableEntityUtilsKt.camelCase;
+import static promise.database.compiler.utils.PersistableEntityUtilsKt.capitalizeFirst;
+import static promise.database.compiler.utils.PersistableEntityUtilsKt.getTableClassNameString;
+import static promise.database.compiler.utils.PersistableEntityUtilsKt.pluralize;
 
 public class RelationsDaoGenerator implements CodeGenerator<List<JavaFile.Builder>> {
 
diff --git a/compiler/src/main/java/promise/database/ompiler/RelationsDaoProcessor.kt b/compiler/src/main/java/promise/database/compiler/RelationsDaoProcessor.kt
similarity index 94%
rename from compiler/src/main/java/promise/database/ompiler/RelationsDaoProcessor.kt
rename to compiler/src/main/java/promise/database/compiler/RelationsDaoProcessor.kt
index e815f85..d10174e 100644
--- a/compiler/src/main/java/promise/database/ompiler/RelationsDaoProcessor.kt
+++ b/compiler/src/main/java/promise/database/compiler/RelationsDaoProcessor.kt
@@ -11,11 +11,11 @@
  * limitations under the License.
  */
 
-package promise.database.ompiler
+package promise.database.compiler
 
 import com.squareup.javapoet.JavaFile
 import promise.database.Entity
-import promise.database.ompiler.utils.isElementAnnotatedAsRelation
+import promise.database.compiler.utils.isElementAnnotatedAsRelation
 import javax.annotation.processing.ProcessingEnvironment
 import javax.annotation.processing.RoundEnvironment
 import javax.lang.model.element.Element
diff --git a/compiler/src/main/java/promise/database/ompiler/TableAnnotationGenerator.java b/compiler/src/main/java/promise/database/compiler/TableAnnotationGenerator.java
similarity index 95%
rename from compiler/src/main/java/promise/database/ompiler/TableAnnotationGenerator.java
rename to compiler/src/main/java/promise/database/compiler/TableAnnotationGenerator.java
index 014823c..8c7cdac 100644
--- a/compiler/src/main/java/promise/database/ompiler/TableAnnotationGenerator.java
+++ b/compiler/src/main/java/promise/database/compiler/TableAnnotationGenerator.java
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.database.ompiler;
+package promise.database.compiler;
 
 import com.squareup.javapoet.AnnotationSpec;
 import com.squareup.javapoet.CodeBlock;
@@ -25,8 +25,9 @@
 
 import promise.database.Entity;
 import promise.database.Table;
-import promise.database.ompiler.utils.LogUtil;
-import promise.database.ompiler.utils.PersistableEntityUtilsKt;
+import promise.database.compiler.utils.LogUtil;
+import promise.database.compiler.utils.LogUtil;
+import promise.database.compiler.utils.PersistableEntityUtilsKt;
 
 public class TableAnnotationGenerator implements CodeGenerator<AnnotationSpec> {
   private Element element;
diff --git a/compiler/src/main/java/promise/database/ompiler/TableColumnFieldsGenerator.kt b/compiler/src/main/java/promise/database/compiler/TableColumnFieldsGenerator.kt
similarity index 95%
rename from compiler/src/main/java/promise/database/ompiler/TableColumnFieldsGenerator.kt
rename to compiler/src/main/java/promise/database/compiler/TableColumnFieldsGenerator.kt
index 416f10c..326400a 100644
--- a/compiler/src/main/java/promise/database/ompiler/TableColumnFieldsGenerator.kt
+++ b/compiler/src/main/java/promise/database/compiler/TableColumnFieldsGenerator.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.database.ompiler
+package promise.database.compiler
 
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
@@ -22,13 +22,13 @@ import promise.database.HasOne
 import promise.database.Ignore
 import promise.database.PrimaryKey
 import promise.database.PrimaryKeyAutoIncrement
-import promise.database.ompiler.utils.LogUtil
-import promise.database.ompiler.utils.checkIfHasTypeConverter
-import promise.database.ompiler.utils.getNameOfColumn
-import promise.database.ompiler.utils.isElementAnnotatedAsRelation
-import promise.database.ompiler.utils.isPersistable
-import promise.database.ompiler.utils.isSameAs
-import promise.database.ompiler.utils.toTypeName
+import promise.database.compiler.utils.LogUtil
+import promise.database.compiler.utils.checkIfHasTypeConverter
+import promise.database.compiler.utils.getNameOfColumn
+import promise.database.compiler.utils.isElementAnnotatedAsRelation
+import promise.database.compiler.utils.isPersistable
+import promise.database.compiler.utils.isSameAs
+import promise.database.compiler.utils.toTypeName
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
diff --git a/compiler/src/main/java/promise/database/ompiler/TableDeserializerMethodGenerator.kt b/compiler/src/main/java/promise/database/compiler/TableDeserializerMethodGenerator.kt
similarity index 86%
rename from compiler/src/main/java/promise/database/ompiler/TableDeserializerMethodGenerator.kt
rename to compiler/src/main/java/promise/database/compiler/TableDeserializerMethodGenerator.kt
index 2450d4f..93744cc 100644
--- a/compiler/src/main/java/promise/database/ompiler/TableDeserializerMethodGenerator.kt
+++ b/compiler/src/main/java/promise/database/compiler/TableDeserializerMethodGenerator.kt
@@ -11,12 +11,21 @@
  * limitations under the License.
  */
 
-package promise.database.ompiler
+package promise.database.compiler
 
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
 import com.squareup.javapoet.MethodSpec
 import com.squareup.javapoet.TypeName
+import promise.database.compiler.utils.ConverterTypes
+import promise.database.compiler.utils.JavaUtils
+import promise.database.compiler.utils.camelCase
+import promise.database.compiler.utils.capitalizeFirst
+import promise.database.compiler.utils.checkIfHasTypeConverter
+import promise.database.compiler.utils.getConverterCompatibleMethod
+import promise.database.compiler.utils.isElementAnnotatedAsRelation
+import promise.database.compiler.utils.isSameAs
+import promise.database.compiler.utils.toTypeName
 import promise.database.ompiler.utils.*
 import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
diff --git a/compiler/src/main/java/promise/database/compiler/TableMetaDataWriter.kt b/compiler/src/main/java/promise/database/compiler/TableMetaDataWriter.kt
new file mode 100644
index 0000000..26adf0b
--- /dev/null
+++ b/compiler/src/main/java/promise/database/compiler/TableMetaDataWriter.kt
@@ -0,0 +1,110 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.database.compiler
+
+import promise.database.Ignore
+import promise.database.Migrate
+import promise.database.MigrationOptions
+import promise.database.Migrations
+import promise.database.compiler.migration.Field
+import promise.database.compiler.migration.TableMetaData
+import promise.database.compiler.migration.TableMigration
+import promise.database.compiler.migration.VersionChange
+import promise.database.compiler.utils.getNameOfColumn
+import promise.database.compiler.utils.getTableName
+import javax.lang.model.element.Element
+import javax.lang.model.util.ElementFilter
+
+class TableMetaDataWriter(
+    private val entityElement: Element,
+    private val elements: Map<Element, String>) {
+
+  companion object {
+    val tableMetaData: ArrayList<TableMetaData> = ArrayList()
+    init {
+      if (PromiseDatabaseCompiler.databaseMetaDataWriter.currentDatabaseMetaData == null)
+        PromiseDatabaseCompiler.databaseMetaDataWriter.loadCurrentMetaData()
+    }
+  }
+
+  fun process(
+      //elements: Map<Element, String>
+  ): promise.database.compiler.utils.List<TableMigration> {
+    val migrateFields = elements.filter {
+      it.key.getAnnotation(Migrate::class.java) != null ||
+          it.key.getAnnotation(Migrations::class.java) != null
+    }
+
+    val tableMigrations = promise.database.compiler.utils.List<TableMigration>()
+    if (migrateFields.isEmpty()) {
+
+    }
+    else {
+      migrateFields.forEach { entry ->
+        if (entry.key.getAnnotation(Migrate::class.java) != null) {
+          val migration = entry.key.getAnnotation(Migrate::class.java)
+          tableMigrations.add(TableMigration().apply {
+            versionChange = VersionChange().apply {
+              fromVersion = migration.fromVersion
+              toVersion = migration.toVersion
+            }
+            field = if (migration.action == MigrationOptions.CREATE_INDEX) entry.key.getNameOfColumn() else entry.value
+            action = migration.action
+          })
+        } else if (entry.key.getAnnotation(Migrations::class.java) != null) {
+          val migrations = entry.key.getAnnotation(Migrations::class.java)
+          migrations.values.forEach {
+            val migration = it
+            tableMigrations.add(TableMigration().apply {
+              versionChange = VersionChange().apply {
+                fromVersion = migration.fromVersion
+                toVersion = migration.toVersion
+              }
+              field = if (migration.action == MigrationOptions.CREATE_INDEX) entry.key.getNameOfColumn() else entry.value
+              action = migration.action
+            })
+          }
+        }
+      }
+    }
+    val metaData = TableMetaData()
+    val oldMetaData = promise.database.compiler.utils.List<TableMetaData>(PromiseDatabaseCompiler.databaseMetaDataWriter.currentDatabaseMetaData!!.tableMetaData)
+        .find {
+          it.tableName == entityElement.getTableName()
+        }
+    if (oldMetaData != null) {
+      val diffMigrations= promise.database.compiler.utils.List(oldMetaData.migrations).joinOn(
+          promise.database.compiler.utils.List(tableMigrations)) { t, u -> t != u }
+      tableMigrations.addAll(diffMigrations)
+      metaData.migrations = tableMigrations
+    }
+    else metaData.migrations = tableMigrations
+    val fields: ArrayList<Field> = ArrayList()
+    ElementFilter.fieldsIn(entityElement.enclosedElements).filter {
+      it.getAnnotation(Ignore::class.java) == null
+    }
+        .forEach {
+          fields.add(Field().apply {
+            fieldName = it.simpleName.toString()
+            columnName = it.getNameOfColumn()
+          })
+        }
+
+    metaData.fields = fields
+    metaData.tableName = entityElement.getTableName()
+    tableMetaData.add(metaData)
+    return tableMigrations
+  }
+
+}
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/database/ompiler/TableMigrationFieldGenerator.kt b/compiler/src/main/java/promise/database/compiler/TableMigrationFieldGenerator.kt
similarity index 52%
rename from compiler/src/main/java/promise/database/ompiler/TableMigrationFieldGenerator.kt
rename to compiler/src/main/java/promise/database/compiler/TableMigrationFieldGenerator.kt
index ae2d789..2139558 100644
--- a/compiler/src/main/java/promise/database/ompiler/TableMigrationFieldGenerator.kt
+++ b/compiler/src/main/java/promise/database/compiler/TableMigrationFieldGenerator.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.database.ompiler
+package promise.database.compiler
 
 import com.squareup.javapoet.AnnotationSpec
 import com.squareup.javapoet.ClassName
@@ -21,65 +21,68 @@ import org.jetbrains.annotations.NotNull
 import promise.database.Migrate
 import promise.database.MigrationOptions
 import promise.database.Migrations
-import promise.database.ompiler.utils.getNameOfColumn
+import promise.database.compiler.migration.TableMigration
+import promise.database.compiler.migration.VersionChange
+import promise.database.compiler.utils.List
+import promise.database.compiler.utils.getNameOfColumn
 import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
 
 class TableMigrationFieldGenerator(
+    private val entityElement: Element,
     private val elements: Map<Element, String>) : CodeGenerator<MethodSpec?> {
 
-  private fun buildIndexMigration(
-      codeBlock: CodeBlock.Builder,
-      column: String,
-      migration: Migrate) {
-    if (migration.action == MigrationOptions.CREATE_INDEX) {
-      codeBlock.add("if (v1 == ${migration.fromVersion} && v2 == ${migration.toVersion}) {\n")
-      codeBlock.indent()
-      codeBlock.addStatement("addIndex(x, \"${column}\")")
-      codeBlock.unindent()
-      codeBlock.add("}\n")
-    }
-  }
-
   private fun buildMigration(
-      codeBlock: CodeBlock.Builder,
-      column: String,
-      migration: Migrate) {
-    if (migration.action == MigrationOptions.CREATE) {
-      codeBlock.add("if (v1 == ${migration.fromVersion} && v2 == ${migration.toVersion}) {\n")
-      codeBlock.indent()
-      codeBlock.addStatement("addColumns(x, ${column})")
-      codeBlock.unindent()
-      codeBlock.add("}\n")
-    } else if (migration.action == MigrationOptions.DROP) {
-      codeBlock.add("if (v1 == ${migration.fromVersion} && v2 == ${migration.toVersion}) {\n")
-      codeBlock.indent()
-      codeBlock.addStatement("dropColumns(x, ${column})")
-      codeBlock.unindent()
-      codeBlock.add("}\n")
-    }
+      versionChange: VersionChange,
+      tableMigrations: List<out TableMigration>,
+      codeBlock: CodeBlock.Builder) {
+    codeBlock.add("if (v1 == ${versionChange.fromVersion} && v2 == ${versionChange.toVersion}) {\n")
+    codeBlock.indent()
+    tableMigrations.groupBy { it.action }
+        .forEach {category ->
+          when (category.name()) {
+            MigrationOptions.CREATE -> {
+              val list: StringBuilder = StringBuilder("")
+              category.list().forEachIndexed { index, tableMigration ->
+                list.append("${tableMigration.field}")
+                if (index != category.list().size - 1) list.append(", ")
+              }
+              codeBlock.addStatement("addColumns(x, $list)")
+            }
+            MigrationOptions.DROP -> {
+              val list: StringBuilder = StringBuilder("")
+              category.list().forEachIndexed { index, tableMigration ->
+                list.append("${tableMigration.field}")
+                if (index != category.list().size - 1) list.append(", ")
+              }
+              codeBlock.addStatement("dropColumns(x, $list)")
+            }
+            MigrationOptions.CREATE_INDEX -> category.list().forEach {
+              codeBlock.addStatement("addIndex(x, \"${it.field}\")")
+            }
+          }
+        }
+    codeBlock.unindent()
+    codeBlock.add("}\n")
   }
 
   override fun generate(): MethodSpec? {
+
+    val tableMetaDataWriter = TableMetaDataWriter(entityElement, elements)
+    tableMetaDataWriter.process()
+
     val migrateFields = elements.filter {
       it.key.getAnnotation(Migrate::class.java) != null ||
           it.key.getAnnotation(Migrations::class.java) != null
     }
+
     if (migrateFields.isEmpty()) return null
     val codeBlock = CodeBlock.builder()
-    migrateFields.forEach {
-      val migration = it.key.getAnnotation(Migrate::class.java)
-      if (migration != null) {
-        if (migration.action == MigrationOptions.CREATE_INDEX)
-          buildIndexMigration(codeBlock, it.key.getNameOfColumn(), migration)
-        else buildMigration(codeBlock, it.value, migration)
-        return@forEach
-      }
-      val migrations = it.key.getAnnotation(Migrations::class.java)
-      migrations?.values?.forEach { m ->
-        buildMigration(codeBlock, it.value, m)
-      }
-    }
+    val tableMigrations = tableMetaDataWriter.process()
+    tableMigrations.groupBy { it.versionChange }
+        .forEach {
+          buildMigration(it.name()!!, it.list(), codeBlock)
+        }
 
     return MethodSpec.methodBuilder("onUpgrade")
         .addParameter(
diff --git a/compiler/src/main/java/promise/database/ompiler/TableRegisteredColumnsMethodGenerator.kt b/compiler/src/main/java/promise/database/compiler/TableRegisteredColumnsMethodGenerator.kt
similarity index 98%
rename from compiler/src/main/java/promise/database/ompiler/TableRegisteredColumnsMethodGenerator.kt
rename to compiler/src/main/java/promise/database/compiler/TableRegisteredColumnsMethodGenerator.kt
index 07455be..5fe5536 100644
--- a/compiler/src/main/java/promise/database/ompiler/TableRegisteredColumnsMethodGenerator.kt
+++ b/compiler/src/main/java/promise/database/compiler/TableRegisteredColumnsMethodGenerator.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.database.ompiler
+package promise.database.compiler
 
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
diff --git a/compiler/src/main/java/promise/database/ompiler/TableSerializerMethodGenerator.kt b/compiler/src/main/java/promise/database/compiler/TableSerializerMethodGenerator.kt
similarity index 84%
rename from compiler/src/main/java/promise/database/ompiler/TableSerializerMethodGenerator.kt
rename to compiler/src/main/java/promise/database/compiler/TableSerializerMethodGenerator.kt
index 000ef2e..339d6cf 100644
--- a/compiler/src/main/java/promise/database/ompiler/TableSerializerMethodGenerator.kt
+++ b/compiler/src/main/java/promise/database/compiler/TableSerializerMethodGenerator.kt
@@ -11,19 +11,19 @@
  * limitations under the License.
  */
 
-package promise.database.ompiler
+package promise.database.compiler
 
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
 import com.squareup.javapoet.MethodSpec
-import promise.database.ompiler.utils.ConverterTypes
-import promise.database.ompiler.utils.JavaUtils
-import promise.database.ompiler.utils.capitalizeFirst
-import promise.database.ompiler.utils.checkIfHasTypeConverter
-import promise.database.ompiler.utils.getConverterCompatibleMethod
-import promise.database.ompiler.utils.isElementAnnotatedAsRelation
-import promise.database.ompiler.utils.isSameAs
-import promise.database.ompiler.utils.toTypeName
+import promise.database.compiler.utils.ConverterTypes
+import promise.database.compiler.utils.JavaUtils
+import promise.database.compiler.utils.capitalizeFirst
+import promise.database.compiler.utils.checkIfHasTypeConverter
+import promise.database.compiler.utils.getConverterCompatibleMethod
+import promise.database.compiler.utils.isElementAnnotatedAsRelation
+import promise.database.compiler.utils.isSameAs
+import promise.database.compiler.utils.toTypeName
 import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
 
diff --git a/compiler/src/main/java/promise/database/ompiler/TypeConverterAnnotatedProcessor.kt b/compiler/src/main/java/promise/database/compiler/TypeConverterAnnotatedProcessor.kt
similarity index 92%
rename from compiler/src/main/java/promise/database/ompiler/TypeConverterAnnotatedProcessor.kt
rename to compiler/src/main/java/promise/database/compiler/TypeConverterAnnotatedProcessor.kt
index d108525..9de821b 100644
--- a/compiler/src/main/java/promise/database/ompiler/TypeConverterAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/database/compiler/TypeConverterAnnotatedProcessor.kt
@@ -11,13 +11,13 @@
  * limitations under the License.
  */
 
-package promise.database.ompiler
+package promise.database.compiler
 
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.JavaFile
 import promise.database.TypeConverter
-import promise.database.ompiler.utils.LogUtil
-import promise.database.ompiler.utils.Utils
+import promise.database.compiler.utils.LogUtil
+import promise.database.compiler.utils.Utils
 import java.util.*
 import javax.annotation.processing.ProcessingEnvironment
 import javax.annotation.processing.RoundEnvironment
@@ -34,7 +34,7 @@ class TypeConverterAnnotatedProcessor(private val processingEnv: ProcessingEnvir
         typeConverter = typeConverters.first() as TypeElement
         return Collections.singletonList(processElement(typeConverter!!))
       } catch (e: Throwable) {
-        LogUtil.e(e, typeConverter)
+       LogUtil.e(e, typeConverter)
       }
     }
     return null
diff --git a/compiler/src/main/java/promise/database/compiler/migration/DatabaseMetaData.kt b/compiler/src/main/java/promise/database/compiler/migration/DatabaseMetaData.kt
new file mode 100644
index 0000000..a35a124
--- /dev/null
+++ b/compiler/src/main/java/promise/database/compiler/migration/DatabaseMetaData.kt
@@ -0,0 +1,19 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.database.compiler.migration
+
+class DatabaseMetaData {
+  var dbVersion: Int = 1
+  var tableMetaData: List<TableMetaData> = emptyList()
+}
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/database/compiler/migration/TableMetaData.kt b/compiler/src/main/java/promise/database/compiler/migration/TableMetaData.kt
new file mode 100644
index 0000000..2421359
--- /dev/null
+++ b/compiler/src/main/java/promise/database/compiler/migration/TableMetaData.kt
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.database.compiler.migration
+
+import com.fasterxml.jackson.annotation.JsonInclude
+
+class Field {
+  var fieldName = ""
+  var columnName = ""
+  var nullable = true
+  var length  = 0
+}
+
+class TableMetaData {
+  var tableName: String = ""
+  var fields: List<Field> = emptyList()
+
+  @JsonInclude(JsonInclude.Include.NON_NULL)
+  var migrations : List<TableMigration> = emptyList()
+}
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/database/compiler/migration/TableMigration.kt b/compiler/src/main/java/promise/database/compiler/migration/TableMigration.kt
new file mode 100644
index 0000000..5db1544
--- /dev/null
+++ b/compiler/src/main/java/promise/database/compiler/migration/TableMigration.kt
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.database.compiler.migration
+
+import promise.database.MigrationOptions
+
+class TableMigration {
+   var versionChange: VersionChange? = null
+   var field: String? = null
+   var action: MigrationOptions? = null
+
+   override fun equals(other: Any?): Boolean {
+      if (javaClass != other?.javaClass) return false
+      other as TableMigration
+
+      if (versionChange != other.versionChange) return false
+      if (field != other.field) return false
+      if (action != other.action) return false
+      return true
+   }
+
+   override fun hashCode(): Int {
+      var result = versionChange?.hashCode() ?: 0
+      result = 31 * result + (field?.hashCode() ?: 0)
+      result = 31 * result + (action?.hashCode() ?: 0)
+      return result
+   }
+}
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/database/compiler/migration/VersionChange.kt b/compiler/src/main/java/promise/database/compiler/migration/VersionChange.kt
new file mode 100644
index 0000000..acc1b53
--- /dev/null
+++ b/compiler/src/main/java/promise/database/compiler/migration/VersionChange.kt
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.database.compiler.migration
+
+class VersionChange {
+   var fromVersion: Int = 0
+    var toVersion: Int = 0
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (javaClass != other?.javaClass) return false
+    other as VersionChange
+    if (fromVersion != other.fromVersion) return false
+    if (toVersion != other.toVersion) return false
+    return true
+  }
+
+  override fun hashCode(): Int {
+    var result = fromVersion
+    result = 31 * result + toVersion
+    return result
+  }
+}
diff --git a/compiler/src/main/java/promise/database/compiler/utils/Arrangeable.java b/compiler/src/main/java/promise/database/compiler/utils/Arrangeable.java
new file mode 100644
index 0000000..b5ea39b
--- /dev/null
+++ b/compiler/src/main/java/promise/database/compiler/utils/Arrangeable.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.database.compiler.utils;
+
+public class Arrangeable<Value, Key> {
+  private Value value;
+  private Key key;
+
+  Value value() {
+    return value;
+  }
+
+  Arrangeable<Value, Key> value(Value value) {
+    this.value = value;
+    return this;
+  }
+
+  Key key() {
+    return key;
+  }
+
+  Arrangeable<Value, Key> key(Key key) {
+    this.key = key;
+    return this;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    Arrangeable<?, ?> that = (Arrangeable<?, ?>) o;
+    return value.equals(that.value) &&
+        key.equals(that.key);
+  }
+
+  @Override
+  public int hashCode() {
+    return key.hashCode() + value.hashCode();
+  }
+}
+
diff --git a/compiler/src/main/java/promise/database/compiler/utils/Category.java b/compiler/src/main/java/promise/database/compiler/utils/Category.java
new file mode 100644
index 0000000..1d15fc9
--- /dev/null
+++ b/compiler/src/main/java/promise/database/compiler/utils/Category.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.database.compiler.utils;
+
+public class Category<K, T> {
+  private List<? extends T> list;
+  private K name;
+
+  Category(K name) {
+    this.name = name;
+  }
+
+  public List<? extends T> list() {
+    return list;
+  }
+
+  public Category<K, T> list(List<? extends T> list) {
+    this.list = list;
+    return this;
+  }
+
+  public K name() {
+    return name;
+  }
+
+  public Category<K, T> name(K name) {
+    this.name = name;
+    return this;
+  }
+}
+
diff --git a/compiler/src/main/java/promise/database/ompiler/utils/JavaUtils.java b/compiler/src/main/java/promise/database/compiler/utils/JavaUtils.java
similarity index 99%
rename from compiler/src/main/java/promise/database/ompiler/utils/JavaUtils.java
rename to compiler/src/main/java/promise/database/compiler/utils/JavaUtils.java
index 2e87050..d19ad60 100644
--- a/compiler/src/main/java/promise/database/ompiler/utils/JavaUtils.java
+++ b/compiler/src/main/java/promise/database/compiler/utils/JavaUtils.java
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.database.ompiler.utils;
+package promise.database.compiler.utils;
 
 import com.squareup.javapoet.ClassName;
 import com.squareup.javapoet.CodeBlock;
diff --git a/compiler/src/main/java/promise/database/compiler/utils/List.java b/compiler/src/main/java/promise/database/compiler/utils/List.java
new file mode 100644
index 0000000..5935a56
--- /dev/null
+++ b/compiler/src/main/java/promise/database/compiler/utils/List.java
@@ -0,0 +1,527 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.database.compiler.utils;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+
+import kotlin.Pair;
+import promise.database.compiler.utils.function.BIConsumer;
+import promise.database.compiler.utils.function.Combiner;
+import promise.database.compiler.utils.function.FilterFunction;
+import promise.database.compiler.utils.function.FilterFunction2;
+import promise.database.compiler.utils.function.GroupFunction;
+import promise.database.compiler.utils.function.GroupFunction2;
+import promise.database.compiler.utils.function.BIConsumer;
+import promise.database.compiler.utils.function.Combiner;
+import promise.database.compiler.utils.function.FilterFunction;
+import promise.database.compiler.utils.function.FilterFunction2;
+import promise.database.compiler.utils.function.GroupFunction;
+import promise.database.compiler.utils.function.GroupFunction2;
+import promise.database.compiler.utils.function.GroupFunction3;
+import promise.database.compiler.utils.function.JoinFunction;
+import promise.database.compiler.utils.function.MapFunction;
+import promise.database.compiler.utils.function.MapIndexFunction;
+import promise.database.compiler.utils.function.ReduceFunction;
+
+public class List<T> extends ArrayList<T> {
+  /**
+   * Constructs an empty list with the specified initial capacity.
+   *
+   * @param initialCapacity the initial capacity of the list
+   * @throws IllegalArgumentException if the specified initial capacity is negative
+   */
+  public List(int initialCapacity) {
+    super(initialCapacity);
+  }
+
+  /**
+   * Constructs an empty list with an initial capacity of ten.
+   */
+  public List() {
+  }
+
+  /**
+   * Constructs a list containing the elements of the specified collection, in the order they are
+   * returned by the collection's iterator.
+   *
+   * @param c the collection whose elements are to be placed into this list
+   * @throws NullPointerException if the specified collection is null
+   */
+  public List(Collection<? extends T> c) {
+    super(c);
+  }
+
+  /**
+   * returns a list from an array of args
+   *
+   * @param t   array of args
+   * @param <T> type of list elements
+   * @return a list
+   */
+  @SafeVarargs
+  public static <T> List<T> fromArray(T... t) {
+    return new List<>(Arrays.asList(t));
+  }
+
+  public static <T> List<T> generate(int num, MapFunction<? extends T, ? super Integer> function) {
+    List<T> list = new List<>();
+    for (int i = 0; i < num; i++) list.add(function.from(i));
+    return list;
+  }
+
+  /**
+   * reverses this list
+   *
+   * @return a reversed list
+   */
+  public List<T> reverse() {
+    Collections.reverse(this);
+    return this;
+  }
+
+  /**
+   * gets a sample elements from the list
+   *
+   * @param size elements to take
+   *             {@link java.util.List#subList(int, int)}
+   *             where fromIndex is zero
+   * @return a sublist
+   */
+  public List<T> take(int size) {
+    List<T> list = new List<>();
+    if (size() > size) for (int i = 0; i < size; i++) list.add(get(i));
+    else list = this;
+    return list;
+  }
+
+  /**
+   * finds an item within the list
+   *
+   * @param function select function
+   * @return an item or null if not found
+   */
+  @Nullable
+  public T find(FilterFunction<? super T> function) {
+    return filter(function).first();
+  }
+
+  /**
+   * find the index where the condition in the select function is true
+   * returns -1 if item is not found
+   *
+   * @param function select function
+   * @return index of item marching the condition
+   */
+  public int findIndex(FilterFunction<? super T> function) {
+    int match = 0;
+    for (T t : this) {
+      if (function.select(t)) return match;
+      match++;
+    }
+    return -1;
+  }
+
+  /**
+   * shiffle the elements of the list
+   *
+   * @return
+   */
+  public List<T> shuffled() {
+    Collections.shuffle(this);
+    return this;
+  }
+
+  /**
+   * return a transformation of all the items
+   *
+   * @param function transformer function
+   * @param <E>      desires transformation result
+   * @return transformed list
+   */
+  public <E> List<E> map(MapFunction<? extends E, ? super T> function) {
+    List<E> list = new List<>();
+    for (T t : this) list.add(function.from(t));
+    return list;
+  }
+
+  public <E> List<E> mapIndexed(MapIndexFunction<? extends E, ? super T> function) {
+    List<E> list = new List<>();
+    for (int i = 0; i < this.size(); i++) {
+      T t = get(i);
+      list.add(function.from(i, t));
+    }
+    return list;
+  }
+/*
+    public <K, V> Map<K, V> associate(MapFunction<Pair<K, V>, ? super T> function) {
+
+    }
+
+    public List<List<T>> chucked(int chuckSize) {
+
+    }
+
+    public <R> List<R> chucked(int chuckSize, MapFunction<List<? extends T>, ? super R> function) {
+
+    }*/
+
+  public Pair<List<? extends T>, List<? extends T>> partition(FilterFunction<? super T> function) {
+    List<T> first = new List<>();
+    List<T> second = new List<>();
+    for (T t : this) {
+      if (function.select(t)) first.add(t);
+      else second.add(t);
+    }
+    return new Pair(first, second);
+  }
+
+  /**
+   * sorts the elements of the list
+   *
+   * @param comparator compare function
+   * @return sorted list
+   */
+  public List<T> sorted(Comparator<? super T> comparator) {
+    Collections.sort(this, comparator);
+    return this;
+  }
+
+  /**
+   * arrange the list based on an atrribute that is not in blueprint of original items
+   *
+   * @param function   transformer for list to desired attribute that is sortable
+   * @param comparator compare fucntion that compares the result of the transformer
+   * @param <K>        desired compare type
+   * @return a sorted list
+   */
+  public <K> List<T> arranged(final MapFunction<? extends K, ? super T> function, final Comparator<? super K> comparator) {
+    return map(t -> new Arrangeable<T, K>().value(t).key(function.from(t)))
+        .sorted(
+            (o1, o2) -> comparator.compare(o1.key(), o2.key()))
+        .map(Arrangeable::value);
+  }
+
+  /**
+   * groups the items into collections with similar attributes
+   *
+   * @param function group function
+   * @param <E>      type that will contain one group of similar items
+   * @return list of collected groups
+   */
+  public <E> List<E> group(GroupFunction3<E, T> function) {
+    return function.group(this);
+  }
+
+  /**
+   * groups the items into groups with similar attributes
+   *
+   * @param function group function
+   * @param <K>      type of similar attribute
+   * @param <E>      collected group type
+   * @return a list of collected group type
+   */
+  public <K, E> List<E> group(GroupFunction2<K, E, T> function) {
+    List<E> es = new List<>();
+    Map<K, List<T>> map = new LinkedHashMap<>();
+    for (int i = 0, size = this.size(); i < size; i++) {
+      T t = this.get(i);
+      K key = function.getKey(t);
+      if (map.containsKey(key)) {
+        List<T> list = map.get(key);
+        list.add(t);
+      } else {
+        List<T> list = new List<>();
+        list.add(t);
+        map.put(key, list);
+      }
+    }
+    for (Map.Entry<K, List<T>> entry : map.entrySet()) {
+      E e = function.get(entry.getKey());
+      function.apply(e, entry.getValue());
+      es.add(e);
+    }
+    return es;
+  }
+
+  /**
+   * groups a list of items with similar attribute
+   *
+   * @param function group function
+   * @param <K>      similar attribute type
+   * @return a list of category of items
+   * each category returned has a list of items with their similar attribute
+   * {@link Category#list() contains grouped items}
+   * {@link Category#name()} contains the name of group that is the same as the value of the similar attribute
+   */
+  public <K> List<Category<K, T>> groupBy(final GroupFunction<? extends K, ? super T> function) {
+    return group(
+        new GroupFunction2<K, Category<K, T>, T>() {
+          @Override
+          public K getKey(T t) {
+            return function.getKey(t);
+          }
+
+          @Override
+          public Category<K, T> get(K k) {
+            return new Category<>(k);
+          }
+
+          @Override
+          public void apply(Category<K, T> category, List<T> list) {
+            category.list(list);
+          }
+        });
+  }
+
+  /**
+   * reduces this list to only contain the elements with similarity to the elements in the
+   * provided list
+   *
+   * @param uList    compare list
+   * @param function compare function that compares each item in this list to each item
+   *                 in the provided uList
+   * @param <U>      type of item in uList
+   * @return a small list with elements similar to the elements in uList
+   */
+  public <U> List<T> joinOn(List<? extends U> uList, JoinFunction<? super T, ? super U> function) {
+    List<T> ts = new List<>();
+    for (int i = 0, tSize = this.size(); i < tSize; i++) {
+      T t = this.get(i);
+      for (int i1 = 0, uSize = uList.size(); i1 < uSize; i1++) {
+        U u = uList.get(i1);
+        if (function.joinBy(t, u)) {
+          ts.add(t);
+          break;
+        }
+      }
+    }
+    return ts;
+  }
+
+  public <U> List<T> join(List<? extends U> uList, Combiner<? super U, T> function) {
+    if (this.size() != uList.size())
+      throw new IllegalArgumentException("Samples must be of same size");
+    List<T> ts = new List<>();
+    for (int i = 0, size = this.size(); i < size; i++) {
+      T t = this.get(i);
+      U u = uList.get(i);
+      ts.add(function.join(t, u));
+    }
+    return ts;
+  }
+
+  /**
+   * returns a list with no duplicate elements
+   *
+   * @return
+   */
+  public List<T> uniques() {
+    return new List<>(new HashSet<>(this));
+  }
+
+  /**
+   * returns a list with unique items based on a given attribute in each item in the list
+   *
+   * @param function     maps to the items that is supposed to be unique
+   * @param joinFunction reduces the this list with the result
+   *                     of unique list of attribute that is supposed to be unique
+   * @param <K>          type of desired unique attribute
+   * @return a unique list if items
+   */
+  public <K> List<T> uniques(MapFunction<? extends K, ? super T> function, JoinFunction<? super T, ? super K> joinFunction) {
+    return joinOn(map(function).uniques(), joinFunction);
+  }
+
+  /**
+   * reduces this list with comparing to the elements of another list
+   *
+   * @param uList    list to compare from
+   * @param function filter function for each item
+   * @param equals  flags to compare equality or no equality
+   * @param <U>      type of list item to compare from
+   * @param <K>      type of attribute to compare
+   * @return a reduced list
+   */
+  public <U, K> List<T> reduce(
+      List<? extends U> uList, final FilterFunction2<? extends K, ? super U, ? super T> function, final boolean equals) {
+    final Set<K> set = new HashSet<>(uList.map(
+        function::getKey));
+    return filter(
+        t -> {
+          if (equals) return set.contains(function.filterBy(t));
+          else return !set.contains(function.filterBy(t));
+        });
+  }
+
+  /**
+   * @param list
+   * @param reverse
+   * @param function
+   * @param combiner
+   * @param <K>
+   * @param <U>
+   * @return
+   */
+  public <K, U> List<T> merge(
+      List<? extends U> list,
+      final boolean reverse,
+      final FilterFunction2<? extends K, ? super U, ? super T> function,
+      Combiner<? super U, T> combiner) {
+    final Set<K> set = new HashSet<>(list.map(
+        function::getKey));
+    return filter(
+        t -> reverse == set.contains(function.filterBy(t)))
+        .join(list, combiner);
+  }
+
+  /**
+   * @param list
+   * @param function
+   * @param <K>
+   * @param <MERGE>
+   * @return
+   */
+  public <K, MERGE> List<Pair<T, K>> mergeWith(List<? extends K> list, final FilterFunction2<? extends MERGE, ? super K, ? super T> function) {
+    List<Pair<T, K>> list1 = new List<>();
+    /*Set<Arrangeable<K, MERGE>> set = new HashSet<>(
+        list.map(new MapFunction<Arrangeable<K, MERGE>, K>() {
+          @Override
+          public Arrangeable<K, MERGE> from(K k) {
+            return new Arrangeable<K, MERGE>().key(function.getKey(k)).value(k);
+          }
+        })
+    );*/
+    for (T t : this)
+      for (K k : list)
+        if (function.getKey(k).equals(function.filterBy(t))) list1.add(new Pair<>(t, k));
+    return list1;
+  }
+
+  /**
+   * returns whether there's an item in the list that matches the condition flagged in the function
+   *
+   * @param function flag function
+   * @return if there's an item matching in the list
+   */
+  public boolean anyMatch(FilterFunction<? super T> function) {
+    boolean match = false;
+    for (T t : this)
+      if (function.select(t)) {
+        match = true;
+        break;
+      }
+    return match;
+  }
+
+  /**
+   * returns whether all the items in this list match the condition in the flag function
+   *
+   * @param function flag function
+   * @return if all items match the flag condition
+   */
+  public boolean allMatch(FilterFunction<? super T> function) {
+    boolean match = true;
+    for (T t : this)
+      match = match && function.select(t);
+    return match;
+  }
+
+  /**
+   * filters this list to only items matching the condition
+   *
+   * @param function filter function
+   * @return a reduces list
+   */
+  public List<T> filter(FilterFunction<? super T> function) {
+    List<T> list = new List<>();
+    for (T t : this) if (function.select(t)) list.add(t);
+    return list;
+  }
+
+  /**
+   * @param list
+   * @param function
+   * @param <U>
+   * @return
+   */
+  public <U> List<T> reduce(List<? extends U> list, JoinFunction<? super T, ? super U> function) {
+    List<T> ts = new List<>();
+    for (int i = 0; i < this.size(); i++) {
+      T t = this.get(i);
+      for (int j = 0; j < list.size(); j++)
+        if (!function.joinBy(t, list.get(j))) {
+          ts.add(t);
+          break;
+        }
+    }
+    return ts;
+  }
+
+  /**
+   * @param consumer
+   */
+  public void biConsume(BIConsumer<? super T, ? super T> consumer) {
+    Iterator<T> it = iterator();
+    if (!it.hasNext()) return;
+    T first = it.next();
+    while (it.hasNext()) {
+      T next = it.next();
+      consumer.accept(first, next);
+      first = next;
+    }
+  }
+
+  /**
+   * gets the first element in the list
+   *
+   * @return first element
+   */
+  @Nullable
+  public T first() {
+    return this.isEmpty() ? null : this.get(0);
+  }
+
+  /**
+   * gets the last element in the list
+   *
+   * @return last element
+   */
+  @Nullable
+  public T last() {
+    return this.isEmpty() ? null : get(size() - 1);
+  }
+
+  /**
+   * reduces all the items in the list to one result
+   *
+   * @param function reducing function
+   * @param <K>      desired type of reduce result
+   * @return an instance of reduce result
+   */
+  public <K> K reduce(ReduceFunction<? extends K, T> function) {
+    return function.reduce(this);
+  }
+}
+
diff --git a/compiler/src/main/java/promise/database/ompiler/utils/LogUtil.java b/compiler/src/main/java/promise/database/compiler/utils/LogUtil.java
similarity index 87%
rename from compiler/src/main/java/promise/database/ompiler/utils/LogUtil.java
rename to compiler/src/main/java/promise/database/compiler/utils/LogUtil.java
index 3aff843..b909c55 100644
--- a/compiler/src/main/java/promise/database/ompiler/utils/LogUtil.java
+++ b/compiler/src/main/java/promise/database/compiler/utils/LogUtil.java
@@ -11,7 +11,9 @@
  * limitations under the License.
  */
 
-package promise.database.ompiler.utils;
+package promise.database.compiler.utils;
+
+import java.util.Arrays;
 
 import javax.annotation.processing.ProcessingEnvironment;
 import javax.lang.model.element.Element;
@@ -52,7 +54,12 @@ public static void n(Object... messages) {
 
   public static void e(Throwable t) {
     processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR,
-        TAG + Utils.INSTANCE.getStackTraceString(t));
+        TAG +  Utils.INSTANCE.getStackTraceString(t));
+  }
+
+  public static void eTrace(Throwable t) {
+    processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR,
+        TAG + Arrays.asList(t.getStackTrace()));
   }
 
   public static void e(Throwable t, Element element) {
diff --git a/compiler/src/main/java/promise/database/ompiler/utils/PersistableEntityUtils.kt b/compiler/src/main/java/promise/database/compiler/utils/PersistableEntityUtils.kt
similarity index 98%
rename from compiler/src/main/java/promise/database/ompiler/utils/PersistableEntityUtils.kt
rename to compiler/src/main/java/promise/database/compiler/utils/PersistableEntityUtils.kt
index fe16d7c..badcad5 100644
--- a/compiler/src/main/java/promise/database/ompiler/utils/PersistableEntityUtils.kt
+++ b/compiler/src/main/java/promise/database/compiler/utils/PersistableEntityUtils.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.database.ompiler.utils
+package promise.database.compiler.utils
 
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.TypeName
@@ -25,7 +25,7 @@ import promise.database.HasOne
 import promise.database.Index
 import promise.database.Text
 import promise.database.VarChar
-import promise.database.ompiler.TypeConverterAnnotatedProcessor
+import promise.database.compiler.TypeConverterAnnotatedProcessor
 import java.io.IOException
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
diff --git a/compiler/src/main/java/promise/database/ompiler/utils/Utils.kt b/compiler/src/main/java/promise/database/compiler/utils/Utils.kt
similarity index 98%
rename from compiler/src/main/java/promise/database/ompiler/utils/Utils.kt
rename to compiler/src/main/java/promise/database/compiler/utils/Utils.kt
index e480f92..79bd795 100644
--- a/compiler/src/main/java/promise/database/ompiler/utils/Utils.kt
+++ b/compiler/src/main/java/promise/database/compiler/utils/Utils.kt
@@ -11,7 +11,7 @@
  * limitations under the License.
  */
 
-package promise.database.ompiler.utils
+package promise.database.compiler.utils
 
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
@@ -68,11 +68,7 @@ fun VariableElement.getClass(): KClass<*> {
   }
 }
 
-@UseExperimental(ExperimentalContracts::class)
 fun TypeMirror.asTypeElement(processingEnv: ProcessingEnvironment): TypeElement {
-  contract {
-    returns() implies (this@asTypeElement is DeclaredType)
-  }
   val typeUtils: Types = processingEnv.typeUtils
   return (try {
     typeUtils.asElement(this)
diff --git a/compiler/src/main/java/promise/database/compiler/utils/function/BIConsumer.java b/compiler/src/main/java/promise/database/compiler/utils/function/BIConsumer.java
new file mode 100644
index 0000000..d07a4f8
--- /dev/null
+++ b/compiler/src/main/java/promise/database/compiler/utils/function/BIConsumer.java
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.database.compiler.utils.function;
+
+public interface BIConsumer<T, U> {
+  void accept(T t, U u);
+}
diff --git a/compiler/src/main/java/promise/database/compiler/utils/function/Combiner.java b/compiler/src/main/java/promise/database/compiler/utils/function/Combiner.java
new file mode 100644
index 0000000..95b4361
--- /dev/null
+++ b/compiler/src/main/java/promise/database/compiler/utils/function/Combiner.java
@@ -0,0 +1,19 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.database.compiler.utils.function;
+
+
+public interface Combiner<K, T> {
+  T join(T t, K k);
+}
diff --git a/compiler/src/main/java/promise/database/compiler/utils/function/FilterFunction.java b/compiler/src/main/java/promise/database/compiler/utils/function/FilterFunction.java
new file mode 100644
index 0000000..1658364
--- /dev/null
+++ b/compiler/src/main/java/promise/database/compiler/utils/function/FilterFunction.java
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.database.compiler.utils.function;
+
+public interface FilterFunction<T> {
+  boolean select(T t);
+}
diff --git a/compiler/src/main/java/promise/database/compiler/utils/function/FilterFunction2.java b/compiler/src/main/java/promise/database/compiler/utils/function/FilterFunction2.java
new file mode 100644
index 0000000..751c689
--- /dev/null
+++ b/compiler/src/main/java/promise/database/compiler/utils/function/FilterFunction2.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.database.compiler.utils.function;
+
+public interface FilterFunction2<K, T, U> {
+  K filterBy(U u);
+
+  K getKey(T t);
+}
diff --git a/compiler/src/main/java/promise/database/compiler/utils/function/GroupFunction.java b/compiler/src/main/java/promise/database/compiler/utils/function/GroupFunction.java
new file mode 100644
index 0000000..4ebec29
--- /dev/null
+++ b/compiler/src/main/java/promise/database/compiler/utils/function/GroupFunction.java
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.database.compiler.utils.function;
+
+public interface GroupFunction<K, T> {
+  K getKey(T t);
+}
diff --git a/compiler/src/main/java/promise/database/compiler/utils/function/GroupFunction2.java b/compiler/src/main/java/promise/database/compiler/utils/function/GroupFunction2.java
new file mode 100644
index 0000000..7019d29
--- /dev/null
+++ b/compiler/src/main/java/promise/database/compiler/utils/function/GroupFunction2.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.database.compiler.utils.function;
+
+
+import promise.database.compiler.utils.List;
+
+public interface GroupFunction2<K, E, T> {
+  K getKey(T t);
+
+  E get(K k);
+
+  void apply(E e, List<T> list);
+}
diff --git a/compiler/src/main/java/promise/database/compiler/utils/function/GroupFunction3.java b/compiler/src/main/java/promise/database/compiler/utils/function/GroupFunction3.java
new file mode 100644
index 0000000..27c4039
--- /dev/null
+++ b/compiler/src/main/java/promise/database/compiler/utils/function/GroupFunction3.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.database.compiler.utils.function;
+
+
+import promise.database.compiler.utils.List;
+import promise.database.compiler.utils.List;
+
+public interface GroupFunction3<E, T> {
+  List<E> group(List<T> list);
+}
diff --git a/compiler/src/main/java/promise/database/compiler/utils/function/JoinFunction.java b/compiler/src/main/java/promise/database/compiler/utils/function/JoinFunction.java
new file mode 100644
index 0000000..7cbd776
--- /dev/null
+++ b/compiler/src/main/java/promise/database/compiler/utils/function/JoinFunction.java
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.database.compiler.utils.function;
+
+public interface JoinFunction<T, U> {
+  boolean joinBy(T t, U u);
+}
diff --git a/compiler/src/main/java/promise/database/compiler/utils/function/MapFunction.java b/compiler/src/main/java/promise/database/compiler/utils/function/MapFunction.java
new file mode 100644
index 0000000..419b028
--- /dev/null
+++ b/compiler/src/main/java/promise/database/compiler/utils/function/MapFunction.java
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.database.compiler.utils.function;
+
+public interface MapFunction<E, T> {
+  E from(T t);
+}
diff --git a/compiler/src/main/java/promise/database/compiler/utils/function/MapIndexFunction.java b/compiler/src/main/java/promise/database/compiler/utils/function/MapIndexFunction.java
new file mode 100644
index 0000000..f972639
--- /dev/null
+++ b/compiler/src/main/java/promise/database/compiler/utils/function/MapIndexFunction.java
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.database.compiler.utils.function;
+
+public interface MapIndexFunction<E, T> {
+  E from(int index, T t);
+}
diff --git a/compiler/src/main/java/promise/database/compiler/utils/function/ReduceFunction.java b/compiler/src/main/java/promise/database/compiler/utils/function/ReduceFunction.java
new file mode 100644
index 0000000..febe2d6
--- /dev/null
+++ b/compiler/src/main/java/promise/database/compiler/utils/function/ReduceFunction.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.database.compiler.utils.function;
+
+
+import promise.database.compiler.utils.List;
+import promise.database.compiler.utils.List;
+
+public interface ReduceFunction<K, T> {
+  K reduce(List<T> list);
+}
diff --git a/database/src/main/java/promise/db/management/DatabaseMigration.kt b/database/src/main/java/promise/db/management/DatabaseMigration.kt
new file mode 100644
index 0000000..5aa1d15
--- /dev/null
+++ b/database/src/main/java/promise/db/management/DatabaseMigration.kt
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db.management
+
+import android.annotation.SuppressLint
+import promise.db.ActiveRecord
+
+@SuppressLint("ParcelCreator")
+class DatabaseMigration : ActiveRecord<DatabaseMigration>() {
+
+  private var version: Int = 1
+
+  override fun getEntity(): DatabaseMigration = this
+}
\ No newline at end of file
diff --git a/database/src/main/java/promise/db/management/TableMetaData.kt b/database/src/main/java/promise/db/management/TableMetaData.kt
new file mode 100644
index 0000000..8b53834
--- /dev/null
+++ b/database/src/main/java/promise/db/management/TableMetaData.kt
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db.management
+
+import android.annotation.SuppressLint
+import promise.db.ActiveRecord
+
+@SuppressLint("ParcelCreator")
+class TableMetaData : ActiveRecord<TableMetaData>() {
+
+  private var version: Int = 1
+
+  override fun getEntity(): TableMetaData = this
+}
\ No newline at end of file
diff --git a/schemas/promise.base.AppDatabase.yml b/schemas/promise.base.AppDatabase.yml
new file mode 100644
index 0000000..84a8ba2
--- /dev/null
+++ b/schemas/promise.base.AppDatabase.yml
@@ -0,0 +1,185 @@
+---
+dbVersion: 1
+tableMetaData:
+- tableName: "likes"
+  fields:
+  - fieldName: "uId"
+    columnName: "uId"
+    nullable: true
+    length: 0
+  - fieldName: "post"
+    columnName: "post"
+    nullable: true
+    length: 0
+  migrations: []
+- tableName: "postComments"
+  fields:
+  - fieldName: "name"
+    columnName: "name"
+    nullable: true
+    length: 0
+  - fieldName: "uId"
+    columnName: "uId"
+    nullable: true
+    length: 0
+  - fieldName: "body"
+    columnName: "body"
+    nullable: true
+    length: 0
+  - fieldName: "email"
+    columnName: "email"
+    nullable: true
+    length: 0
+  - fieldName: "postCommentId"
+    columnName: "postCommentId"
+    nullable: true
+    length: 0
+  - fieldName: "post"
+    columnName: "post"
+    nullable: true
+    length: 0
+  migrations:
+  - versionChange:
+      fromVersion: 1
+      toVersion: 2
+    field: "postCommentIdColumn"
+    action: "CREATE"
+  - versionChange:
+      fromVersion: 3
+      toVersion: 4
+    field: "postColumn"
+    action: "DROP"
+  - versionChange:
+      fromVersion: 1
+      toVersion: 2
+    field: "uIdColumn"
+    action: "CREATE"
+  - versionChange:
+      fromVersion: 3
+      toVersion: 4
+    field: "email"
+    action: "CREATE_INDEX"
+- tableName: "postComments"
+  fields:
+  - fieldName: "name"
+    columnName: "name"
+    nullable: true
+    length: 0
+  - fieldName: "uId"
+    columnName: "uId"
+    nullable: true
+    length: 0
+  - fieldName: "body"
+    columnName: "body"
+    nullable: true
+    length: 0
+  - fieldName: "email"
+    columnName: "email"
+    nullable: true
+    length: 0
+  - fieldName: "postCommentId"
+    columnName: "postCommentId"
+    nullable: true
+    length: 0
+  - fieldName: "post"
+    columnName: "post"
+    nullable: true
+    length: 0
+  migrations:
+  - versionChange:
+      fromVersion: 1
+      toVersion: 2
+    field: "postCommentIdColumn"
+    action: "CREATE"
+  - versionChange:
+      fromVersion: 3
+      toVersion: 4
+    field: "postColumn"
+    action: "DROP"
+  - versionChange:
+      fromVersion: 1
+      toVersion: 2
+    field: "uIdColumn"
+    action: "CREATE"
+  - versionChange:
+      fromVersion: 3
+      toVersion: 4
+    field: "email"
+    action: "CREATE_INDEX"
+- tableName: "posts"
+  fields:
+  - fieldName: "uId"
+    columnName: "uId"
+    nullable: true
+    length: 0
+  - fieldName: "title"
+    columnName: "title"
+    nullable: true
+    length: 0
+  - fieldName: "body"
+    columnName: "body"
+    nullable: true
+    length: 0
+  - fieldName: "userId"
+    columnName: "userId"
+    nullable: true
+    length: 0
+  - fieldName: "comments"
+    columnName: "comments"
+    nullable: true
+    length: 0
+  - fieldName: "photos"
+    columnName: "photos"
+    nullable: true
+    length: 0
+  - fieldName: "likes"
+    columnName: "likes"
+    nullable: true
+    length: 0
+  migrations: []
+- tableName: "todoes"
+  fields:
+  - fieldName: "uid"
+    columnName: "uid"
+    nullable: true
+    length: 0
+  - fieldName: "completed"
+    columnName: "completed"
+    nullable: true
+    length: 0
+  - fieldName: "title"
+    columnName: "title"
+    nullable: true
+    length: 0
+  - fieldName: "userId"
+    columnName: "userId"
+    nullable: true
+    length: 0
+  - fieldName: "photo"
+    columnName: "photo"
+    nullable: true
+    length: 0
+  migrations: []
+- tableName: "photos"
+  fields:
+  - fieldName: "albumId"
+    columnName: "albumId"
+    nullable: true
+    length: 0
+  - fieldName: "title"
+    columnName: "title"
+    nullable: true
+    length: 0
+  - fieldName: "url"
+    columnName: "url"
+    nullable: true
+    length: 0
+  - fieldName: "thumbnailUrl"
+    columnName: "thumbnailUrl"
+    nullable: true
+    length: 0
+  - fieldName: "post"
+    columnName: "post"
+    nullable: true
+    length: 0
+  migrations: []

From 64bfdc846f72a6b50a708eaf83aa1c8e46bde1e3 Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Thu, 13 Aug 2020 10:40:17 +0300
Subject: [PATCH 24/34] gen for create and drop migrations

---
 .../java/promise/base/AppTypeConverter.kt     |   9 +
 .../main/java/promise/base/comment/Like.java  |   5 +-
 .../promise/base/comment/PostComment.java     |   4 -
 app/src/main/java/promise/base/post/Post.java |  14 ++
 app/src/main/java/promise/base/todo/Todo.java |  14 +-
 .../java/promise/database/MigrationOptions.kt |   2 +-
 .../compiler/DatabaseAnnotationGenerator.kt   |   4 +-
 .../compiler/DatabaseMetaDataWriter.kt        |   4 +-
 .../compiler/PromiseDatabaseCompiler.kt       |   6 +-
 .../database/compiler/TableMetaDataWriter.kt  | 157 +++++++++++++-----
 .../compiler/TableMigrationFieldGenerator.kt  |  81 +++++----
 .../compiler/migration/TableMetaData.kt       |   1 -
 .../compiler/migration/TableMigration.kt      |  27 ++-
 .../compiler/utils/PersistableEntityUtils.kt  |  19 +++
 .../src/main/java/promise/db/FastTable.kt     |  17 +-
 schemas/promise.base.AppDatabase.yml          |  94 ++---------
 16 files changed, 274 insertions(+), 184 deletions(-)

diff --git a/app/src/main/java/promise/base/AppTypeConverter.kt b/app/src/main/java/promise/base/AppTypeConverter.kt
index 46888f4..6010fbc 100644
--- a/app/src/main/java/promise/base/AppTypeConverter.kt
+++ b/app/src/main/java/promise/base/AppTypeConverter.kt
@@ -14,10 +14,19 @@
 package promise.base
 
 import promise.database.TypeConverter
+import java.util.*
 
 @TypeConverter
 class AppTypeConverter {
 
+  fun dateToString(date: Date): String {
+    return date.toString()
+  }
+
+  fun stringToDate(data: String): Date {
+    return Date()
+  }
+
   fun toUniqueId(data: String): ID = ID(data)
 
   fun toString(data: ID?): String = data?.id ?: ""
diff --git a/app/src/main/java/promise/base/comment/Like.java b/app/src/main/java/promise/base/comment/Like.java
index d42615b..5c87946 100644
--- a/app/src/main/java/promise/base/comment/Like.java
+++ b/app/src/main/java/promise/base/comment/Like.java
@@ -14,9 +14,7 @@
 package promise.base.comment;
 
 import android.annotation.SuppressLint;
-
 import org.jetbrains.annotations.NotNull;
-
 import promise.base.ID;
 import promise.base.post.Post;
 import promise.database.AddedEntity;
@@ -26,14 +24,13 @@
 
 @SuppressLint("ParcelCreator")
 @Entity
-@AddedEntity(fromVersion = 1, toVersion = 2)
+//@AddedEntity(fromVersion = 1, toVersion = 2)
 public class Like extends ActiveRecord<Like> {
 	private ID uId;
 
 	@HasOne
 	private Post post;
 
-
 	@Override
  	public String toString(){
 		return 
diff --git a/app/src/main/java/promise/base/comment/PostComment.java b/app/src/main/java/promise/base/comment/PostComment.java
index c18c1db..b3bb08c 100644
--- a/app/src/main/java/promise/base/comment/PostComment.java
+++ b/app/src/main/java/promise/base/comment/PostComment.java
@@ -16,17 +16,13 @@
 @Entity
 public class PostComment extends ActiveRecord<PostComment> {
 	private String name;
-	@Migrate(fromVersion = 1, toVersion = 2, action = MigrationOptions.CREATE)
 	private ID uId;
 	private String body;
-  @Migrate(fromVersion = 3, toVersion = 4, action = MigrationOptions.CREATE_INDEX)
 	private String email;
 
-	@Migrate(fromVersion = 1, toVersion = 2, action = MigrationOptions.CREATE)
 	private String postCommentId = "";
 
 	@HasOne
-  @Migrate(fromVersion = 3, toVersion = 4, action = MigrationOptions.DROP)
 	private Post post;
 
 	public void setName(String name){
diff --git a/app/src/main/java/promise/base/post/Post.java b/app/src/main/java/promise/base/post/Post.java
index eb7a557..974621a 100644
--- a/app/src/main/java/promise/base/post/Post.java
+++ b/app/src/main/java/promise/base/post/Post.java
@@ -2,8 +2,11 @@
 
 import android.annotation.SuppressLint;
 
+import androidx.annotation.NonNull;
+
 import org.jetbrains.annotations.NotNull;
 
+import java.util.Date;
 import java.util.List;
 
 import promise.base.ID;
@@ -22,6 +25,9 @@ public class Post extends ActiveRecord<Post> {
 	private String body;
 	private int userId;
 
+	private Date publishedDate;
+
+	@NonNull
 	@Override
 	public String toString() {
 		return "Post{" +
@@ -112,4 +118,12 @@ public void setLikes(List<Like> likes) {
 	public Post getEntity() {
 		return this;
 	}
+
+	public Date getPublishedDate() {
+		return publishedDate;
+	}
+
+	public void setPublishedDate(Date publishedDate) {
+		this.publishedDate = publishedDate;
+	}
 }
diff --git a/app/src/main/java/promise/base/todo/Todo.java b/app/src/main/java/promise/base/todo/Todo.java
index b5d4e30..f41dddc 100644
--- a/app/src/main/java/promise/base/todo/Todo.java
+++ b/app/src/main/java/promise/base/todo/Todo.java
@@ -15,7 +15,8 @@ public class Todo extends ActiveRecord<Todo> {
 	private int uid;
 	private boolean completed;
 	private String title;
-	private int userId;
+
+	private String description;
 
 	@HasOne
 	private Photo photo;
@@ -52,12 +53,12 @@ public String getTitle(){
 		return title;
 	}
 
-	public void setUserId(int userId){
-		this.userId = userId;
+	public String getDescription() {
+		return description;
 	}
 
-	public int getUserId(){
-		return userId;
+	public void setDescription(String description) {
+		this.description = description;
 	}
 
 	@Override
@@ -66,8 +67,7 @@ public String toString(){
 			"Todo{" + 
 			"id = '" + uid + '\'' +
 			",completed = '" + completed + '\'' + 
-			",title = '" + title + '\'' + 
-			",userId = '" + userId + '\'' + 
+			",title = '" + title + '\'' +
 			"}";
 		}
 
diff --git a/commons/src/main/java/promise/database/MigrationOptions.kt b/commons/src/main/java/promise/database/MigrationOptions.kt
index 77d3bea..14fb1e2 100644
--- a/commons/src/main/java/promise/database/MigrationOptions.kt
+++ b/commons/src/main/java/promise/database/MigrationOptions.kt
@@ -14,5 +14,5 @@
 package promise.database
 
 enum class MigrationOptions {
-  CREATE, DROP, CREATE_INDEX
+  CREATE, DROP, CREATE_INDEX, RENAME_COLUMN
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/database/compiler/DatabaseAnnotationGenerator.kt b/compiler/src/main/java/promise/database/compiler/DatabaseAnnotationGenerator.kt
index 3119301..b5a1b0c 100644
--- a/compiler/src/main/java/promise/database/compiler/DatabaseAnnotationGenerator.kt
+++ b/compiler/src/main/java/promise/database/compiler/DatabaseAnnotationGenerator.kt
@@ -23,6 +23,7 @@ import promise.database.compiler.utils.getTableEntities
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.TypeElement
+import kotlin.math.max
 
 class DatabaseAnnotationGenerator(
     private val processingEnv: ProcessingEnvironment,
@@ -36,7 +37,8 @@ class DatabaseAnnotationGenerator(
         entities = element.getTableEntities(processingEnv)
       } catch (e: Throwable) { LogUtil.e(e)
       }
-      val version = element.getDatabaseVersion()
+      val generatedVersion = TableMetaDataWriter.finalMaxDbVersion()
+      val version = max(element.getDatabaseVersion(), generatedVersion)
       try {
         entities?.forEachIndexed { index, entityClass ->
           val className = entityClass.getTableClassNameString()
diff --git a/compiler/src/main/java/promise/database/compiler/DatabaseMetaDataWriter.kt b/compiler/src/main/java/promise/database/compiler/DatabaseMetaDataWriter.kt
index 5700e4a..fc41cab 100644
--- a/compiler/src/main/java/promise/database/compiler/DatabaseMetaDataWriter.kt
+++ b/compiler/src/main/java/promise/database/compiler/DatabaseMetaDataWriter.kt
@@ -25,6 +25,7 @@ import java.io.FileReader
 import java.io.FileWriter
 import java.io.IOException
 import javax.lang.model.element.TypeElement
+import kotlin.math.max
 
 class DatabaseMetaDataWriter(
     private val databaseElement: TypeElement,
@@ -57,8 +58,9 @@ class DatabaseMetaDataWriter(
     val databaseMetaData = DatabaseMetaData()
     if (TableMetaDataWriter.tableMetaData.isNotEmpty()) {
       databaseMetaData.tableMetaData = TableMetaDataWriter.tableMetaData
+      val generatedVersion = TableMetaDataWriter.finalMaxDbVersion()
+      databaseMetaData.dbVersion = max(databaseElement.getDatabaseVersion(), generatedVersion)
     }
-    databaseMetaData.dbVersion = databaseElement.getDatabaseVersion()
     serializeToXML(databaseMetaData)
   }
 
diff --git a/compiler/src/main/java/promise/database/compiler/PromiseDatabaseCompiler.kt b/compiler/src/main/java/promise/database/compiler/PromiseDatabaseCompiler.kt
index 66bcfe2..d0af55b 100644
--- a/compiler/src/main/java/promise/database/compiler/PromiseDatabaseCompiler.kt
+++ b/compiler/src/main/java/promise/database/compiler/PromiseDatabaseCompiler.kt
@@ -48,12 +48,12 @@ class PromiseDatabaseCompiler : AbstractProcessor() {
     try {
       val database = DatabaseEntityAnnotatedProcessor.getDatabaseElement(environment, processingEnv)
       if (database != null) {
-        val pkg = processingEnv.elementUtils.getPackageOf(database).toString()
-        val projectFolder = File(File(File("${pkg}${File.separator}${database.simpleName}.java").parent).parent).parent
+//        val pkg = processingEnv.elementUtils.getPackageOf(database).toString()
+//        val projectFolder = File(File(File("${pkg}${File.separator}${database.simpleName}.java").parent).parent).parent
 //        val resource = processingEnv.filer.createResource(StandardJavaFileManager.getLocation(StandardLocation),
 //            "schemas", database.asType().toString() + ".yml")
 //        val schemaPath = resource.toUri().path
-        databaseMetaDataWriter = DatabaseMetaDataWriter(database, "${projectFolder}${File.separator}schemas${File.separator}${database.asType()}.yml")
+        databaseMetaDataWriter = DatabaseMetaDataWriter(database, "schemas${File.separator}${database.asType()}.yml")
       } else LogUtil.e(Exception("No database class found in module"))
       val javaFiles: ArrayList<JavaFile.Builder> = ArrayList()
       val processors: ArrayList<AnnotatedClassProcessor> = ArrayList()
diff --git a/compiler/src/main/java/promise/database/compiler/TableMetaDataWriter.kt b/compiler/src/main/java/promise/database/compiler/TableMetaDataWriter.kt
index 26adf0b..a08aac3 100644
--- a/compiler/src/main/java/promise/database/compiler/TableMetaDataWriter.kt
+++ b/compiler/src/main/java/promise/database/compiler/TableMetaDataWriter.kt
@@ -13,16 +13,17 @@
 
 package promise.database.compiler
 
+import promise.database.HasMany
 import promise.database.Ignore
-import promise.database.Migrate
 import promise.database.MigrationOptions
-import promise.database.Migrations
 import promise.database.compiler.migration.Field
 import promise.database.compiler.migration.TableMetaData
 import promise.database.compiler.migration.TableMigration
 import promise.database.compiler.migration.VersionChange
+import promise.database.compiler.utils.function.FilterFunction2
 import promise.database.compiler.utils.getNameOfColumn
 import promise.database.compiler.utils.getTableName
+import promise.database.compiler.utils.isColumnNullable
 import javax.lang.model.element.Element
 import javax.lang.model.util.ElementFilter
 
@@ -32,6 +33,20 @@ class TableMetaDataWriter(
 
   companion object {
     val tableMetaData: ArrayList<TableMetaData> = ArrayList()
+
+    fun finalMaxDbVersion(): Int {
+      if (tableMetaData.isNotEmpty()) {
+        val versionChanges: ArrayList<VersionChange?> = ArrayList()
+        tableMetaData.map {
+          metaData -> metaData.migrations.map { it.versionChange } }
+            .forEach {
+              versionChanges.addAll(it)
+            }
+        return versionChanges.mapNotNull { it!!.toVersion }.max() ?: 1
+      }
+      return 1
+    }
+
     init {
       if (PromiseDatabaseCompiler.databaseMetaDataWriter.currentDatabaseMetaData == null)
         PromiseDatabaseCompiler.databaseMetaDataWriter.loadCurrentMetaData()
@@ -41,63 +56,75 @@ class TableMetaDataWriter(
   fun process(
       //elements: Map<Element, String>
   ): promise.database.compiler.utils.List<TableMigration> {
-    val migrateFields = elements.filter {
-      it.key.getAnnotation(Migrate::class.java) != null ||
-          it.key.getAnnotation(Migrations::class.java) != null
-    }
 
-    val tableMigrations = promise.database.compiler.utils.List<TableMigration>()
-    if (migrateFields.isEmpty()) {
+//
+//
+//    val migrateFields = elements.filter {
+//      it.key.getAnnotation(Migrate::class.java) != null ||
+//          it.key.getAnnotation(Migrations::class.java) != null
+//    }
 
-    }
-    else {
-      migrateFields.forEach { entry ->
-        if (entry.key.getAnnotation(Migrate::class.java) != null) {
-          val migration = entry.key.getAnnotation(Migrate::class.java)
-          tableMigrations.add(TableMigration().apply {
-            versionChange = VersionChange().apply {
-              fromVersion = migration.fromVersion
-              toVersion = migration.toVersion
-            }
-            field = if (migration.action == MigrationOptions.CREATE_INDEX) entry.key.getNameOfColumn() else entry.value
-            action = migration.action
-          })
-        } else if (entry.key.getAnnotation(Migrations::class.java) != null) {
-          val migrations = entry.key.getAnnotation(Migrations::class.java)
-          migrations.values.forEach {
-            val migration = it
-            tableMigrations.add(TableMigration().apply {
-              versionChange = VersionChange().apply {
-                fromVersion = migration.fromVersion
-                toVersion = migration.toVersion
-              }
-              field = if (migration.action == MigrationOptions.CREATE_INDEX) entry.key.getNameOfColumn() else entry.value
-              action = migration.action
-            })
-          }
-        }
-      }
-    }
+//    if (migrateFields.isEmpty()) {
+//
+//    }
+//    else {
+//      migrateFields.forEach { entry ->
+//        if (entry.key.getAnnotation(Migrate::class.java) != null) {
+//          val migration = entry.key.getAnnotation(Migrate::class.java)
+//          tableMigrations.add(TableMigration().apply {
+//            versionChange = VersionChange().apply {
+//              fromVersion = migration.fromVersion
+//              toVersion = migration.toVersion
+//            }
+//            field = if (migration.action == MigrationOptions.CREATE_INDEX) entry.key.getNameOfColumn() else entry.value
+//            action = migration.action
+//          })
+//        } else if (entry.key.getAnnotation(Migrations::class.java) != null) {
+//          val migrations = entry.key.getAnnotation(Migrations::class.java)
+//          migrations.values.forEach {
+//            val migration = it
+//            tableMigrations.add(TableMigration().apply {
+//              versionChange = VersionChange().apply {
+//                fromVersion = migration.fromVersion
+//                toVersion = migration.toVersion
+//              }
+//              field = if (migration.action == MigrationOptions.CREATE_INDEX) entry.key.getNameOfColumn() else entry.value
+//              action = migration.action
+//            })
+//          }
+//        }
+//      }
+//    }
     val metaData = TableMetaData()
-    val oldMetaData = promise.database.compiler.utils.List<TableMetaData>(PromiseDatabaseCompiler.databaseMetaDataWriter.currentDatabaseMetaData!!.tableMetaData)
+    val oldMetaData = promise.database.compiler.utils.List<TableMetaData>(
+        PromiseDatabaseCompiler.databaseMetaDataWriter.currentDatabaseMetaData!!.tableMetaData)
         .find {
           it.tableName == entityElement.getTableName()
         }
+    val tableMigrations = promise.database.compiler.utils.List<TableMigration>()
     if (oldMetaData != null) {
-      val diffMigrations= promise.database.compiler.utils.List(oldMetaData.migrations).joinOn(
+      tableMigrations.addAll(generateRequiredTableMigrations(
+          PromiseDatabaseCompiler.databaseMetaDataWriter.currentDatabaseMetaData!!.dbVersion,
+          promise.database.compiler.utils.List(oldMetaData.fields),
+          elements))
+      val diffMigrations = promise.database.compiler.utils.List(oldMetaData.migrations).joinOn(
           promise.database.compiler.utils.List(tableMigrations)) { t, u -> t != u }
       tableMigrations.addAll(diffMigrations)
       metaData.migrations = tableMigrations
-    }
-    else metaData.migrations = tableMigrations
+    } else metaData.migrations = tableMigrations
     val fields: ArrayList<Field> = ArrayList()
+    /**
+     * ignore fields with Has many relation and ones with Ignore annotation
+     */
     ElementFilter.fieldsIn(entityElement.enclosedElements).filter {
-      it.getAnnotation(Ignore::class.java) == null
+      it.getAnnotation(Ignore::class.java) == null &&
+          it.getAnnotation(HasMany::class.java) == null
     }
         .forEach {
           fields.add(Field().apply {
             fieldName = it.simpleName.toString()
             columnName = it.getNameOfColumn()
+            nullable = it.isColumnNullable()
           })
         }
 
@@ -107,4 +134,50 @@ class TableMetaDataWriter(
     return tableMigrations
   }
 
+  private fun generateRequiredTableMigrations(
+      oldDatabaseVersion: Int,
+      oldFields: promise.database.compiler.utils.List<Field>,
+      newFields: Map<Element, String>
+  ): List<TableMigration> {
+    if (oldFields.isEmpty() && newFields.isEmpty()) return emptyList()
+    val newFields2 = promise.database.compiler.utils.List(newFields.toList())
+    val migrations: ArrayList<TableMigration> = ArrayList()
+    if (oldFields.size > newFields.size) oldFields.reduce(newFields2,
+        object : FilterFunction2<String, Pair<Element, String>, Field> {
+          override fun filterBy(u: Field): String = u.fieldName
+          override fun getKey(t: Pair<Element, String>): String = t.first.simpleName.toString()
+        }, false)
+        .forEach {
+          migrations.add(TableMigration().apply {
+            versionChange = VersionChange().apply {
+              fromVersion = oldDatabaseVersion
+              toVersion = oldDatabaseVersion + 1
+            }
+            field = "\"${it.columnName}\""
+            action = MigrationOptions.DROP
+          })
+        }
+    if (newFields.size > oldFields.size) newFields2.reduce(oldFields,
+        object : FilterFunction2<String, Field, Pair<Element, String>> {
+          override fun filterBy(u: Pair<Element, String>): String = u.first.simpleName.toString()
+          override fun getKey(t: Field): String = t.fieldName
+        }, false)
+        .forEach {
+          migrations.add(TableMigration().apply {
+            versionChange = VersionChange().apply {
+              fromVersion = oldDatabaseVersion
+              toVersion = oldDatabaseVersion + 1
+            }
+            field = it.second
+            action = MigrationOptions.CREATE
+          })
+        }
+    if (newFields2.size == oldFields.size) {
+      val sameFieldsMaintained = newFields2.joinOn(oldFields
+      ) { t, u -> t.first.simpleName.toString() == u.fieldName }
+
+    }
+    return migrations
+  }
+
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/database/compiler/TableMigrationFieldGenerator.kt b/compiler/src/main/java/promise/database/compiler/TableMigrationFieldGenerator.kt
index 2139558..101d85d 100644
--- a/compiler/src/main/java/promise/database/compiler/TableMigrationFieldGenerator.kt
+++ b/compiler/src/main/java/promise/database/compiler/TableMigrationFieldGenerator.kt
@@ -18,13 +18,12 @@ import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
 import com.squareup.javapoet.MethodSpec
 import org.jetbrains.annotations.NotNull
-import promise.database.Migrate
+import promise.database.HasMany
+import promise.database.Ignore
 import promise.database.MigrationOptions
-import promise.database.Migrations
 import promise.database.compiler.migration.TableMigration
 import promise.database.compiler.migration.VersionChange
 import promise.database.compiler.utils.List
-import promise.database.compiler.utils.getNameOfColumn
 import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
 
@@ -39,7 +38,7 @@ class TableMigrationFieldGenerator(
     codeBlock.add("if (v1 == ${versionChange.fromVersion} && v2 == ${versionChange.toVersion}) {\n")
     codeBlock.indent()
     tableMigrations.groupBy { it.action }
-        .forEach {category ->
+        .forEach { category ->
           when (category.name()) {
             MigrationOptions.CREATE -> {
               val list: StringBuilder = StringBuilder("")
@@ -60,6 +59,7 @@ class TableMigrationFieldGenerator(
             MigrationOptions.CREATE_INDEX -> category.list().forEach {
               codeBlock.addStatement("addIndex(x, \"${it.field}\")")
             }
+
           }
         }
     codeBlock.unindent()
@@ -67,39 +67,50 @@ class TableMigrationFieldGenerator(
   }
 
   override fun generate(): MethodSpec? {
-
-    val tableMetaDataWriter = TableMetaDataWriter(entityElement, elements)
-    tableMetaDataWriter.process()
-
-    val migrateFields = elements.filter {
-      it.key.getAnnotation(Migrate::class.java) != null ||
-          it.key.getAnnotation(Migrations::class.java) != null
+    /**
+     * ignore fields with Has many relation and ones with Ignore annotation
+     */
+    val elements2 = elements.filter {
+      it.key.getAnnotation(HasMany::class.java) == null &&
+          it.key.getAnnotation(Ignore::class.java) == null
     }
+    val tableMetaDataWriter = TableMetaDataWriter(entityElement, elements2)
 
-    if (migrateFields.isEmpty()) return null
-    val codeBlock = CodeBlock.builder()
-    val tableMigrations = tableMetaDataWriter.process()
-    tableMigrations.groupBy { it.versionChange }
-        .forEach {
-          buildMigration(it.name()!!, it.list(), codeBlock)
-        }
 
-    return MethodSpec.methodBuilder("onUpgrade")
-        .addParameter(
-            ClassName.get("androidx.sqlite.db", "SupportSQLiteDatabase")
-                .annotated(AnnotationSpec.builder(NotNull::class.java).build()),
-            "x")
-        .addParameter(Integer::class.javaPrimitiveType, "v1")
-        .addParameter(Integer::class.javaPrimitiveType, "v2")
-        .addAnnotation(Override::class.java)
-        .addJavadoc("""
-          Migration callback, adds, deletes columns in this table
-          May also create indices
-        """.trimIndent())
-        .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
-        .addException(ClassName.get("promise.db", "TableError"))
-        .addCode(codeBlock.build())
-        .build()
+    val tableMigrations = tableMetaDataWriter.process()
+//
+//    tableMigrations.addAll(elements2.filter { it.key.getAnnotation(RenameColumn::class.java) != null }
+//        .map {
+//          val renameColumn = it.key.getAnnotation(RenameColumn::class.java)
+//          RenameColumnTableMigration().apply {
+//            versionChange = VersionChange().apply {
+//              fromVersion = renameColumn.fromVersion
+//              toVersion = renameColumn.toVersion
+//            }
+//            field = it.key.getNameOfColumn()
+//            oldColumnName = renameColumn.oldName
+//          }
+//        })
+//
+    if (tableMigrations.isNotEmpty()) {
+      val codeBlock = CodeBlock.builder()
+      tableMigrations.groupBy { it.versionChange }
+          .forEach {
+            buildMigration(it.name()!!, it.list(), codeBlock)
+          }
+      return MethodSpec.methodBuilder("onUpgrade")
+          .addParameter(
+              ClassName.get("androidx.sqlite.db", "SupportSQLiteDatabase")
+                  .annotated(AnnotationSpec.builder(NotNull::class.java).build()),
+              "x")
+          .addParameter(Integer::class.javaPrimitiveType, "v1")
+          .addParameter(Integer::class.javaPrimitiveType, "v2")
+          .addAnnotation(Override::class.java)
+          .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
+          .addException(ClassName.get("promise.db", "TableError"))
+          .addCode(codeBlock.build())
+          .build()
+    }
+    return null
   }
-
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/database/compiler/migration/TableMetaData.kt b/compiler/src/main/java/promise/database/compiler/migration/TableMetaData.kt
index 2421359..da9f78d 100644
--- a/compiler/src/main/java/promise/database/compiler/migration/TableMetaData.kt
+++ b/compiler/src/main/java/promise/database/compiler/migration/TableMetaData.kt
@@ -19,7 +19,6 @@ class Field {
   var fieldName = ""
   var columnName = ""
   var nullable = true
-  var length  = 0
 }
 
 class TableMetaData {
diff --git a/compiler/src/main/java/promise/database/compiler/migration/TableMigration.kt b/compiler/src/main/java/promise/database/compiler/migration/TableMigration.kt
index 5db1544..f1e326d 100644
--- a/compiler/src/main/java/promise/database/compiler/migration/TableMigration.kt
+++ b/compiler/src/main/java/promise/database/compiler/migration/TableMigration.kt
@@ -15,7 +15,7 @@ package promise.database.compiler.migration
 
 import promise.database.MigrationOptions
 
-class TableMigration {
+open class TableMigration {
    var versionChange: VersionChange? = null
    var field: String? = null
    var action: MigrationOptions? = null
@@ -36,4 +36,29 @@ class TableMigration {
       result = 31 * result + (action?.hashCode() ?: 0)
       return result
    }
+}
+
+class RenameColumnTableMigration: TableMigration() {
+
+   var oldColumnName: String? = null
+
+   init {
+     super.action = MigrationOptions.RENAME_COLUMN
+   }
+
+   override fun equals(other: Any?): Boolean {
+      if (this === other) return true
+      if (javaClass != other?.javaClass) return false
+      if (!super.equals(other)) return false
+      other as RenameColumnTableMigration
+      if (oldColumnName != other.oldColumnName) return false
+      return true
+   }
+
+   override fun hashCode(): Int {
+      var result = 0
+      result = 31 * result + (oldColumnName?.hashCode() ?: 0)
+      return result
+   }
+
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/database/compiler/utils/PersistableEntityUtils.kt b/compiler/src/main/java/promise/database/compiler/utils/PersistableEntityUtils.kt
index badcad5..877bdb9 100644
--- a/compiler/src/main/java/promise/database/compiler/utils/PersistableEntityUtils.kt
+++ b/compiler/src/main/java/promise/database/compiler/utils/PersistableEntityUtils.kt
@@ -152,6 +152,25 @@ fun Element.getNameOfColumn(): String {
   return this.simpleName.toString()
 }
 
+fun Element.isColumnNullable(): Boolean {
+  var nullable: Boolean = true
+  if ((this.toTypeName().isSameAs(Integer::class.java) ||
+          this.toTypeName().isSameAs(Float::class.java) ||
+          this.toTypeName().isSameAs(Double::class.java) ||
+          this.toTypeName().isSameAs(Boolean::class.java)) &&
+      this.getAnnotation(promise.database.Number::class.java) != null) {
+    nullable = this.getAnnotation(promise.database.Number::class.java).nullable
+  } else if (this.toTypeName().isSameAs(String::class.java) &&
+      this.getAnnotation(VarChar::class.java) != null) {
+    nullable = this.getAnnotation(VarChar::class.java).nullable
+  } else if (this.getAnnotation(Text::class.java) != null) {
+    nullable = this.getAnnotation(Text::class.java).nullable
+  } else if (this.getAnnotation(VarChar::class.java) != null) {
+    nullable = this.getAnnotation(VarChar::class.java).nullable
+  }
+  return nullable
+}
+
 /**
  * capitalize the first char of string
  */
diff --git a/database/src/main/java/promise/db/FastTable.kt b/database/src/main/java/promise/db/FastTable.kt
index 0e05687..7e71cda 100644
--- a/database/src/main/java/promise/db/FastTable.kt
+++ b/database/src/main/java/promise/db/FastTable.kt
@@ -333,9 +333,22 @@ abstract class FastTable<T : Identifiable<Int>>
    * @throws TableError if theirs an sql error
    */
   @Throws(TableError::class)
-  fun dropColumns(database: SupportSQLiteDatabase, vararg columns: Column<*>): Boolean {
+  fun dropColumns(database: SupportSQLiteDatabase, vararg columns: String): Boolean {
     for (column in columns) {
-      val alterSql = ALTER_COMMAND + " `" + name + "` " + "DROP COLUMN " + column.name + ";"
+      val alterSql = "$ALTER_COMMAND `$name` DROP COLUMN $column;"
+      try {
+        database.execSQL(alterSql)
+      } catch (e: SQLException) {
+        throw TableError(e)
+      }
+    }
+    return true
+  }
+
+  @Throws(TableError::class)
+  fun renameColumns(database: SupportSQLiteDatabase, vararg columns: Pair<String, String>): Boolean {
+    for (column in columns) {
+      val alterSql = "$ALTER_COMMAND `$name` SET COLUMN ${column.first} ${column.second};"
       try {
         database.execSQL(alterSql)
       } catch (e: SQLException) {
diff --git a/schemas/promise.base.AppDatabase.yml b/schemas/promise.base.AppDatabase.yml
index 84a8ba2..7064386 100644
--- a/schemas/promise.base.AppDatabase.yml
+++ b/schemas/promise.base.AppDatabase.yml
@@ -1,5 +1,5 @@
 ---
-dbVersion: 1
+dbVersion: 3
 tableMetaData:
 - tableName: "likes"
   fields:
@@ -38,74 +38,7 @@ tableMetaData:
     columnName: "post"
     nullable: true
     length: 0
-  migrations:
-  - versionChange:
-      fromVersion: 1
-      toVersion: 2
-    field: "postCommentIdColumn"
-    action: "CREATE"
-  - versionChange:
-      fromVersion: 3
-      toVersion: 4
-    field: "postColumn"
-    action: "DROP"
-  - versionChange:
-      fromVersion: 1
-      toVersion: 2
-    field: "uIdColumn"
-    action: "CREATE"
-  - versionChange:
-      fromVersion: 3
-      toVersion: 4
-    field: "email"
-    action: "CREATE_INDEX"
-- tableName: "postComments"
-  fields:
-  - fieldName: "name"
-    columnName: "name"
-    nullable: true
-    length: 0
-  - fieldName: "uId"
-    columnName: "uId"
-    nullable: true
-    length: 0
-  - fieldName: "body"
-    columnName: "body"
-    nullable: true
-    length: 0
-  - fieldName: "email"
-    columnName: "email"
-    nullable: true
-    length: 0
-  - fieldName: "postCommentId"
-    columnName: "postCommentId"
-    nullable: true
-    length: 0
-  - fieldName: "post"
-    columnName: "post"
-    nullable: true
-    length: 0
-  migrations:
-  - versionChange:
-      fromVersion: 1
-      toVersion: 2
-    field: "postCommentIdColumn"
-    action: "CREATE"
-  - versionChange:
-      fromVersion: 3
-      toVersion: 4
-    field: "postColumn"
-    action: "DROP"
-  - versionChange:
-      fromVersion: 1
-      toVersion: 2
-    field: "uIdColumn"
-    action: "CREATE"
-  - versionChange:
-      fromVersion: 3
-      toVersion: 4
-    field: "email"
-    action: "CREATE_INDEX"
+  migrations: []
 - tableName: "posts"
   fields:
   - fieldName: "uId"
@@ -124,19 +57,16 @@ tableMetaData:
     columnName: "userId"
     nullable: true
     length: 0
-  - fieldName: "comments"
-    columnName: "comments"
-    nullable: true
-    length: 0
-  - fieldName: "photos"
-    columnName: "photos"
-    nullable: true
-    length: 0
-  - fieldName: "likes"
-    columnName: "likes"
+  - fieldName: "publishedDate"
+    columnName: "publishedDate"
     nullable: true
     length: 0
-  migrations: []
+  migrations:
+  - versionChange:
+      fromVersion: 2
+      toVersion: 3
+    field: "publishedDateColumn"
+    action: "CREATE"
 - tableName: "todoes"
   fields:
   - fieldName: "uid"
@@ -151,8 +81,8 @@ tableMetaData:
     columnName: "title"
     nullable: true
     length: 0
-  - fieldName: "userId"
-    columnName: "userId"
+  - fieldName: "description"
+    columnName: "description"
     nullable: true
     length: 0
   - fieldName: "photo"

From 2f51e0f4ecd4c8fae6958c0c85e5562dc7863dc1 Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Mon, 17 Aug 2020 16:42:52 +0300
Subject: [PATCH 25/34] refactored fastTable methods

---
 app/build.gradle                              |   7 +
 app/schemas/promise.base.AppDatabase/1.yml    |  87 +++
 app/src/main/java/promise/base/AppDatabase.kt |   2 +-
 .../java/promise/base/AppTypeConverter.kt     |   9 +-
 .../java/promise/base/post/PostRepository.kt  |  78 +--
 .../promise/dbapp/DatabaseDependencies.kt     |  28 +-
 .../main/java/promise/dbapp/MainActivity.kt   |  43 +-
 .../main/java/promise/dbapp/ReposModule.kt    |   8 +-
 .../dbapp/test/PostCommentsDaoImpl.java       |  93 ++-
 compiler/build.gradle                         |   2 +
 .../compiler/DAOAnnotatedProcessor.kt         | 219 +++++---
 .../DatabaseAbstractMethodsGenerator.kt       |  27 +-
 .../DatabaseEntityAnnotatedProcessor.kt       |  44 +-
 .../compiler/DatabaseMetaDataWriter.kt        |  40 +-
 .../compiler/PromiseDatabaseCompiler.kt       |  47 +-
 .../compiler/RelationsDaoGenerator.java       |   1 -
 .../compiler/TableColumnFieldsGenerator.kt    |   4 +-
 .../TableDeserializerMethodGenerator.kt       |   3 +-
 .../database/compiler/utils/JavaUtils.java    |  29 +-
 .../database/compiler/utils/LogUtil.java      |   1 +
 .../promise/database/compiler/utils/Utils.kt  |  16 +-
 .../src/main/java/promise/db/DDLFunctions.kt  |   8 +
 .../src/main/java/promise/db/DMLFunctions.kt  |   6 -
 .../src/main/java/promise/db/DMLVisitors.kt   | 129 +++++
 .../main/java/promise/db/FastDatabaseImpl.kt  |  29 +-
 .../src/main/java/promise/db/FastTable.kt     | 530 +-----------------
 .../src/main/java/promise/db/FetchVisitor.kt  | 389 +++++++++++++
 .../main/java/promise/db/PromiseDatabase.java |  12 +-
 .../java/promise/db/ReactiveFastDatabase.kt   |  56 +-
 .../src/main/java/promise/db/TableCrud.kt     | 124 +---
 .../src/main/java/promise/utils/Acceptor.kt   |  18 +
 .../src/main/java/promise/utils/Visitor.kt    |  18 +
 schemas/promise.base.AppDatabase.yml          |  32 +-
 33 files changed, 1097 insertions(+), 1042 deletions(-)
 create mode 100644 app/schemas/promise.base.AppDatabase/1.yml
 create mode 100644 database/src/main/java/promise/db/DMLVisitors.kt
 create mode 100644 database/src/main/java/promise/db/FetchVisitor.kt
 create mode 100644 database/src/main/java/promise/utils/Acceptor.kt
 create mode 100644 database/src/main/java/promise/utils/Visitor.kt

diff --git a/app/build.gradle b/app/build.gradle
index 4eb0d15..c36e547 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -33,6 +33,13 @@ android {
 
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
 
+        javaCompileOptions {
+            annotationProcessorOptions {
+                arguments = [
+                        "promise.database.projectDir"  : "$projectDir".toString()
+                ]
+            }
+        }
     }
 
     compileOptions {
diff --git a/app/schemas/promise.base.AppDatabase/1.yml b/app/schemas/promise.base.AppDatabase/1.yml
new file mode 100644
index 0000000..2a892fe
--- /dev/null
+++ b/app/schemas/promise.base.AppDatabase/1.yml
@@ -0,0 +1,87 @@
+---
+dbVersion: 1
+tableMetaData:
+- tableName: "likes"
+  fields:
+  - fieldName: "uId"
+    columnName: "uId"
+    nullable: true
+  - fieldName: "post"
+    columnName: "post"
+    nullable: true
+  migrations: []
+- tableName: "postComments"
+  fields:
+  - fieldName: "name"
+    columnName: "name"
+    nullable: true
+  - fieldName: "uId"
+    columnName: "uId"
+    nullable: true
+  - fieldName: "body"
+    columnName: "body"
+    nullable: true
+  - fieldName: "email"
+    columnName: "email"
+    nullable: true
+  - fieldName: "postCommentId"
+    columnName: "postCommentId"
+    nullable: true
+  - fieldName: "post"
+    columnName: "post"
+    nullable: true
+  migrations: []
+- tableName: "posts"
+  fields:
+  - fieldName: "uId"
+    columnName: "uId"
+    nullable: true
+  - fieldName: "title"
+    columnName: "title"
+    nullable: true
+  - fieldName: "body"
+    columnName: "body"
+    nullable: true
+  - fieldName: "userId"
+    columnName: "userId"
+    nullable: true
+  - fieldName: "publishedDate"
+    columnName: "publishedDate"
+    nullable: true
+  migrations: []
+- tableName: "todoes"
+  fields:
+  - fieldName: "uid"
+    columnName: "uid"
+    nullable: true
+  - fieldName: "completed"
+    columnName: "completed"
+    nullable: true
+  - fieldName: "title"
+    columnName: "title"
+    nullable: true
+  - fieldName: "description"
+    columnName: "description"
+    nullable: true
+  - fieldName: "photo"
+    columnName: "photo"
+    nullable: true
+  migrations: []
+- tableName: "photos"
+  fields:
+  - fieldName: "albumId"
+    columnName: "albumId"
+    nullable: true
+  - fieldName: "title"
+    columnName: "title"
+    nullable: true
+  - fieldName: "url"
+    columnName: "url"
+    nullable: true
+  - fieldName: "thumbnailUrl"
+    columnName: "thumbnailUrl"
+    nullable: true
+  - fieldName: "post"
+    columnName: "post"
+    nullable: true
+  migrations: []
diff --git a/app/src/main/java/promise/base/AppDatabase.kt b/app/src/main/java/promise/base/AppDatabase.kt
index 7d514bf..a5ab05d 100644
--- a/app/src/main/java/promise/base/AppDatabase.kt
+++ b/app/src/main/java/promise/base/AppDatabase.kt
@@ -35,5 +35,5 @@ import promise.db.PromiseDatabase
 abstract class AppDatabase(fastDatabase: FastDatabase)
   : PromiseDatabase(fastDatabase) {
 
-  //abstract fun getPostCommentsDao(): PostCommentDao
+  abstract fun getPostCommentsDao(): PostCommentDao
 }
diff --git a/app/src/main/java/promise/base/AppTypeConverter.kt b/app/src/main/java/promise/base/AppTypeConverter.kt
index 6010fbc..190200b 100644
--- a/app/src/main/java/promise/base/AppTypeConverter.kt
+++ b/app/src/main/java/promise/base/AppTypeConverter.kt
@@ -12,20 +12,15 @@
  */
 
 package promise.base
-
 import promise.database.TypeConverter
 import java.util.*
 
 @TypeConverter
 class AppTypeConverter {
 
-  fun dateToString(date: Date): String {
-    return date.toString()
-  }
+  fun dateToString(date: Date?): String = (date ?: Date()).time.toString()
 
-  fun stringToDate(data: String): Date {
-    return Date()
-  }
+  fun stringToDate(data: String): Date = Date(data.toLong())
 
   fun toUniqueId(data: String): ID = ID(data)
 
diff --git a/app/src/main/java/promise/base/post/PostRepository.kt b/app/src/main/java/promise/base/post/PostRepository.kt
index 57d9526..8fbb41d 100644
--- a/app/src/main/java/promise/base/post/PostRepository.kt
+++ b/app/src/main/java/promise/base/post/PostRepository.kt
@@ -27,42 +27,42 @@ interface PostRepository {
 
   fun deletePosts()
 }
-//
-//@Singleton
-//class PostRepositoryImpl @Inject constructor(
-//    private var postRelationsDao: PostRelationsDao,
-//    private var postsTable: PostsTable) : PostRepository {
-//  init {
-//    val posts = IdentifiableList(promise.commons.model.List.generate(5) {
-//      Post().apply {
-//        uId = ID(it.toString())
-//        title = "post".plus(it)
-//        body = "body".plus(it)
-//        userId = it
-//        comments = promise.commons.model.List.generate(4) {
-//          PostComment().apply {
-//            name = "nm".repeat(it)
-//            uId = ID((it + 1).toString())
-//            body = "hbytcvbcrxgfvbtrxt"
-//            email = "ejmail;jgfccghcfcvhbhcgvb"
-//          }
-//        }
-//      }
-//    })
-//
-//    postRelationsDao.saveWithComments(posts)
-//  }
-//
-//  override fun savePost(post: Post) {
-//    postsTable.save(post)
-//  }
-//
-//  override fun getPosts(): List<Post> = postRelationsDao.listWithComments()
-//  override fun deletePosts() {
-//    val persons = postRelationsDao.listWithComments()
-//    persons.forEach {
-//      postRelationsDao.deleteComments(it)
-//      it.delete()
-//    }
-//  }
-//}
\ No newline at end of file
+
+@Singleton
+class PostRepositoryImpl @Inject constructor(
+    private var postRelationsDao: PostRelationsDao,
+    private var postsTable: PostsTable) : PostRepository {
+  init {
+    val posts = IdentifiableList(promise.commons.model.List.generate(5) {
+      Post().apply {
+        uId = ID(it.toString())
+        title = "post".plus(it)
+        body = "body".plus(it)
+        userId = it
+        comments = promise.commons.model.List.generate(4) {
+          PostComment().apply {
+            name = "nm".repeat(it)
+            uId = ID((it + 1).toString())
+            body = "hbytcvbcrxgfvbtrxt"
+            email = "ejmail;jgfccghcfcvhbhcgvb"
+          }
+        }
+      }
+    })
+
+    postRelationsDao.saveWithComments(posts)
+  }
+
+  override fun savePost(post: Post) {
+    postsTable.save(post)
+  }
+
+  override fun getPosts(): List<Post> = postRelationsDao.listWithComments()
+  override fun deletePosts() {
+    val persons = postRelationsDao.listWithComments()
+    persons.forEach {
+      postRelationsDao.deleteComments(it)
+      it.delete()
+    }
+  }
+}
\ No newline at end of file
diff --git a/app/src/main/java/promise/dbapp/DatabaseDependencies.kt b/app/src/main/java/promise/dbapp/DatabaseDependencies.kt
index 1e391a1..e866ae7 100644
--- a/app/src/main/java/promise/dbapp/DatabaseDependencies.kt
+++ b/app/src/main/java/promise/dbapp/DatabaseDependencies.kt
@@ -22,19 +22,19 @@ import javax.inject.Singleton
 
 @Module
 object DatabaseDependencies {
-//
-// @Provides
-// @Singleton
-// @JvmStatic
-// fun provideAppDatabase(): AppDatabaseImpl = AppDatabaseImpl.createDatabase("blog_db")
-//
-// @Provides
-// @JvmStatic
-// fun providePostRelationsDao(appDatabase: AppDatabaseImpl): PostRelationsDao =
-//     appDatabase.postRelationsDao
-// @Provides
-// @JvmStatic
-// fun providePostTable(appDatabase: AppDatabaseImpl): PostsTable =
-//     appDatabase.postsTable
+
+ @Provides
+ @Singleton
+ @JvmStatic
+ fun provideAppDatabase(): AppDatabaseImpl = AppDatabaseImpl.createDatabase("blog_db")
+
+ @Provides
+ @JvmStatic
+ fun providePostRelationsDao(appDatabase: AppDatabaseImpl): PostRelationsDao =
+     appDatabase.postRelationsDao
+ @Provides
+ @JvmStatic
+ fun providePostTable(appDatabase: AppDatabaseImpl): PostsTable =
+     appDatabase.postsTable
 
 }
\ No newline at end of file
diff --git a/app/src/main/java/promise/dbapp/MainActivity.kt b/app/src/main/java/promise/dbapp/MainActivity.kt
index 3b623c8..f6f418e 100644
--- a/app/src/main/java/promise/dbapp/MainActivity.kt
+++ b/app/src/main/java/promise/dbapp/MainActivity.kt
@@ -22,9 +22,9 @@ import promise.base.post.PostRepository
 import javax.inject.Inject
 
 class MainActivity : DaggerAppCompatActivity() {
-//
-//  @Inject
-//  lateinit var postRepository: PostRepository
+
+  @Inject
+  lateinit var postRepository: PostRepository
 
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
@@ -37,25 +37,22 @@ class MainActivity : DaggerAppCompatActivity() {
     }
   }
 
-//  override fun onPostCreate(savedInstanceState: Bundle?) {
-//    super.onPostCreate(savedInstanceState)
-//
-//
-//    showInfo()
-//
-//    clear_button.setOnClickListener {
-//      deleteInfo()
-//      showInfo()
-//    }
-//  }
-//
-//  private fun showInfo() {
-//    val persons = postRepository.getPosts()
-//    complex_values_textview.text = persons.toString()
-//  }
-//
-//  private fun deleteInfo() {
-//    postRepository.deletePosts()
-//  }
+  override fun onPostCreate(savedInstanceState: Bundle?) {
+    super.onPostCreate(savedInstanceState)
+    showInfo()
+    clear_button.setOnClickListener {
+      deleteInfo()
+      showInfo()
+    }
+  }
+
+  private fun showInfo() {
+    val persons = postRepository.getPosts()
+    complex_values_textview.text = persons.toString()
+  }
+
+  private fun deleteInfo() {
+    postRepository.deletePosts()
+  }
 
 }
diff --git a/app/src/main/java/promise/dbapp/ReposModule.kt b/app/src/main/java/promise/dbapp/ReposModule.kt
index 126e2a2..f2eb78a 100644
--- a/app/src/main/java/promise/dbapp/ReposModule.kt
+++ b/app/src/main/java/promise/dbapp/ReposModule.kt
@@ -16,11 +16,11 @@ package promise.dbapp
 import dagger.Binds
 import dagger.Module
 import promise.base.post.PostRepository
-//import promise.base.post.PostRepositoryImpl
+import promise.base.post.PostRepositoryImpl
 
 @Module
 abstract class ReposModule {
-//
-//  @Binds
-//  abstract fun bindPostsRepository(postRepositoryImpl: PostRepositoryImpl): PostRepository
+
+  @Binds
+  abstract fun bindPostsRepository(postRepositoryImpl: PostRepositoryImpl): PostRepository
 }
\ No newline at end of file
diff --git a/app/src/main/java/promise/dbapp/test/PostCommentsDaoImpl.java b/app/src/main/java/promise/dbapp/test/PostCommentsDaoImpl.java
index 1ff645e..b450eda 100644
--- a/app/src/main/java/promise/dbapp/test/PostCommentsDaoImpl.java
+++ b/app/src/main/java/promise/dbapp/test/PostCommentsDaoImpl.java
@@ -12,57 +12,50 @@
  */
 
 package promise.dbapp.test;
-//
-//import android.database.Cursor;
-//
-//import java.util.ArrayList;
-//import java.util.List;
-//
-//import promise.base.comment.PostComment;
-//import promise.base.comment.PostCommentDao;
-//import promise.base.comment.PostCommentToReplyRelation;
-//import promise.base.comment.PostCommentsTable;
-//import promise.db.PromiseDatabase;
-//import promise.db.criteria.Criteria;
-//import promise.model.IdentifiableList;
+
+import android.database.Cursor;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import promise.base.comment.PostComment;
+import promise.base.comment.PostCommentDao;
+import promise.base.comment.PostCommentToReplyRelation;
+import promise.base.comment.PostCommentsTable;
+import promise.db.PromiseDatabase;
+import promise.db.criteria.Criteria;
+import promise.model.IdentifiableList;
 
 public class PostCommentsDaoImpl
-    //extends PostCommentDao
+    implements PostCommentDao
 {
-//
-//  private PromiseDatabase fastDatabase;
-//  private PostCommentsTable postCommentsTable;
-//
-//  public PostCommentsDaoImpl(PromiseDatabase fastDatabase) {
-//    this.fastDatabase = fastDatabase;
-//    this.postCommentsTable = (PostCommentsTable) fastDatabase.tableOf(PostComment.class);
-//  }
-//
-//  @Override
-//  public List<PostCommentToReplyRelation> getPostComments(Criteria andCriteria) {
-//    Cursor cursor = fastDatabase.getDatabaseInstance().query(
-//        postCommentsTable.queryBuilder()
-//            .whereAnd(andCriteria));
-//    return getPostCommentRepliesImpl(cursor);
-//  }
-//
-//  public List<PostComment> getPostCommentRepliesImpl(PostComment postComment) {
-//    return new ArrayList<>(postCommentsTable.findAll(PostCommentsTable.idColumn.with(postComment.getId())));
-//  }
-//
-//  private List<PostCommentToReplyRelation> getPostCommentRepliesImpl(Cursor cursor) {
-//    IdentifiableList<? extends PostComment> postComments = postCommentsTable.collection(cursor);
-//    return postComments.map(postComment -> new PostCommentToReplyRelation() {{
-//      setPostComment(postComment);
-//      setPostCommentReplies(getPostCommentRepliesImpl(postComment));
-//    }});
-//  }
-//
-//  private PostCommentToReplyRelation getPostCommentReplyImpl(Cursor cursor) {
-//    PostComment postComment = postCommentsTable.single(cursor);
-//    return new PostCommentToReplyRelation() {{
-//      setPostComment(postComment);
-//      setPostCommentReplies(getPostCommentRepliesImpl(postComment));
-//    }};
-//  }
+
+  private PromiseDatabase promiseDatabase;
+
+  public PostCommentsDaoImpl(PromiseDatabase fastDatabase) {
+    this.promiseDatabase = fastDatabase;
+  }
+
+  private PostCommentToReplyRelation getPostCommentToReplyRelation(PostComment postComment) {
+    return new PostCommentToReplyRelation() {{
+      setPostComment(postComment);
+      setPostCommentReplies(new ArrayList<>(
+          promiseDatabase.tableOf(PostComment.class).findAll(
+              PostCommentsTable.postCommentIdColumn.with(
+                  postComment.getId().toString()))));
+    }};
+  }
+
+  @Override
+  public List<PostCommentToReplyRelation> getPostComments(Criteria andCriteria) {
+    Cursor cursor = promiseDatabase.getDatabaseInstance().query(
+        promiseDatabase.tableOf(PostComment.class).queryBuilder()
+            .whereAnd(andCriteria));
+    return getPostCommentToReplyRelationCollection(cursor);
+  }
+
+  private List<PostCommentToReplyRelation> getPostCommentToReplyRelationCollection(Cursor cursor) {
+    IdentifiableList<? extends PostComment> postComments = promiseDatabase.tableOf(PostComment.class).collection(cursor);
+    return postComments.map(this::getPostCommentToReplyRelation);
+  }
 }
diff --git a/compiler/build.gradle b/compiler/build.gradle
index 97fdd42..3ad1290 100644
--- a/compiler/build.gradle
+++ b/compiler/build.gradle
@@ -22,6 +22,8 @@ dependencies {
     //compileOnly 'com.github.android-promise.database:commons:1.0.3-alpha4'
     compileOnly project(path: ':commons')
     compileOnly files(Jvm.current().getToolsJar())
+    implementation 'com.google.auto.value:auto-value-annotations:1.7.4'
+    kapt 'com.google.auto.value:auto-value:1.7.4'
     implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:2.9.0'
     implementation 'com.fasterxml.jackson.core:jackson-databind:2.9.0'
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
diff --git a/compiler/src/main/java/promise/database/compiler/DAOAnnotatedProcessor.kt b/compiler/src/main/java/promise/database/compiler/DAOAnnotatedProcessor.kt
index 776e559..6b48662 100644
--- a/compiler/src/main/java/promise/database/compiler/DAOAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/database/compiler/DAOAnnotatedProcessor.kt
@@ -13,38 +13,41 @@
 
 package promise.database.compiler
 
+import com.google.auto.common.MoreTypes
 import com.squareup.javapoet.AnnotationSpec
 import com.squareup.javapoet.ClassName
+import com.squareup.javapoet.CodeBlock
+import com.squareup.javapoet.FieldSpec
 import com.squareup.javapoet.JavaFile
 import com.squareup.javapoet.MethodSpec
+import com.squareup.javapoet.ParameterSpec
 import com.squareup.javapoet.TypeSpec
 import org.jetbrains.annotations.NotNull
+import promise.database.Child
 import promise.database.DAO
 import promise.database.Parent
 import promise.database.Relation
 import promise.database.compiler.utils.JavaUtils
 import promise.database.compiler.utils.LogUtil
+import promise.database.compiler.utils.asTableClassName
+import promise.database.compiler.utils.camelCase
+import promise.database.compiler.utils.toTypeName
 import javax.annotation.processing.ProcessingEnvironment
 import javax.annotation.processing.RoundEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.ElementKind
 import javax.lang.model.element.Modifier
+import javax.lang.model.element.TypeElement
 import javax.lang.model.element.VariableElement
 import javax.lang.model.util.ElementFilter
 
+
 class DAOAnnotatedProcessor(private val processingEnv: ProcessingEnvironment) : AnnotatedClassProcessor() {
   override fun process(environment: RoundEnvironment?): List<JavaFile.Builder?>? {
     val javaFiles = ArrayList<JavaFile.Builder?>()
     environment?.getElementsAnnotatedWith(DAO::class.java)
-        ?.forEach { element ->
-//          if (element.kind != ElementKind.CLASS ||
-//              element.kind != ElementKind.INTERFACE)
-//            LogUtil.e(Exception("Only classes can be annotated"), element)
-          if (!element.modifiers.contains(Modifier.ABSTRACT))
-            LogUtil.e(Exception("Class must be abstract"), element)
-//          if (element.enclosingElement != null)
-//            LogUtil.e(Exception("Class must not extend or implement any other class or interfaces"), element)
-          else javaFiles.add(processAnnotation(element))
+        ?.forEach {
+          javaFiles.add(processAnnotation(it))
         }
     return javaFiles
   }
@@ -60,76 +63,146 @@ class DAOAnnotatedProcessor(private val processingEnv: ProcessingEnvironment) :
         .addModifiers(Modifier.PUBLIC)
         .addMethod(MethodSpec.constructorBuilder()
             .addModifiers(Modifier.PUBLIC)
-            .addParameter(
-                ClassName.get("promise.db", "PromiseDatabase")
-                    .annotated(AnnotationSpec.builder(NotNull::class.java).build()),
+            .addParameter(ClassName.get("promise.db", "PromiseDatabase")
+                .annotated(AnnotationSpec.builder(NotNull::class.java).build()),
                 "promiseDatabase")
-            .build())
+            .addStatement("this.promiseDatabase = promiseDatabase").build())
+
+    classBuilder.addField(FieldSpec.builder(ClassName.get("promise.db", "PromiseDatabase")
+        .annotated(AnnotationSpec.builder(NotNull::class.java).build()),
+        "promiseDatabase").build())
+
     if (element.kind == ElementKind.INTERFACE) classBuilder.addSuperinterface(element.asType())
     else if (element.kind == ElementKind.CLASS) classBuilder.superclass(element.asType())
+
     val gen = """
-      //  private PromiseDatabase fastDatabase;
-      //  private PostCommentsTable postCommentsTable;
-      //
-      //  public PostCommentsDaoImpl(PromiseDatabase fastDatabase) {
-      //    this.fastDatabase = fastDatabase;
-      //    this.postCommentsTable = (PostCommentsTable) fastDatabase.tableOf(PostComment.class);
-      //  }
-      //
-      //  @Override
-      //  public List<PostCommentToReplyRelation> getPostComments(Criteria andCriteria) {
-      //    Cursor cursor = fastDatabase.getDatabaseInstance().query(
-      //        postCommentsTable.queryBuilder()
-      //            .whereAnd(andCriteria));
-      //    return getPostCommentRepliesImpl(cursor);
-      //  }
-      //
-      //  public List<PostComment> getPostCommentRepliesImpl(PostComment postComment) {
-      //    return new ArrayList<>(postCommentsTable.findAll(PostCommentsTable.idColumn.with(postComment.getId())));
-      //  }
-      //
-      //  private List<PostCommentToReplyRelation> getPostCommentRepliesImpl(Cursor cursor) {
-      //    IdentifiableList<? extends PostComment> postComments = postCommentsTable.collection(cursor);
-      //    return postComments.map(postComment -> new PostCommentToReplyRelation() {{
-      //      setPostComment(postComment);
-      //      setPostCommentReplies(getPostCommentRepliesImpl(postComment));
-      //    }});
-      //  }
-      //
-      //  private PostCommentToReplyRelation getPostCommentReplyImpl(Cursor cursor) {
-      //    PostComment postComment = postCommentsTable.single(cursor);
-      //    return new PostCommentToReplyRelation() {{
-      //      setPostComment(postComment);
-      //      setPostCommentReplies(getPostCommentRepliesImpl(postComment));
-      //    }};
-      //  }
+      
+  private PostCommentToReplyRelation getPostCommentToReplyRelation(PostComment postComment) {
+    return new PostCommentToReplyRelation() {{
+      setPostComment(postComment);
+      setPostCommentReplies(new ArrayList<>(
+          promiseDatabase.tableOf(PostComment.class).findAll(
+              PostCommentsTable.postCommentIdColumn.with(
+                  postComment.getId().toString()))));
+    }};
+  }
+
+  @Override
+  public List<PostCommentToReplyRelation> getPostComments(Criteria andCriteria) {
+    Cursor cursor = promiseDatabase.getDatabaseInstance().query(
+        promiseDatabase.tableOf(PostComment.class).queryBuilder()
+            .whereAnd(andCriteria));
+    return getPostCommentRepliesImpl(cursor);
+  }
+
+  private List<PostCommentToReplyRelation> getPostCommentRepliesImpl(Cursor cursor) {
+    IdentifiableList<? extends PostComment> postComments = promiseDatabase.tableOf(PostComment.class).collection(cursor);
+    return postComments.map(this::getPostCommentToReplyRelation);
+  }
     """.trimIndent()
-//    ElementFilter.methodsIn(element.enclosedElements).forEach { executableElement ->
-//      val returnType = processingEnv.typeUtils.asElement(executableElement.returnType)
-//      val relationType: Element
-//      if (JavaUtils.isCollectionType(processingEnv, returnType as VariableElement?)) {
-//        val typeMirrors = JavaUtils.getParameterizedTypeMirrors(returnType)
-//        if (typeMirrors != null && typeMirrors.isNotEmpty()) {
-//          relationType = processingEnv.typeUtils.asElement(typeMirrors[0])
-//          if (relationType.getAnnotation(Relation::class.java) != null) {
-//            var relationFields = ElementFilter.fieldsIn(relationType.enclosedElements);
-//            val parentRelations = relationFields.filter {
-//              it.getAnnotation(Parent::class.java) != null
-//            }
-//            if (parentRelations.size > 1) {
-//              LogUtil.e(Exception("Relation classes can only have one field annotated with Parent"), relationType)
-//            }
-//            val parentRelation = parentRelations[0]
-//
-//
-//          } else LogUtil.e(Exception("Class must be annotated as Relation"), relationType)
-//        }
-//      }
-//      else {
-//
-//      }
-//    }
+    ElementFilter.methodsIn(element.enclosedElements).forEach { executableElement ->
+      classBuilder.addMethod(MethodSpec.overriding(executableElement)
+          .addCode("return null;").build())
+      var relationType: Element?
+      if (MoreTypes.isType(executableElement.returnType) &&
+          MoreTypes.isTypeOf(Collection::class.java, executableElement.returnType)) {
+        val typeMirrors =
+            JavaUtils.getParameterizedTypeMirrors(MoreTypes.asDeclared(executableElement.returnType) as VariableElement)
+
+        val typeMirror = typeMirrors[0]
+        relationType = processingEnv.typeUtils.asElement(typeMirror)
+        LogUtil.n(Exception("Return type is collection: ${relationType}"))
+        //generateGetRelationMethod(classBuilder, relationType)
+      }
+
+      else {
+        relationType = processingEnv.typeUtils.asElement(executableElement.returnType)
+        LogUtil.n(Exception("Return type is : ${relationType}"))
+        //generateGetRelationMethod(classBuilder, relationType)
+      }
+
+      if (relationType == null) throw IllegalStateException("Failed to determine relation class")
+
+//      classBuilder.addMethod(MethodSpec.methodBuilder("get${relationType.simpleName}Impl")
+//          .addParameter(ClassName.get("android.database", "Cursor"), "cursor")
+//          .addModifiers(Modifier.PRIVATE)
+//          .returns(processingEnv.typeUtils.asElement(executableElement.returnType).toTypeName())
+//          .addCode("return null;")
+//          .build())
+    }
     return JavaFile.builder(pack, classBuilder.build())
   }
 
+  private fun generateGetRelationMethod(classBuilder: TypeSpec.Builder,
+                                        relationType: Element) {
+    val gen = """
+  private PostCommentToReplyRelation getPostCommentToReplyRelation(PostComment postComment) {
+    return new PostCommentToReplyRelation() {{
+      setPostComment(postComment);
+      setPostCommentReplies(new ArrayList<>(
+          promiseDatabase.tableOf(PostComment.class).findAll(
+              PostCommentsTable.postCommentIdColumn.with(
+                  postComment.getId().toString()))));
+    }};
+  }
+  }
+    """.trimIndent()
+    if (relationType.getAnnotation(Relation::class.java) != null) {
+      val relationFields = ElementFilter.fieldsIn(relationType.enclosedElements);
+      val parentRelations = relationFields.filter {
+        it.getAnnotation(Parent::class.java) != null
+      }
+      if (parentRelations.isEmpty()) LogUtil.e(Exception("Relation classes must have a parent annotated field"), relationType)
+      if (parentRelations.size > 1) LogUtil.e(Exception("Relation classes can only have one field annotated with Parent"), relationType)
+      val parentRelation = parentRelations[0]
+
+      classBuilder.addMethod(MethodSpec.methodBuilder("get${relationType.simpleName}")
+          .addModifiers(Modifier.PRIVATE)
+          .returns(relationType.toTypeName())
+          .addParameter(ParameterSpec.builder(parentRelation.toTypeName(),
+              parentRelation.simpleName.toString().camelCase()).build())
+          .addCode(CodeBlock.builder()
+              .beginControlFlow("return new ${relationType.simpleName}() {")
+              .addStatement("set${parentRelation.simpleName}(${parentRelation.simpleName.toString().camelCase()})")
+              .add(getCodeBlockForChildElements(relationType).build())
+              .endControlFlow("}")
+              .build())
+          .build())
+
+      val parentTableClass = (parentRelation as TypeElement).asTableClassName(processingEnv)
+      classBuilder.addField(FieldSpec.builder(parentTableClass, parentTableClass.simpleName().camelCase())
+          .addModifiers(Modifier.PRIVATE)
+          .build())
+
+    } else LogUtil.e(Exception("Class must be annotated as Relation"), relationType)
+  }
+
+  private fun getCodeBlockForChildElements(element: Element): CodeBlock.Builder {
+    val codeBlock = CodeBlock.builder()
+    ElementFilter.fieldsIn(element.enclosedElements)
+        .filter {
+          it.getAnnotation(Parent::class.java) == null
+        }
+        .filter {
+          if (it.getAnnotation(Child::class.java) != null) true
+          else {
+            LogUtil.e(Exception("Field ${it.simpleName} must be annotated with Child"))
+            false
+          }
+        }.forEach {
+          val childAnnotation = it.getAnnotation(Child::class.java)
+          if (JavaUtils.isCollectionType(processingEnv, it)) {
+            val typeMirrors = JavaUtils.getParameterizedTypeMirrors(it)
+            if (typeMirrors != null && typeMirrors.isNotEmpty()) {
+              val relationType = processingEnv.typeUtils.asElement(typeMirrors[0])
+              val fieldToRelatedKey = childAnnotation.fieldRelatedToParent
+              val parentRelationKey = childAnnotation.parentRelatedField
+
+            }
+          } else {
+          }
+        }
+    return codeBlock
+  }
+
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/database/compiler/DatabaseAbstractMethodsGenerator.kt b/compiler/src/main/java/promise/database/compiler/DatabaseAbstractMethodsGenerator.kt
index 55e8dc5..632a4ef 100644
--- a/compiler/src/main/java/promise/database/compiler/DatabaseAbstractMethodsGenerator.kt
+++ b/compiler/src/main/java/promise/database/compiler/DatabaseAbstractMethodsGenerator.kt
@@ -62,32 +62,33 @@ class DatabaseAbstractMethodsGenerator(
     }
 
     val codeBlock = CodeBlock.builder()
+        .beginControlFlow("return new Visitor<Class<? extends T>, FastTable<T>>()")
+        .add("@Override \n")
+        .beginControlFlow("public FastTable<T> visit(Class<? extends T> entityClass)")
     element.getTableEntities(processingEnv).forEach {
       JavaUtils.generateIfStatementObtainClassString(processingEnv, codeBlock, it)
     }
     codeBlock.addStatement("throw new IllegalArgumentException(entityClass.getCanonicalName() + \"not registered with this database\")")
+        .endControlFlow()
+        .add("};")
 
     val typeVariable: TypeVariableName? = TypeVariableName.get("T").withBounds(
         ParameterizedTypeName.get(
             ClassName.get("promise.commons.model", "Identifiable"),
             ClassName.get(Integer::class.java)))
-    funSpecs.add(MethodSpec.methodBuilder("tableOf")
+
+    funSpecs.add(MethodSpec.methodBuilder("getEntityClassVisitor")
         .addTypeVariable(typeVariable)
-        .addParameter(ParameterizedTypeName.get(ClassName.get(Class::class.java),
-            WildcardTypeName.subtypeOf(TypeVariableName.get("T"))
-        ), "entityClass")
         .addAnnotation(Override::class.java)
         .addAnnotation(NotNull::class.java)
-        .addJavadoc("""
-          Returns the table for the specified entity
-          @Param entityClass Class of the entity persisted
-          @Returns the table instance
-        """.trimIndent())
-        .addException(IllegalArgumentException::class.java)
         .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
-        .returns(ParameterizedTypeName.get(
-            ClassName.get("promise.db", "FastTable"),
-            TypeVariableName.get("T")))
+        .returns(ParameterizedTypeName.get(ClassName.get("promise.utils", "Visitor"),
+            ParameterizedTypeName.get(ClassName.get(Class::class.java),
+                WildcardTypeName.subtypeOf(TypeVariableName.get("T"))
+            ),
+            ParameterizedTypeName.get(
+                ClassName.get("promise.db", "FastTable"),
+                TypeVariableName.get("T"))))
         .addCode(codeBlock.build())
         .build())
 
diff --git a/compiler/src/main/java/promise/database/compiler/DatabaseEntityAnnotatedProcessor.kt b/compiler/src/main/java/promise/database/compiler/DatabaseEntityAnnotatedProcessor.kt
index a7a13c1..afe6b3b 100644
--- a/compiler/src/main/java/promise/database/compiler/DatabaseEntityAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/database/compiler/DatabaseEntityAnnotatedProcessor.kt
@@ -18,9 +18,7 @@ import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.JavaFile
 import com.squareup.javapoet.MethodSpec
 import com.squareup.javapoet.TypeSpec
-import promise.database.DatabaseEntity
 import promise.database.compiler.utils.JavaUtils
-import promise.database.compiler.utils.LogUtil
 import promise.database.compiler.utils.asTableClassName
 import promise.database.compiler.utils.getTableClassNameString
 import promise.database.compiler.utils.getTableEntities
@@ -28,7 +26,6 @@ import java.util.*
 import javax.annotation.processing.ProcessingEnvironment
 import javax.annotation.processing.RoundEnvironment
 import javax.lang.model.element.Element
-import javax.lang.model.element.ElementKind
 import javax.lang.model.element.Modifier
 import javax.lang.model.element.TypeElement
 import javax.tools.Diagnostic
@@ -36,35 +33,10 @@ import javax.tools.Diagnostic
 class DatabaseEntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment,
                                        private val database: TypeElement) : AnnotatedClassProcessor() {
 
-  companion object {
-    fun getDatabaseElement(environment: RoundEnvironment?, processingEnv: ProcessingEnvironment): TypeElement? {
-      val databases = environment?.getElementsAnnotatedWith(DatabaseEntity::class.java) ?: emptySet()
-      if (databases.size > 1)
-        LogUtil.e(Exception("There can only be one database in the module"))
-      else if (databases.size == 1) {
-        val element = databases.first()
-        if (element.kind != ElementKind.CLASS) {
-          LogUtil.e(Exception("Only classes can be annotated"), element)
-          return null
-        }
-        if (element.kind == ElementKind.CLASS && !(element as TypeElement).modifiers.contains(Modifier.ABSTRACT))
-          LogUtil.e(Exception("Database class must be abstract"), element)
-        val promiseDatabaseType = JavaUtils.getDeclaredType(processingEnv,
-            processingEnv.elementUtils.getTypeElement("promise.db.PromiseDatabase"))
-        if (!JavaUtils.isSubTypeOfDeclaredType(processingEnv, element, promiseDatabaseType))
-          LogUtil.e(Exception("Database class must extend from promise.db.PromiseDatabase"), element)
-        return element as TypeElement?
-      }
-      return null
-    }
-  }
-
   override fun process(environment: RoundEnvironment?): List<JavaFile.Builder?>? =
       Collections.singletonList(processElement(database))
 
   private fun processElement(element: Element): JavaFile.Builder {
-    processingEnv.messager.printMessage(Diagnostic.Kind.OTHER, "DatabaseProcessor Processing: ${element.simpleName}")
-
     val className = element.simpleName.toString()
     val pack = processingEnv.elementUtils.getPackageOf(element).toString()
 
@@ -84,15 +56,15 @@ class DatabaseEntityAnnotatedProcessor(private val processingEnv: ProcessingEnvi
 
     if (RelationsDaoGenerator.relationsMap.isNotEmpty())
       classBuilder.addMethods(RelationsDaoGenerator.relationsMap.map {
-      MethodSpec.methodBuilder("get"+ it.key.simpleName())
-          .addModifiers(Modifier.PUBLIC)
-          .returns(it.key)
-          .addCode(JavaUtils.generateGetRelationDaoCodeBlock(it).build())
-          .build()
-    })
+        MethodSpec.methodBuilder("get" + it.key.simpleName())
+            .addModifiers(Modifier.PUBLIC)
+            .returns(it.key)
+            .addCode(JavaUtils.generateGetRelationDaoCodeBlock(it).build())
+            .build()
+      })
 
     val supressWarningsSpec = AnnotationSpec.builder(SuppressWarnings::class.java)
-        .addMember("value" , "{\"unchecked\"}")
+        .addMember("value", "{\"unchecked\"}")
 
     classBuilder.superclass(ClassName.get(pack, className))
         .addAnnotation(databaseAnnotationSpec)
@@ -101,7 +73,7 @@ class DatabaseEntityAnnotatedProcessor(private val processingEnv: ProcessingEnvi
         .addMethod(constructorMethod.build())
 
     (element as TypeElement).getTableEntities(processingEnv).forEach {
-      classBuilder.addMethod(MethodSpec.methodBuilder("get"+it.getTableClassNameString())
+      classBuilder.addMethod(MethodSpec.methodBuilder("get" + it.getTableClassNameString())
           .addModifiers(Modifier.PUBLIC)
           .returns(it.asTableClassName(processingEnv))
           .addCode(JavaUtils.generateGetTableStatement(processingEnv, it))
diff --git a/compiler/src/main/java/promise/database/compiler/DatabaseMetaDataWriter.kt b/compiler/src/main/java/promise/database/compiler/DatabaseMetaDataWriter.kt
index fc41cab..c508d8a 100644
--- a/compiler/src/main/java/promise/database/compiler/DatabaseMetaDataWriter.kt
+++ b/compiler/src/main/java/promise/database/compiler/DatabaseMetaDataWriter.kt
@@ -27,29 +27,39 @@ import java.io.IOException
 import javax.lang.model.element.TypeElement
 import kotlin.math.max
 
-class DatabaseMetaDataWriter(
+class DatabaseMetaDataWriter
+(
     private val databaseElement: TypeElement,
     private val schemasPath: String) {
 
+  init {
+    val dir = File(schemasPath)
+    dir.parentFile.mkdirs()
+   dir.mkdirs()
+  }
+
   var currentDatabaseMetaData: DatabaseMetaData? = null
 
-  fun loadCurrentMetaData() {
-    try {
-      val file = File(schemasPath)
-      if (file.exists()) {
+  fun loadCurrentMetaData() = try {
+    val file = File(schemasPath)
+    if (file.exists() && file.isDirectory) {
+     val files = file.listFiles()
+      if (files.isNotEmpty()) {
+        files.sortBy { it.name }
+        val currentFile = files.last()
         val om = ObjectMapper(YAMLFactory())
         //xmlMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
-        val fileWriter = FileReader(file)
+        val fileWriter = FileReader(currentFile)
         currentDatabaseMetaData = om.readValue(fileWriter,  DatabaseMetaData::class.java)
         fileWriter.close()
       }
       else currentDatabaseMetaData = DatabaseMetaData()
-    } catch (e: JsonProcessingException) {
-      LogUtil.e(e)
-    } catch (e: IOException) {
-      LogUtil.e(e)
     }
-
+    else currentDatabaseMetaData = DatabaseMetaData()
+  } catch (e: JsonProcessingException) {
+    LogUtil.e(e)
+  } catch (e: IOException) {
+    LogUtil.e(e)
   }
 
   fun process(
@@ -61,13 +71,13 @@ class DatabaseMetaDataWriter(
       val generatedVersion = TableMetaDataWriter.finalMaxDbVersion()
       databaseMetaData.dbVersion = max(databaseElement.getDatabaseVersion(), generatedVersion)
     }
-    serializeToXML(databaseMetaData)
+    serializeToXML(databaseMetaData, databaseMetaData.dbVersion)
   }
 
-  private fun serializeToXML(obj: Any) {
+  private fun serializeToXML(obj: Any, version: Int) {
     try {
-      val file = File(schemasPath)
-      file.delete()
+      val file = File(schemasPath + File.separator + version + ".yml")
+      if (file.exists()) file.delete()
       file.createNewFile()
       val om = ObjectMapper(YAMLFactory())
       // serialize our Object into XML string
diff --git a/compiler/src/main/java/promise/database/compiler/PromiseDatabaseCompiler.kt b/compiler/src/main/java/promise/database/compiler/PromiseDatabaseCompiler.kt
index d0af55b..761f1d8 100644
--- a/compiler/src/main/java/promise/database/compiler/PromiseDatabaseCompiler.kt
+++ b/compiler/src/main/java/promise/database/compiler/PromiseDatabaseCompiler.kt
@@ -18,7 +18,9 @@ import com.squareup.javapoet.JavaFile
 import promise.database.DAO
 import promise.database.DatabaseEntity
 import promise.database.Entity
+import promise.database.Relation
 import promise.database.TypeConverter
+import promise.database.compiler.utils.JavaUtils
 import promise.database.compiler.utils.LogUtil
 import java.io.File
 import javax.annotation.processing.AbstractProcessor
@@ -28,10 +30,9 @@ import javax.annotation.processing.RoundEnvironment
 import javax.annotation.processing.SupportedOptions
 import javax.annotation.processing.SupportedSourceVersion
 import javax.lang.model.SourceVersion
+import javax.lang.model.element.ElementKind
+import javax.lang.model.element.Modifier
 import javax.lang.model.element.TypeElement
-import javax.tools.JavaFileManager
-import javax.tools.StandardJavaFileManager
-import javax.tools.StandardLocation
 
 @AutoService(Processor::class)
 @SupportedSourceVersion(SourceVersion.RELEASE_8)
@@ -43,24 +44,46 @@ class PromiseDatabaseCompiler : AbstractProcessor() {
     LogUtil.initLogger(processingEnv)
   }
 
+  private fun getDatabaseElement(environment: RoundEnvironment?, processingEnv: ProcessingEnvironment): TypeElement? {
+    val databases = environment?.getElementsAnnotatedWith(DatabaseEntity::class.java) ?: emptySet()
+    if (databases.size > 1)
+      LogUtil.e(Exception("There can only be one database in the module"))
+    else if (databases.size == 1) {
+      val element = databases.first()
+      if (element.kind != ElementKind.CLASS) {
+        LogUtil.e(Exception("Only classes can be annotated"), element)
+        return null
+      }
+      if (element.kind == ElementKind.CLASS && !(element as TypeElement).modifiers.contains(Modifier.ABSTRACT))
+        LogUtil.e(Exception("Database class must be abstract"), element)
+      val promiseDatabaseType = JavaUtils.getDeclaredType(processingEnv,
+          processingEnv.elementUtils.getTypeElement("promise.db.PromiseDatabase"))
+      if (!JavaUtils.isSubTypeOfDeclaredType(processingEnv, element, promiseDatabaseType))
+        LogUtil.e(Exception("Database class must extend from promise.db.PromiseDatabase"), element)
+      return element as TypeElement
+    }
+    return null
+  }
+
   override fun process(mutableSet: MutableSet<out TypeElement>?, environment: RoundEnvironment?): Boolean {
     if (mutableSet == null || mutableSet.isEmpty()) return false
     try {
-      val database = DatabaseEntityAnnotatedProcessor.getDatabaseElement(environment, processingEnv)
+      val database = getDatabaseElement(environment, processingEnv)
       if (database != null) {
-//        val pkg = processingEnv.elementUtils.getPackageOf(database).toString()
-//        val projectFolder = File(File(File("${pkg}${File.separator}${database.simpleName}.java").parent).parent).parent
-//        val resource = processingEnv.filer.createResource(StandardJavaFileManager.getLocation(StandardLocation),
-//            "schemas", database.asType().toString() + ".yml")
-//        val schemaPath = resource.toUri().path
-        databaseMetaDataWriter = DatabaseMetaDataWriter(database, "schemas${File.separator}${database.asType()}.yml")
+        var schelocation = ""
+        val options = processingEnv?.options ?: emptyMap()
+        if (options.containsKey("promise.database.projectDir")) schelocation = options["promise.database.projectDir"]!!
+        else LogUtil.e(Exception("you must provide schema location as argument"))
+        val finalLocation = "${schelocation}${File.separator}schemas${File.separator}${database.asType()}"
+        //LogUtil.e(Exception("Schema loc $finalLocation"))
+        databaseMetaDataWriter = DatabaseMetaDataWriter(database, finalLocation)
       } else LogUtil.e(Exception("No database class found in module"))
       val javaFiles: ArrayList<JavaFile.Builder> = ArrayList()
       val processors: ArrayList<AnnotatedClassProcessor> = ArrayList()
       processors.add(TypeConverterAnnotatedProcessor(processingEnv))
       processors.add(EntityAnnotatedProcessor(processingEnv, database!!))
       processors.add(RelationsDaoProcessor(processingEnv))
-      //processors.add(DAOAnnotatedProcessor(processingEnv))
+      processors.add(DAOAnnotatedProcessor(processingEnv))
       processors.add(DatabaseEntityAnnotatedProcessor(processingEnv, database))
       processors.forEach {
         val builders = it.process(environment)
@@ -94,7 +117,7 @@ class PromiseDatabaseCompiler : AbstractProcessor() {
       }
       return true
     } catch (e: Throwable) {
-      LogUtil.eTrace(e)
+      LogUtil.e(e)
       return false
     }
   }
diff --git a/compiler/src/main/java/promise/database/compiler/RelationsDaoGenerator.java b/compiler/src/main/java/promise/database/compiler/RelationsDaoGenerator.java
index ab317da..4fb3c74 100644
--- a/compiler/src/main/java/promise/database/compiler/RelationsDaoGenerator.java
+++ b/compiler/src/main/java/promise/database/compiler/RelationsDaoGenerator.java
@@ -122,7 +122,6 @@ else if (relationElement.getAnnotation(HasOne.class) != null) try {
         .addParameters(constructorParameters)
         .addCode(constructorBlock.build())
         .build());
-
     generateRelationsDaoBuilder(constructorParameters, pack, fileName);
     javaFiles.add(JavaFile.builder(pack, classBuilder.build()));
     javaFiles.add(Utils.INSTANCE.generateInstanceProviderHolder(ClassName.get(pack, fileName)));
diff --git a/compiler/src/main/java/promise/database/compiler/TableColumnFieldsGenerator.kt b/compiler/src/main/java/promise/database/compiler/TableColumnFieldsGenerator.kt
index 326400a..b8c26d6 100644
--- a/compiler/src/main/java/promise/database/compiler/TableColumnFieldsGenerator.kt
+++ b/compiler/src/main/java/promise/database/compiler/TableColumnFieldsGenerator.kt
@@ -130,7 +130,7 @@ class TableColumnFieldsGenerator(
   private fun getColumnInitializer(element: Element, classTypeName: TypeName): String {
     var str = "Column.Type"
     if (classTypeName.isSameAs(Integer::class.java) ||
-        classTypeName.isSameAs(Integer::class.java) ||
+        classTypeName.isSameAs(Long::class.java) ||
         classTypeName.isSameAs(Float::class.java) ||
         classTypeName.isSameAs(Double::class.java) ||
         classTypeName.isSameAs(Boolean::class.java)) {
@@ -194,6 +194,4 @@ class TableColumnFieldsGenerator(
     }
     return str
   }
-
-
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/database/compiler/TableDeserializerMethodGenerator.kt b/compiler/src/main/java/promise/database/compiler/TableDeserializerMethodGenerator.kt
index 93744cc..943005b 100644
--- a/compiler/src/main/java/promise/database/compiler/TableDeserializerMethodGenerator.kt
+++ b/compiler/src/main/java/promise/database/compiler/TableDeserializerMethodGenerator.kt
@@ -26,7 +26,7 @@ import promise.database.compiler.utils.getConverterCompatibleMethod
 import promise.database.compiler.utils.isElementAnnotatedAsRelation
 import promise.database.compiler.utils.isSameAs
 import promise.database.compiler.utils.toTypeName
-import promise.database.ompiler.utils.*
+import promise.database.compiler.utils.*
 import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
 
@@ -85,6 +85,7 @@ class TableDeserializerMethodGenerator(
   private fun getCursorReturn(varType: TypeName): String =
       when {
         varType.isSameAs(Integer::class.java) -> "getInt"
+        varType.isSameAs(Long::class.java) -> "getLong"
         varType.isSameAs(Boolean::class.java) -> "getInt"
         varType.isSameAs(Double::class.java) -> "getDouble"
         varType.isSameAs(Float::class.java) -> "getFloat"
diff --git a/compiler/src/main/java/promise/database/compiler/utils/JavaUtils.java b/compiler/src/main/java/promise/database/compiler/utils/JavaUtils.java
index d19ad60..04ac53f 100644
--- a/compiler/src/main/java/promise/database/compiler/utils/JavaUtils.java
+++ b/compiler/src/main/java/promise/database/compiler/utils/JavaUtils.java
@@ -26,6 +26,7 @@
 
 import javax.annotation.processing.ProcessingEnvironment;
 import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
 import javax.lang.model.element.Modifier;
 import javax.lang.model.element.TypeElement;
 import javax.lang.model.element.VariableElement;
@@ -77,15 +78,6 @@ public static void generateAddConverterStatementInDatabaseConstructorMethod(
         UtilsKt.toTypeName(converter));
   }
 
-  public static void generateAddRelationsDaoStatementInDatabaseConstructorMethod(
-      MethodSpec.Builder constructorMethod,
-      HashMap<ClassName, HashMap<ClassName, Element>> relationsMap) {
-    for (Map.Entry<ClassName, HashMap<ClassName, Element>> relationDao : relationsMap.entrySet()) {
-      CodeBlock.Builder codeBlock = generateGetRelationDaoCodeBlock(relationDao);
-      constructorMethod.addCode(codeBlock.build());
-    }
-  }
-
   public static CodeBlock.Builder generateGetRelationDaoCodeBlock(Map.Entry<ClassName, HashMap<ClassName, Element>> relationDao) {
     ClassName providerClassName = ClassName.get(relationDao.getKey().packageName(),
         UtilsKt.getInstanceProviderClassName(relationDao.getKey().simpleName()));
@@ -94,9 +86,8 @@ public static CodeBlock.Builder generateGetRelationDaoCodeBlock(Map.Entry<ClassN
         ClassName.get("promise.commons", "SingletonInstanceProvider"),
         providerClassName,
         relationDao.getKey());
-    for (Map.Entry<ClassName, Element> tableAndEntity: relationDao.getValue().entrySet()) {
-      codeBlock.add(".set"+tableAndEntity.getKey().simpleName()+"(get"+tableAndEntity.getKey().simpleName()+"())\n");
-    }
+    for (Map.Entry<ClassName, Element> tableAndEntity: relationDao.getValue().entrySet())
+      codeBlock.add(".set" + tableAndEntity.getKey().simpleName() + "(get" + tableAndEntity.getKey().simpleName() + "())\n");
     codeBlock.addStatement(".build())).get()");
     return codeBlock;
   }
@@ -188,13 +179,6 @@ public static <T> Class<T> wrap(Class<T> c) {
     return c.isPrimitive() ? (Class<T>) PRIMITIVES_TO_WRAPPERS.get(c) : c;
   }
 
-  /**
-   * checks if typemirror is equal to a typename
-   *
-   * @param typeMirror
-   * @param otherType
-   * @return
-   */
   public static boolean isTypeEqual(TypeMirror typeMirror, TypeName otherType) {
     if (typeMirror.getKind() == TypeKind.NONE || otherType == TypeName.VOID ||
         typeMirror.getKind() == TypeKind.VOID) {
@@ -225,6 +209,7 @@ public static boolean isCollectionType(ProcessingEnvironment processingEnvironme
     return isSubTypeOfDeclaredType(processingEnvironment, variableElement, collectionType);
   }
 
+
   public static List<? extends TypeMirror> getParameterizedTypeMirrors(VariableElement variableElement) {
     if (variableElement.asType() instanceof DeclaredType) {
       DeclaredType declaredType = (DeclaredType) variableElement.asType();
@@ -234,11 +219,7 @@ public static List<? extends TypeMirror> getParameterizedTypeMirrors(VariableEle
   }
 
   public static TypeMirror getTypeMirror(VariableElement variableElement) {
-    if (variableElement.asType() instanceof DeclaredType) {
-      return variableElement.asType();
-    }
+    if (variableElement.asType() instanceof DeclaredType) return variableElement.asType();
     return null;
   }
-
-
 }
diff --git a/compiler/src/main/java/promise/database/compiler/utils/LogUtil.java b/compiler/src/main/java/promise/database/compiler/utils/LogUtil.java
index b909c55..fe6064f 100644
--- a/compiler/src/main/java/promise/database/compiler/utils/LogUtil.java
+++ b/compiler/src/main/java/promise/database/compiler/utils/LogUtil.java
@@ -43,6 +43,7 @@ public static void w( Object... messages) {
   }
 
   public static void n(Object... messages) {
+
     StringBuilder builder = new StringBuilder();
 
     builder.append(TAG);
diff --git a/compiler/src/main/java/promise/database/compiler/utils/Utils.kt b/compiler/src/main/java/promise/database/compiler/utils/Utils.kt
index 79bd795..ae13163 100644
--- a/compiler/src/main/java/promise/database/compiler/utils/Utils.kt
+++ b/compiler/src/main/java/promise/database/compiler/utils/Utils.kt
@@ -33,10 +33,9 @@ import javax.lang.model.element.ExecutableElement
 import javax.lang.model.element.Modifier
 import javax.lang.model.element.TypeElement
 import javax.lang.model.element.VariableElement
-import javax.lang.model.type.DeclaredType
-import javax.lang.model.type.MirroredTypeException
-import javax.lang.model.type.TypeKind
-import javax.lang.model.type.TypeMirror
+import javax.lang.model.type.*
+import javax.lang.model.util.SimpleTypeVisitor6
+import javax.lang.model.util.SimpleTypeVisitor7
 import javax.lang.model.util.Types
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.contract
@@ -77,10 +76,15 @@ fun TypeMirror.asTypeElement(processingEnv: ProcessingEnvironment): TypeElement
   }) as TypeElement
 }
 
-fun String.getInstanceProviderClassName(): String {
-  return "${this}InstanceProvider"
+fun TypeMirror.asVariableElement(processingEnv: ProcessingEnvironment): VariableElement? {
+  val typeUtils: Types = processingEnv.typeUtils
+  val typeMirror = typeUtils.erasure(this)
+  if (typeMirror is VariableElement) return typeMirror
+  return null
 }
 
+fun String.getInstanceProviderClassName(): String = "${this}InstanceProvider"
+
 object Utils {
 
   fun getAnnotationMirror(typeElement: ExecutableElement, clazz: Class<*>): AnnotationMirror? {
diff --git a/database/src/main/java/promise/db/DDLFunctions.kt b/database/src/main/java/promise/db/DDLFunctions.kt
index eddfdb5..b530502 100644
--- a/database/src/main/java/promise/db/DDLFunctions.kt
+++ b/database/src/main/java/promise/db/DDLFunctions.kt
@@ -34,4 +34,12 @@ interface DDLFunctions<in X> {
    */
   @Throws(TableError::class)
   fun onUpgrade(x: X, v1: Int, v2: Int)
+
+  /**
+   * @param x
+   * @return
+   * @throws TableError
+   */
+  @Throws(TableError::class)
+  fun onDrop(x: X): Boolean
 }
\ No newline at end of file
diff --git a/database/src/main/java/promise/db/DMLFunctions.kt b/database/src/main/java/promise/db/DMLFunctions.kt
index 2f38ade..7e912f8 100644
--- a/database/src/main/java/promise/db/DMLFunctions.kt
+++ b/database/src/main/java/promise/db/DMLFunctions.kt
@@ -28,10 +28,6 @@ interface DMLFunctions<T : Identifiable<Int>> {
 
   fun save(t: T): Long
 
-  fun single(cursor: Cursor): T
-
-  fun collection(cursor: Cursor): IdentifiableList<out T>
-
   fun saveAsync(t: T): Single<Long>
 
   fun save(list: IdentifiableList<out T>): Boolean
@@ -46,8 +42,6 @@ interface DMLFunctions<T : Identifiable<Int>> {
 
   fun updateAsync(t: T, column: Column<*>): Maybe<Boolean>
 
-  fun queryBuilder(): QueryBuilder
-
   fun query(queryBuilder: QueryBuilder): Cursor
 
   fun queryAsync(queryBuilder: QueryBuilder): Single<Cursor>
diff --git a/database/src/main/java/promise/db/DMLVisitors.kt b/database/src/main/java/promise/db/DMLVisitors.kt
new file mode 100644
index 0000000..a97ab38
--- /dev/null
+++ b/database/src/main/java/promise/db/DMLVisitors.kt
@@ -0,0 +1,129 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db
+
+import android.database.sqlite.SQLiteDatabase
+import android.text.TextUtils
+import androidx.sqlite.db.SupportSQLiteDatabase
+import promise.commons.model.Identifiable
+import promise.commons.model.List
+import promise.model.IdentifiableList
+import promise.utils.Visitor
+
+class UpdateVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteDatabase,
+                                           private val instance: T,
+                                           private val column: Column<*>? = null) : Visitor<TableCrud<T, in SupportSQLiteDatabase>, Boolean> {
+
+  override fun visit(t: TableCrud<T, in SupportSQLiteDatabase>): Boolean {
+    fun update(instance: T, x: SupportSQLiteDatabase, column: Column<*>): Boolean {
+      val whereArg: String = if (column.operand != null && column.value() != null)
+        column.name + column.operand + column.value()
+      else throw TableError("Cant update the record, missing updating information")
+      val values = t.serialize(instance)
+      values.put(FastTable.updatedAt.name, System.currentTimeMillis())
+      return x.update(t.name, SQLiteDatabase.CONFLICT_ROLLBACK, values, whereArg, null) > 0
+    }
+    return if (column == null) {
+      try {
+        update(this.instance, x, FastTable.id.with(this.instance.getId()))
+      } catch (tableError: TableError) {
+        false
+      }
+    } else update(this.instance, x, column)
+  }
+}
+
+class DeleteVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteDatabase,
+                                           private val instance: T) : Visitor<TableCrud<T, in SupportSQLiteDatabase>, Boolean> {
+  override fun visit(t: TableCrud<T, in SupportSQLiteDatabase>): Boolean {
+    fun onDelete(x: SupportSQLiteDatabase, column: Column<*>): Boolean {
+      val where = column.name + column.operand + column.value()
+      return x.delete(t.name, where, null) >= 0
+    }
+    return onDelete(x, FastTable.id.with(instance.getId()))
+  }
+}
+
+class DeleteErasureVisitor(private val x: SupportSQLiteDatabase,
+                           private val column: Column<*>? = null) : Visitor<TableCrud<*, in SupportSQLiteDatabase>, Boolean> {
+  override fun visit(t: TableCrud<*, in SupportSQLiteDatabase>): Boolean {
+    fun onDelete(x: SupportSQLiteDatabase): Boolean =
+        !TextUtils.isEmpty(t.name) && x.delete(t.name, null, null) >= 0
+
+    fun onDelete(x: SupportSQLiteDatabase, column: Column<*>): Boolean {
+      val where = column.name + column.operand + column.value()
+      return x.delete(t.name, where, null) >= 0
+    }
+    return if (column != null) onDelete(x, column)
+    else onDelete(x)
+  }
+}
+
+class DeleteListErasureVisitor<C>(private val x: SupportSQLiteDatabase,
+                                  private val column: Column<C>,
+                                  private val list: List<out C>) : Visitor<TableCrud<*, in SupportSQLiteDatabase>, Boolean> {
+  override fun visit(t: TableCrud<*, in SupportSQLiteDatabase>): Boolean {
+    fun <C> onDelete(x: SupportSQLiteDatabase, column: Column<C>, list: List<out C>): Boolean {
+      val deleted: Boolean
+      var where = ""
+      var i = 0
+      val listSize = list.size
+      while (i < listSize) {
+        val c = list[i]
+        where = if (i == listSize - 1) {
+          column.name + " " + column.operand + " " + c
+        } else column.name + " " + column.operand + " " + c + " OR "
+        i++
+      }
+      deleted = x.delete(t.name, where, null) >= 0
+      return deleted
+    }
+    return onDelete(x, column, list)
+  }
+}
+
+class SaveVisitor<T : Identifiable<Int>>(
+    private val updateVisitor: Visitor<TableCrud<T, in SupportSQLiteDatabase>, Boolean>,
+    private val x: SupportSQLiteDatabase,
+    private val instance: T
+) : Visitor<TableCrud<T, in SupportSQLiteDatabase>, Long> {
+  override fun visit(t: TableCrud<T, in SupportSQLiteDatabase>): Long {
+    fun onSave(instance: T, x: SupportSQLiteDatabase): Long {
+      if (instance.getId() != 0 && updateVisitor.visit(t)) return instance.getId().toLong()
+      val values = t.serialize(instance)
+      values.put(FastTable.createdAt.name, System.currentTimeMillis())
+      values.put(FastTable.updatedAt.name, System.currentTimeMillis())
+      return x.insert(t.name, SQLiteDatabase.CONFLICT_ROLLBACK, values)
+    }
+    return onSave(instance, x)
+  }
+}
+
+class SaveListVisitor<T : Identifiable<Int>>(
+    private val x: SupportSQLiteDatabase,
+    private val list: IdentifiableList<out T>
+) : Visitor<TableCrud<T, in SupportSQLiteDatabase>, Boolean> {
+  override fun visit(t: TableCrud<T, in SupportSQLiteDatabase>): Boolean {
+    var saved = true
+    var i = 0
+    val listSize = list.size
+    while (i < listSize) {
+      val instance = list[i]
+      val visitor = SaveVisitor<T>(UpdateVisitor(x, instance, null), x, instance)
+      saved = saved && visitor.visit(t) > 0
+      i++
+    }
+    /*if (close) database.close();*/return saved
+  }
+}
\ No newline at end of file
diff --git a/database/src/main/java/promise/db/FastDatabaseImpl.kt b/database/src/main/java/promise/db/FastDatabaseImpl.kt
index 4c94b54..78a51b9 100644
--- a/database/src/main/java/promise/db/FastDatabaseImpl.kt
+++ b/database/src/main/java/promise/db/FastDatabaseImpl.kt
@@ -51,7 +51,7 @@ open class FastDatabaseImpl internal constructor(
         listener!!.onCorrupt()
       })
 
-  constructor(name: String?, version: Int) : this(name, version,  null)
+  constructor(name: String?, version: Int) : this(name, version, null)
 
   final override fun onCreate(db: SupportSQLiteDatabase) {
     if (databaseCreationCallback != null) {
@@ -209,17 +209,18 @@ open class FastDatabaseImpl internal constructor(
   }
 
   override fun <T : Identifiable<Int>> find(tableCrud: TableCrud<T, in SupportSQLiteDatabase>): TableCrud.Extras<T> =
-      checkTableExist(tableCrud).onFind(readableDatabase)
+      checkTableExist(tableCrud).accept(FetchExtrasVisitor(readableDatabase)) as TableCrud.Extras<T>
+  //return checkTableExist(tableCrud).onFind(readableDatabase)
 
   override fun <T : Identifiable<Int>> findAll(tableCrud: TableCrud<T, in SupportSQLiteDatabase>): IdentifiableList<out T> =
-      checkTableExist(tableCrud).onFindAll(readableDatabase, true)
+      checkTableExist(tableCrud).accept(FetchAllVisitor(readableDatabase, null)) as IdentifiableList<out T>
 
   override fun <T : Identifiable<Int>> update(t: T, tableCrud: TableCrud<T, in SupportSQLiteDatabase>): Boolean =
-      checkTableExist(tableCrud).onUpdate(t, writableDatabase)
+      checkTableExist(tableCrud).accept(UpdateVisitor(writableDatabase, t, null)) as Boolean
 
   override fun <T : Identifiable<Int>> update(t: T, tableCrud: TableCrud<T, in SupportSQLiteDatabase>, column: Column<*>): Boolean =
       try {
-        checkTableExist(tableCrud).onUpdate(t, writableDatabase, column)
+        checkTableExist(tableCrud).accept(UpdateVisitor(writableDatabase, t, column)) as Boolean
       } catch (tableError: TableError) {
         LogUtil.e(TAG, "update error", tableError)
         false
@@ -227,32 +228,32 @@ open class FastDatabaseImpl internal constructor(
 
   override fun <T : Identifiable<Int>> findAll(tableCrud: TableCrud<T, in SupportSQLiteDatabase>,
                                                vararg columns: Column<*>): IdentifiableList<out T> =
-      checkTableExist(tableCrud).onFindAll(readableDatabase, *columns)
+      checkTableExist(tableCrud).accept(FetchAllVisitor(readableDatabase, columns)) as IdentifiableList<out T>
 
   override fun <T : Identifiable<Int>> delete(tableCrud: TableCrud<T, in SupportSQLiteDatabase>, t: T): Boolean =
-      checkTableExist(tableCrud).onDelete(t, writableDatabase)
+      checkTableExist(tableCrud).accept(DeleteVisitor(writableDatabase, t)) as Boolean
 
   override fun delete(tableCrud: TableCrud<*, in SupportSQLiteDatabase>, column: Column<*>): Boolean =
-      checkTableExist(tableCrud).onDelete(writableDatabase, column)
+      checkTableExist(tableCrud).acceptErasure(DeleteErasureVisitor(writableDatabase, column)) as Boolean
 
   override fun delete(tableCrud: TableCrud<*, in SupportSQLiteDatabase>): Boolean =
-      checkTableExist(tableCrud).onDelete(writableDatabase)
+      checkTableExist(tableCrud).acceptErasure(DeleteErasureVisitor(writableDatabase)) as Boolean
 
   @SafeVarargs
- override fun delete(vararg tableCruds: TableCrud<*, in SupportSQLiteDatabase>): Boolean {
+  override fun delete(vararg tableCruds: TableCrud<*, in SupportSQLiteDatabase>): Boolean {
     var delete = true
     for (table in tableCruds) delete = delete && delete(table)
     return delete
   }
 
   override fun <T> delete(tableCrud: TableCrud<*, in SupportSQLiteDatabase>, column: Column<T>, list: List<out T>): Boolean =
-      checkTableExist(tableCrud).onDelete(writableDatabase, column, list)
+      checkTableExist(tableCrud).acceptErasure(DeleteListErasureVisitor(writableDatabase, column, list)) as Boolean
 
   override fun <T : Identifiable<Int>> save(t: T, tableCrud: TableCrud<T, in SupportSQLiteDatabase>): Long =
-      checkTableExist(tableCrud).onSave(t, writableDatabase)
+      checkTableExist(tableCrud).accept(SaveVisitor(UpdateVisitor(writableDatabase, t, null), writableDatabase, t)) as Long
 
   override fun <T : Identifiable<Int>> save(list: IdentifiableList<out T>, tableCrud: TableCrud<T, in SupportSQLiteDatabase>): Boolean =
-      checkTableExist(tableCrud).onSave(list, writableDatabase)
+      checkTableExist(tableCrud).accept(SaveListVisitor(writableDatabase, list)) as Boolean
 
 
   override fun deleteAll(): Boolean = synchronized(FastDatabaseImpl::class.java) {
@@ -269,7 +270,7 @@ open class FastDatabaseImpl internal constructor(
   }
 
   override fun getLastId(tableCrud: TableCrud<*, in SupportSQLiteDatabase>): Int =
-      checkTableExist(tableCrud).onGetLastId(readableDatabase)
+      checkTableExist(tableCrud).acceptErasure(FetchLastIdVisitor(readableDatabase)) as Int
 
   override fun transact(block: FastDatabase.() -> Unit) = synchronized(this) {
     val db = writableDatabase
diff --git a/database/src/main/java/promise/db/FastTable.kt b/database/src/main/java/promise/db/FastTable.kt
index 7e71cda..1c0b4a2 100644
--- a/database/src/main/java/promise/db/FastTable.kt
+++ b/database/src/main/java/promise/db/FastTable.kt
@@ -13,12 +13,8 @@
 package promise.db
 
 import android.annotation.SuppressLint
-import android.content.ContentValues
 import android.database.Cursor
 import android.database.SQLException
-import android.database.sqlite.SQLiteDatabase.CONFLICT_ROLLBACK
-import android.database.sqlite.SQLiteException
-import android.text.TextUtils
 import androidx.sqlite.db.SupportSQLiteDatabase
 import io.reactivex.Maybe
 import io.reactivex.Single
@@ -27,11 +23,8 @@ import promise.commons.model.Identifiable
 import promise.commons.model.List
 import promise.commons.model.List.fromArray
 import promise.commons.util.Conditions
-import promise.commons.util.DoubleConverter
 import promise.database.Table
-import promise.db.criteria.Criteria
 import promise.model.ITimeStamped
-import promise.db.projection.Projection
 import promise.model.IdentifiableList
 import java.util.*
 
@@ -105,7 +98,7 @@ abstract class FastTable<T : Identifiable<Int>>
 
   override fun collection(cursor: Cursor): IdentifiableList<out T> {
     val collection = IdentifiableList<T>()
-    while (cursor.moveToNext()  && !cursor.isClosed) {
+    while (cursor.moveToNext() && !cursor.isClosed) {
       collection.add(getWithId(cursor))
     }
     cursor.close()
@@ -130,7 +123,7 @@ abstract class FastTable<T : Identifiable<Int>>
   /**
    * The specific tag for logging in this table
    */
-  private val TAG: String = LogUtil.makeTag(FastTable::class.java) + name
+  override val TAG: String = LogUtil.makeTag(FastTable::class.java) + name
 
   /**
    * Temporary data holder for holding data during dangerous table structure changes
@@ -551,189 +544,6 @@ abstract class FastTable<T : Identifiable<Int>>
     }
   }
 
-  /**
-   * more verbose readAsync operation against the database
-   *
-   * @param x readable sql database
-   * @return an extras instance for more concise reads
-   */
-  override fun onFind(x: SupportSQLiteDatabase): TableCrud.Extras<T> =
-      object : QueryExtras<T>(x) {
-        /**
-         *
-         */
-        override fun serialize(t: T): ContentValues = this@FastTable.serialize(t)
-
-        /**
-         *
-         */
-        override fun deserialize(e: Cursor): T = this@FastTable.deserialize(e)
-      }
-
-  /**
-   * readAsync all the rows in the database
-   *
-   * @param x readable sql database
-   * @param close    close the connection if this is true
-   * @return a list of records
-   */
-  override fun onFindAll(x: SupportSQLiteDatabase, close: Boolean): IdentifiableList<out T> {
-    val builder: QueryBuilder = queryBuilder()
-    val cursor: Cursor
-    return try {
-      cursor = x.query(builder.build(), builder.buildParameters())
-      collection(cursor)
-    } catch (e: SQLiteException) {
-      IdentifiableList<T>()
-    }
-  }
-
-  /**
-   * readAsync the rows following the criteria specified in the column provided
-   * for each of the columns
-   * if [Column.value] is not null, filter with the value
-   * if [Column.order] is not null, order by that column too
-   *
-   * @param x readable sql database
-   * @param column  the fields to infer where and order by conditions
-   * @return list of records satisfying the criteria
-   */
-  override fun onFindAll(x: SupportSQLiteDatabase, vararg column: Column<*>): IdentifiableList<out T> {
-    val builder: QueryBuilder = queryBuilder().takeAll()
-    column.forEach {
-      if (it.value() != null) builder.whereAnd(Criteria.equals(it, it.value()))
-      if (it.order() != null) {
-        if (it.order() == Column.DESCENDING) {
-          builder.orderByDescending(it)
-        } else builder.orderByAscending(it)
-      }
-    }
-   return collection( x.query(builder.build(), builder.buildParameters()))
-  }
-
-  /**
-   * updateAsync a row in the table
-   *
-   * @param t        instance to updateAsync
-   * @param x writable sql database
-   * @param column   field with where condition to updateAsync
-   * @return true if instance is updated
-   */
-  @Throws(TableError::class)
-  override fun onUpdate(t: T, x: SupportSQLiteDatabase, column: Column<*>): Boolean {
-    val whereArg: String = if (column.operand != null && column.value() != null)
-      column.name + column.operand + column.value()
-    else throw TableError("Cant update the record, missing updating information")
-    val values = serialize(t)
-    values.put(updatedAt.name, System.currentTimeMillis())
-    return x.update(name, CONFLICT_ROLLBACK, values, whereArg, null) > 0;
-  }
-
-  /**
-   * updated an instance with an id value more than zero
-   *
-   * @param t        the instance to updateAsync
-   * @param x writable sql database
-   * @return true if updated
-   */
-  override fun onUpdate(t: T, x: SupportSQLiteDatabase): Boolean = try {
-    onUpdate(t, x, id.with(t.getId()))
-  } catch (tableError: TableError) {
-    false
-  }
-
-  /**
-   * deletes multiple rows from the table where the column matches all the
-   * given values in list
-   *
-   * @param x writable sql database
-   * @param column   the matching column
-   * @param list     values to match with
-   * @param <C>      the type of matching, must not be derived data type
-   * @return true if all rows are deleted
-  </C> */
-  override fun <C> onDelete(x: SupportSQLiteDatabase, column: Column<C>, list: List<out C>): Boolean {
-    val deleted: Boolean
-    var where = ""
-    var i = 0
-    val listSize = list.size
-    while (i < listSize) {
-      val c = list[i]
-      where = if (i == listSize - 1) {
-        column.name + " " + column.operand + " " + c
-      } else column.name + " " + column.operand + " " + c + " OR "
-      i++
-    }
-    deleted = x.delete(name, where, null) >= 0
-    return deleted
-  }
-
-  /**
-   * deleteAsync a row in the table matching condition in the column
-   *
-   * @param x writable sql database
-   * @param column   field to match
-   * @return true if row is deleted
-   */
-  override fun onDelete(x: SupportSQLiteDatabase, column: Column<*>): Boolean {
-    val where = column.name + column.operand + column.value()
-    return x.delete(name, where, null) >= 0
-  }
-
-  /**
-   * deleteAsync an instance from the table
-   *
-   * @param t        instance to be removed must have an id more than zero
-   * @param x writable sql database
-   * @return true if item is deleted
-   */
-  override fun onDelete(t: T, x: SupportSQLiteDatabase): Boolean =
-      onDelete(x, id.with(t.getId()))
-
-  /**
-   * deleteAsync all rows in the table
-   *
-   * @param x writable sql database
-   * @return true if all rows are deleted
-   */
-  override fun onDelete(x: SupportSQLiteDatabase): Boolean =
-      !TextUtils.isEmpty(name) && x.delete(name, null, null) >= 0
-
-  /**
-   * saveAsync an instance to the database
-   * serialize it to content values
-   *
-   * @param t        instance to be saved
-   * @param x writable sql database
-   * @return id of the row affected
-   */
-  override fun onSave(t: T, x: SupportSQLiteDatabase): Long {
-    if (t.getId() != 0 && onUpdate(t, x)) return t.getId().toLong()
-    val values = serialize(t)
-    values.put(createdAt.name, System.currentTimeMillis())
-    values.put(updatedAt.name, System.currentTimeMillis())
-    return x.insert(name, CONFLICT_ROLLBACK, values)
-  }
-
-  /**
-   * saveAsync a list of items in the database
-   *
-   * @param list     items to be saved
-   * @param x writable sql database
-   * @return true if all the items are saved
-   */
-  override fun onSave(list: IdentifiableList<out T>, x: SupportSQLiteDatabase): Boolean {
-    var saved = true
-    var i = 0
-    val listSize = list.size
-    while (i < listSize) {
-      val t = list[i]
-      saved = saved && onSave(t, x) > 0
-      i++
-    }
-    /*if (close) database.close();*/return saved
-  }
-
   /**
    * drop this table from the database
    *
@@ -752,19 +562,6 @@ abstract class FastTable<T : Identifiable<Int>>
     return true
   }
 
-  /**
-   * get the last id of the last row in the table
-   * uses projection to count the id column as num
-   *
-   * @param x readable sql database
-   * @return the id
-   */
-  override fun onGetLastId(x: SupportSQLiteDatabase): Int {
-    val builder: QueryBuilder = queryBuilder().select(Projection.count(id).`as`("num"))
-    @SuppressLint("Recycle") val cursor = x.query(builder.build(), builder.buildParameters())
-    return cursor.getInt(id.index)
-  }
-
   /**
    * backup all the items in the table during dangerous upgrdes
    *
@@ -772,7 +569,7 @@ abstract class FastTable<T : Identifiable<Int>>
    */
   fun backup(database: SupportSQLiteDatabase) {
     backup = IdentifiableList()
-    backup!!.addAll(onFindAll(database, false))
+    backup!!.addAll(accept(FetchAllVisitor(database, null)) as IdentifiableList<T>)
   }
 
   /**
@@ -782,7 +579,7 @@ abstract class FastTable<T : Identifiable<Int>>
    */
   fun restore(database: SupportSQLiteDatabase) {
     if (backup != null && !backup!!.isEmpty()) {
-      onSave(backup!!, database)
+      accept(SaveListVisitor<T>(database, backup!!))
       backup!!.clear()
     }
     backup = null
@@ -807,323 +604,4 @@ abstract class FastTable<T : Identifiable<Int>>
     return t
   }
 
-  /**
-   * This class contains special queries for reading from the table
-   * see [TimeAware] for encapsulating id and timestamps
-   * see [DoubleConverter] for serializing and de-serializing
-   *
-   * @param <Q> The type of the items in the table
-  </Q> */
-  private abstract inner class QueryExtras<Q : Identifiable<Int>> internal constructor(
-      /**
-       * the database instance to readAsync fromm
-       */
-      private val database: SupportSQLiteDatabase) : TableCrud.Extras<Q>, DoubleConverter<Q, Cursor, ContentValues> {
-
-    fun database(): SupportSQLiteDatabase = database
-
-    /**
-     * get a record pre populated with id and timestamps from each readAsync
-     *
-     * @param cursor serialized version of Q
-     * @return Q the de-serialized output of reading the cursor
-     */
-    fun getWithId(cursor: Cursor): Q {
-      var t = deserialize(cursor)
-      t.setId(cursor.getInt(id.getIndex(cursor)))
-      if (t is ITimeStamped) {
-        val iTimeAware = t as ITimeStamped
-        iTimeAware.setCreatedAt(cursor.getInt(createdAt.getIndex(cursor)).toLong())
-        iTimeAware.setUpdatedAt(cursor.getInt(updatedAt.getIndex(cursor)).toLong())
-        t = iTimeAware as Q
-      }
-      if (t is ActiveRecord<*>) (t as ActiveRecord<T>).table = this@FastTable
-      return t
-    }
-
-    /**
-     * get the first record in the table
-     *
-     * @return the first records or null if theirs none in the table
-     */
-    override fun first(): Q? {
-      val cursor: Cursor
-      return try {
-        val builder: QueryBuilder = queryBuilder().take(1)
-        cursor = database.query(builder.build(), builder.buildParameters())
-        cursor.moveToFirst()
-        getWithId(cursor)
-      } catch (e: SQLiteException) {
-        LogUtil.e(TAG, e)
-        null
-      }
-    }
-
-    /**
-     * get the last record in the table
-     *
-     * @return an item or null if theirs none stored in the table
-     */
-    override fun last(): Q? {
-      val cursor: Cursor
-      return try {
-        val builder: QueryBuilder = queryBuilder().orderByDescending(id).take(1)
-        cursor = database.query(builder.build(), builder.buildParameters())
-        cursor.moveToFirst()
-        getWithId(cursor)
-      } catch (e: SQLiteException) {
-        LogUtil.e(TAG, e)
-        null
-      }
-    }
-
-    /**
-     * get all the items in the table
-     *
-     * @return the items or an empty list if theirs none
-     */
-    override fun all(): IdentifiableList<out Q> {
-      val cursor: Cursor
-      return try {
-        val builder: QueryBuilder = queryBuilder().takeAll()
-        cursor = database.query(builder.build(), builder.buildParameters())
-        val ts = IdentifiableList<Q>()
-        while (cursor.moveToNext() && !cursor.isClosed) ts.add(getWithId(cursor))
-        ts
-      } catch (e: SQLiteException) {
-        IdentifiableList<Q>()
-      }
-    }
-
-    /**
-     * readAsync the top items in the table
-     *
-     * @param limit the number of records to readAsync
-     * @return a list of the items
-     */
-    override fun limit(limit: Int): IdentifiableList<out Q> {
-      val cursor: Cursor
-      return try {
-        val builder: QueryBuilder = queryBuilder().take(limit)
-        cursor = database.query(builder.build(), builder.buildParameters())
-        val ts = IdentifiableList<Q>()
-        while (cursor.moveToNext() && !cursor.isClosed) ts.add(getWithId(cursor))
-        ts
-      } catch (e: SQLiteException) {
-        LogUtil.e(TAG, e)
-        IdentifiableList<Q>()
-      }
-    }
-
-    /**
-     * reads the records between the skip and limit in the table
-     *
-     * @param skip  of set from the top to not readAsync
-     * @param limit items to load after skip
-     * @return a list of records
-     */
-    override fun paginate(skip: Int, limit: Int): IdentifiableList<out Q> {
-      val cursor: Cursor
-      return try {
-        val builder: QueryBuilder = queryBuilder().take(limit).skip(skip)
-        cursor = database.query(builder.build(), builder.buildParameters())
-        val ts = IdentifiableList<Q>()
-        while (cursor.moveToNext() && !cursor.isClosed) ts.add(getWithId(cursor))
-        ts
-      } catch (e: SQLiteException) {
-        LogUtil.e(TAG, e)
-        IdentifiableList<Q>()
-      }
-    }
-
-    override fun paginateDescending(skip: Int, limit: Int): IdentifiableList<out Q> {
-      val cursor: Cursor
-      return try {
-        val builder: QueryBuilder = queryBuilder().orderByDescending(id).take(limit).skip(skip)
-        cursor = database.query(builder.build(), builder.buildParameters())
-        val ts = IdentifiableList<Q>()
-        while (cursor.moveToNext() && !cursor.isClosed) ts.add(getWithId(cursor))
-        ts
-      } catch (e: SQLiteException) {
-        LogUtil.e(TAG, e)
-        IdentifiableList<Q>()
-      }
-    }
-
-    /**
-     * gets all items that match in between the int left and right
-     *
-     * @param column column to match between
-     * @param a      lower between bound
-     * @param b      upper between bound
-     * @return a list of items
-     */
-    override fun between(column: Column<Number>, a: Number, b: Number): IdentifiableList<out Q> {
-      val cursor: Cursor
-      return try {
-        val builder: QueryBuilder = queryBuilder().takeAll().whereAnd(Criteria.between(column, a, b))
-        cursor = database.query(builder.build(), builder.buildParameters())
-        val ts = IdentifiableList<Q>()
-        while (cursor.moveToNext() && !cursor.isClosed) ts.add(getWithId(cursor))
-        ts
-      } catch (e: SQLiteException) {
-        LogUtil.e(TAG, e)
-        IdentifiableList<Q>()
-      }
-    }
-
-    /**
-     * gets all items matching the multiple columns
-     *
-     * @param column fields to match their values
-     * @return a list of items
-     */
-    override fun where(vararg column: Column<*>): IdentifiableList<out Q> {
-      val cursor: Cursor
-      return try {
-        val builder: QueryBuilder = queryBuilder().takeAll()
-        for (column1 in column) if (column1.value() != null) builder.whereAnd(Criteria.equals(column1, column1.value()))
-        cursor = database.query(builder.build(), builder.buildParameters())
-        val ts = IdentifiableList<Q>()
-        while (cursor.moveToNext() && !cursor.isClosed) ts.add(getWithId(cursor))
-        ts
-      } catch (e: SQLiteException) {
-        LogUtil.e(TAG, e)
-        IdentifiableList<Q>()
-      }
-    }
-
-    /**
-     * gets all the items matching not in any of the columns
-     *
-     * @param column field to match
-     * @param bounds not in bounds
-     * @return a list of items
-     */
-    @SafeVarargs
-    override fun notIn(column: Column<Number>, vararg bounds: Number): IdentifiableList<out Q> {
-      val cursor: Cursor
-      val items = arrayOfNulls<Any>(bounds.size)
-      System.arraycopy(bounds, 0, items, 0, bounds.size)
-      val builder: QueryBuilder = queryBuilder().takeAll()
-          .whereAnd(Criteria.notIn(column, items))
-      return try {
-        cursor = database.query(builder.build(), builder.buildParameters())
-        val ts = IdentifiableList<Q>()
-        while (cursor.moveToNext() && !cursor.isClosed) {
-          val t = getWithId(cursor)
-          ts.add(t)
-        }
-        cursor.close()
-        /*database.close();*/ts
-      } catch (e: SQLiteException) {
-        LogUtil.e(TAG, e)
-        IdentifiableList<Q>()
-      }
-    }
-
-    /**
-     * get all the rows where the column is like the columns values
-     *
-     * @param column the fields to compute like from
-     * @return a list of columns
-     */
-    override fun like(vararg column: Column<*>): IdentifiableList<out Q> {
-      val cursor: Cursor
-      val builder: QueryBuilder = queryBuilder().takeAll()
-      for (column1 in column) builder.whereAnd(Criteria.contains(column1, column1.value().toString()))
-      return try {
-        cursor = database.query(builder.build(), builder.buildParameters())
-        val ts = IdentifiableList<Q>()
-        while (cursor.moveToNext() && !cursor.isClosed) {
-          val t = getWithId(cursor)
-          ts.add(t)
-        }
-        cursor.close()
-        /*database.close();*/ts
-      } catch (e: SQLiteException) {
-        LogUtil.e(TAG, e)
-        IdentifiableList<Q>()
-      }
-    }
-
-    /**
-     * get all the rows in the oder specified by the column
-     *
-     * @param column field to order by
-     * @return a list of ordered items
-     */
-    override fun orderBy(column: Column<*>): IdentifiableList<out Q> {
-      val cursor: Cursor
-      val builder: QueryBuilder = queryBuilder().takeAll()
-      if (column.order() == Column.DESCENDING) {
-        builder.orderByDescending(column)
-      } else builder.orderByAscending(column)
-      return try {
-        cursor = database.query(builder.build(), builder.buildParameters())
-        val ts = IdentifiableList<Q>()
-        while (cursor.moveToNext() && !cursor.isClosed) {
-          val t = getWithId(cursor)
-          ts.add(t)
-        }
-        cursor.close()
-        /*database.close();*/ts
-      } catch (e: SQLiteException) {
-        LogUtil.e(TAG, e)
-        IdentifiableList<Q>()
-      }
-    }
-
-    /**
-     * gets all the items grouped by the column
-     *
-     * @param column field to group by
-     * @return a list of grouped items
-     */
-    override fun groupBy(column: Column<*>): IdentifiableList<out Q> {
-      val cursor: Cursor
-      val builder: QueryBuilder = queryBuilder().takeAll().groupBy(column)
-      return try {
-        cursor = database.query(builder.build(), builder.buildParameters())
-        val ts = IdentifiableList<Q>()
-        while (cursor.moveToNext() && !cursor.isClosed) {
-          val t = getWithId(cursor)
-          ts.add(t)
-        }
-        cursor.close()
-        /*database.close();*/ts
-      } catch (e: SQLiteException) {
-        LogUtil.e(TAG, e)
-        IdentifiableList<Q>()
-      }
-    }
-
-    /**
-     * gets all the items grouped and ordered by the two columns
-     *
-     * @param column  group by field
-     * @param column1 order by fields
-     * @return a list of items
-     */
-    override fun groupAndOrderBy(column: Column<*>, column1: Column<*>): IdentifiableList<out Q> {
-      val cursor: Cursor
-      val builder: QueryBuilder = queryBuilder().takeAll().groupBy(column)
-      if (column1.order() == Column.DESCENDING) {
-        builder.orderByDescending(column1)
-      } else builder.orderByAscending(column1)
-      return try {
-        cursor = database.query(builder.build(), builder.buildParameters())
-        val ts = IdentifiableList<Q>()
-        while (cursor.moveToNext() && !cursor.isClosed) {
-          val t = getWithId(cursor)
-          ts.add(t)
-        }
-        cursor.close()
-        /*database.close();*/ts
-      } catch (e: SQLiteException) {
-        LogUtil.e(TAG, e)
-        IdentifiableList<Q>()
-      }
-    }
-  }
 }
\ No newline at end of file
diff --git a/database/src/main/java/promise/db/FetchVisitor.kt b/database/src/main/java/promise/db/FetchVisitor.kt
new file mode 100644
index 0000000..1624527
--- /dev/null
+++ b/database/src/main/java/promise/db/FetchVisitor.kt
@@ -0,0 +1,389 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.db
+
+import android.annotation.SuppressLint
+import android.content.ContentValues
+import android.database.Cursor
+import android.database.sqlite.SQLiteException
+import androidx.sqlite.db.SupportSQLiteDatabase
+import promise.commons.data.log.LogUtil
+import promise.commons.model.Identifiable
+import promise.commons.util.DoubleConverter
+import promise.db.criteria.Criteria
+import promise.db.projection.Projection
+import promise.model.ITimeStamped
+import promise.model.IdentifiableList
+import promise.utils.Visitor
+
+class FetchLastIdVisitor(private val x: SupportSQLiteDatabase) : Visitor<TableCrud<*, in SupportSQLiteDatabase>, Int> {
+  override fun visit(t: TableCrud<*, in SupportSQLiteDatabase>): Int {
+    val builder: QueryBuilder = t.queryBuilder().select(Projection.count(FastTable.id).`as`("num"))
+    @SuppressLint("Recycle") val cursor = x.query(builder.build(), builder.buildParameters())
+    return cursor.getInt(FastTable.id.index)
+  }
+}
+
+class FetchAllVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteDatabase,
+                                             private val columns: Array<out Column<*>>? = null) : Visitor<TableCrud<T, in SupportSQLiteDatabase>, IdentifiableList<out T>> {
+
+  override fun visit(t: TableCrud<T, in SupportSQLiteDatabase>): IdentifiableList<out T> {
+    val builder: QueryBuilder = t.queryBuilder()
+    columns?.forEach {
+      if (it.value() != null) builder.whereAnd(Criteria.equals(it, it.value()))
+      if (it.order() != null) {
+        if (it.order() == Column.DESCENDING) {
+          builder.orderByDescending(it)
+        } else builder.orderByAscending(it)
+      }
+    }
+    val cursor: Cursor
+    return try {
+      cursor = x.query(builder.build(), builder.buildParameters())
+      t.collection(cursor)
+    } catch (e: SQLiteException) {
+      IdentifiableList<T>()
+    }
+  }
+}
+
+class FetchExtrasVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteDatabase) : Visitor<TableCrud<T, in SupportSQLiteDatabase>, TableCrud.Extras<T>> {
+
+  override fun visit(t: TableCrud<T, in SupportSQLiteDatabase>): TableCrud.Extras<T> =
+      object : QueryExtras<T>(x, t) {
+        override fun serialize(instance: T): ContentValues = t.serialize(instance)
+        override fun deserialize(e: Cursor): T = t.deserialize(e)
+      }
+
+  /**
+   * This class contains special queries for reading from the table
+   * see [TimeAware] for encapsulating id and timestamps
+   * see [DoubleConverter] for serializing and de-serializing
+   *
+   * @param <Q> The type of the items in the table
+  </Q> */
+  private abstract inner class QueryExtras<Q : Identifiable<Int>> internal constructor(
+      /**
+       * the database instance to readAsync fromm
+       */
+      private val database: SupportSQLiteDatabase,
+      private val fastTable: TableCrud<T, in SupportSQLiteDatabase>) : TableCrud.Extras<Q>, DoubleConverter<Q, Cursor, ContentValues> {
+
+    fun database(): SupportSQLiteDatabase = database
+
+    /**
+     * get a record pre populated with id and timestamps from each readAsync
+     *
+     * @param cursor serialized version of Q
+     * @return Q the de-serialized output of reading the cursor
+     */
+    fun getWithId(cursor: Cursor): Q {
+      var t = deserialize(cursor)
+      t.setId(cursor.getInt(FastTable.id.getIndex(cursor)))
+      if (t is ITimeStamped) {
+        val iTimeAware = t as ITimeStamped
+        iTimeAware.setCreatedAt(cursor.getInt(FastTable.createdAt.getIndex(cursor)).toLong())
+        iTimeAware.setUpdatedAt(cursor.getInt(FastTable.updatedAt.getIndex(cursor)).toLong())
+        t = iTimeAware as Q
+      }
+      if (t is ActiveRecord<*>) (t as ActiveRecord<T>).table = fastTable as FastTable<T>
+      return t
+    }
+
+    /**
+     * get the first record in the table
+     *
+     * @return the first records or null if theirs none in the table
+     */
+    override fun first(): Q? {
+      val cursor: Cursor
+      return try {
+        val builder: QueryBuilder = fastTable.queryBuilder().take(1)
+        cursor = database.query(builder.build(), builder.buildParameters())
+        cursor.moveToFirst()
+        getWithId(cursor)
+      } catch (e: SQLiteException) {
+        LogUtil.e(fastTable.TAG, e)
+        null
+      }
+    }
+
+    /**
+     * get the last record in the table
+     *
+     * @return an item or null if theirs none stored in the table
+     */
+    override fun last(): Q? {
+      val cursor: Cursor
+      return try {
+        val builder: QueryBuilder = fastTable.queryBuilder().orderByDescending(FastTable.id).take(1)
+        cursor = database.query(builder.build(), builder.buildParameters())
+        cursor.moveToFirst()
+        getWithId(cursor)
+      } catch (e: SQLiteException) {
+        LogUtil.e(fastTable.TAG, e)
+        null
+      }
+    }
+
+    /**
+     * get all the items in the table
+     *
+     * @return the items or an empty list if theirs none
+     */
+    override fun all(): IdentifiableList<out Q> {
+      val cursor: Cursor
+      return try {
+        val builder: QueryBuilder = fastTable.queryBuilder().takeAll()
+        cursor = database.query(builder.build(), builder.buildParameters())
+        val ts = IdentifiableList<Q>()
+        while (cursor.moveToNext() && !cursor.isClosed) ts.add(getWithId(cursor))
+        ts
+      } catch (e: SQLiteException) {
+        IdentifiableList<Q>()
+      }
+    }
+
+    /**
+     * readAsync the top items in the table
+     *
+     * @param limit the number of records to readAsync
+     * @return a list of the items
+     */
+    override fun limit(limit: Int): IdentifiableList<out Q> {
+      val cursor: Cursor
+      return try {
+        val builder: QueryBuilder = fastTable.queryBuilder().take(limit)
+        cursor = database.query(builder.build(), builder.buildParameters())
+        val ts = IdentifiableList<Q>()
+        while (cursor.moveToNext() && !cursor.isClosed) ts.add(getWithId(cursor))
+        ts
+      } catch (e: SQLiteException) {
+        LogUtil.e(fastTable.TAG, e)
+        IdentifiableList<Q>()
+      }
+    }
+
+    /**
+     * reads the records between the skip and limit in the table
+     *
+     * @param skip  of set from the top to not readAsync
+     * @param limit items to load after skip
+     * @return a list of records
+     */
+    override fun paginate(skip: Int, limit: Int): IdentifiableList<out Q> {
+      val cursor: Cursor
+      return try {
+        val builder: QueryBuilder = fastTable.queryBuilder().take(limit).skip(skip)
+        cursor = database.query(builder.build(), builder.buildParameters())
+        val ts = IdentifiableList<Q>()
+        while (cursor.moveToNext() && !cursor.isClosed) ts.add(getWithId(cursor))
+        ts
+      } catch (e: SQLiteException) {
+        LogUtil.e(fastTable.TAG, e)
+        IdentifiableList<Q>()
+      }
+    }
+
+    override fun paginateDescending(skip: Int, limit: Int): IdentifiableList<out Q> {
+      val cursor: Cursor
+      return try {
+        val builder: QueryBuilder = fastTable.queryBuilder().orderByDescending(FastTable.id).take(limit).skip(skip)
+        cursor = database.query(builder.build(), builder.buildParameters())
+        val ts = IdentifiableList<Q>()
+        while (cursor.moveToNext() && !cursor.isClosed) ts.add(getWithId(cursor))
+        ts
+      } catch (e: SQLiteException) {
+        LogUtil.e(fastTable.TAG, e)
+        IdentifiableList<Q>()
+      }
+    }
+
+    /**
+     * gets all items that match in between the int left and right
+     *
+     * @param column column to match between
+     * @param a      lower between bound
+     * @param b      upper between bound
+     * @return a list of items
+     */
+    override fun between(column: Column<Number>, a: Number, b: Number): IdentifiableList<out Q> {
+      val cursor: Cursor
+      return try {
+        val builder: QueryBuilder = fastTable.queryBuilder().takeAll().whereAnd(Criteria.between(column, a, b))
+        cursor = database.query(builder.build(), builder.buildParameters())
+        val ts = IdentifiableList<Q>()
+        while (cursor.moveToNext() && !cursor.isClosed) ts.add(getWithId(cursor))
+        ts
+      } catch (e: SQLiteException) {
+        LogUtil.e(fastTable.TAG, e)
+        IdentifiableList<Q>()
+      }
+    }
+
+    /**
+     * gets all items matching the multiple columns
+     *
+     * @param column fields to match their values
+     * @return a list of items
+     */
+    override fun where(vararg column: Column<*>): IdentifiableList<out Q> {
+      val cursor: Cursor
+      return try {
+        val builder: QueryBuilder = fastTable.queryBuilder().takeAll()
+        for (column1 in column) if (column1.value() != null) builder.whereAnd(Criteria.equals(column1, column1.value()))
+        cursor = database.query(builder.build(), builder.buildParameters())
+        val ts = IdentifiableList<Q>()
+        while (cursor.moveToNext() && !cursor.isClosed) ts.add(getWithId(cursor))
+        ts
+      } catch (e: SQLiteException) {
+        LogUtil.e(fastTable.TAG, e)
+        IdentifiableList<Q>()
+      }
+    }
+
+    /**
+     * gets all the items matching not in any of the columns
+     *
+     * @param column field to match
+     * @param bounds not in bounds
+     * @return a list of items
+     */
+    @SafeVarargs
+    override fun notIn(column: Column<Number>, vararg bounds: Number): IdentifiableList<out Q> {
+      val cursor: Cursor
+      val items = arrayOfNulls<Any>(bounds.size)
+      System.arraycopy(bounds, 0, items, 0, bounds.size)
+      val builder: QueryBuilder = fastTable.queryBuilder().takeAll()
+          .whereAnd(Criteria.notIn(column, items))
+      return try {
+        cursor = database.query(builder.build(), builder.buildParameters())
+        val ts = IdentifiableList<Q>()
+        while (cursor.moveToNext() && !cursor.isClosed) {
+          val t = getWithId(cursor)
+          ts.add(t)
+        }
+        cursor.close()
+        /*database.close();*/ts
+      } catch (e: SQLiteException) {
+        LogUtil.e(fastTable.TAG, e)
+        IdentifiableList<Q>()
+      }
+    }
+
+    /**
+     * get all the rows where the column is like the columns values
+     *
+     * @param column the fields to compute like from
+     * @return a list of columns
+     */
+    override fun like(vararg column: Column<*>): IdentifiableList<out Q> {
+      val cursor: Cursor
+      val builder: QueryBuilder = fastTable.queryBuilder().takeAll()
+      for (column1 in column) builder.whereAnd(Criteria.contains(column1, column1.value().toString()))
+      return try {
+        cursor = database.query(builder.build(), builder.buildParameters())
+        val ts = IdentifiableList<Q>()
+        while (cursor.moveToNext() && !cursor.isClosed) {
+          val t = getWithId(cursor)
+          ts.add(t)
+        }
+        cursor.close()
+        /*database.close();*/ts
+      } catch (e: SQLiteException) {
+        LogUtil.e(fastTable.TAG, e)
+        IdentifiableList<Q>()
+      }
+    }
+
+    /**
+     * get all the rows in the oder specified by the column
+     *
+     * @param column field to order by
+     * @return a list of ordered items
+     */
+    override fun orderBy(column: Column<*>): IdentifiableList<out Q> {
+      val cursor: Cursor
+      val builder: QueryBuilder = fastTable.queryBuilder().takeAll()
+      if (column.order() == Column.DESCENDING) {
+        builder.orderByDescending(column)
+      } else builder.orderByAscending(column)
+      return try {
+        cursor = database.query(builder.build(), builder.buildParameters())
+        val ts = IdentifiableList<Q>()
+        while (cursor.moveToNext() && !cursor.isClosed) {
+          val t = getWithId(cursor)
+          ts.add(t)
+        }
+        cursor.close()
+        /*database.close();*/ts
+      } catch (e: SQLiteException) {
+        LogUtil.e(fastTable.TAG, e)
+        IdentifiableList<Q>()
+      }
+    }
+
+    /**
+     * gets all the items grouped by the column
+     *
+     * @param column field to group by
+     * @return a list of grouped items
+     */
+    override fun groupBy(column: Column<*>): IdentifiableList<out Q> {
+      val cursor: Cursor
+      val builder: QueryBuilder = fastTable.queryBuilder().takeAll().groupBy(column)
+      return try {
+        cursor = database.query(builder.build(), builder.buildParameters())
+        val ts = IdentifiableList<Q>()
+        while (cursor.moveToNext() && !cursor.isClosed) {
+          val t = getWithId(cursor)
+          ts.add(t)
+        }
+        cursor.close()
+        /*database.close();*/ts
+      } catch (e: SQLiteException) {
+        LogUtil.e(fastTable.TAG, e)
+        IdentifiableList<Q>()
+      }
+    }
+
+    /**
+     * gets all the items grouped and ordered by the two columns
+     *
+     * @param column  group by field
+     * @param column1 order by fields
+     * @return a list of items
+     */
+    override fun groupAndOrderBy(column: Column<*>, column1: Column<*>): IdentifiableList<out Q> {
+      val cursor: Cursor
+      val builder: QueryBuilder = fastTable.queryBuilder().takeAll().groupBy(column)
+      if (column1.order() == Column.DESCENDING) {
+        builder.orderByDescending(column1)
+      } else builder.orderByAscending(column1)
+      return try {
+        cursor = database.query(builder.build(), builder.buildParameters())
+        val ts = IdentifiableList<Q>()
+        while (cursor.moveToNext() && !cursor.isClosed) {
+          val t = getWithId(cursor)
+          ts.add(t)
+        }
+        cursor.close()
+        /*database.close();*/ts
+      } catch (e: SQLiteException) {
+        LogUtil.e(fastTable.TAG, e)
+        IdentifiableList<Q>()
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/database/src/main/java/promise/db/PromiseDatabase.java b/database/src/main/java/promise/db/PromiseDatabase.java
index 3838762..9db1b3c 100644
--- a/database/src/main/java/promise/db/PromiseDatabase.java
+++ b/database/src/main/java/promise/db/PromiseDatabase.java
@@ -13,7 +13,11 @@
 
 package promise.db;
 
+import org.jetbrains.annotations.NotNull;
+
 import promise.commons.model.Identifiable;
+import promise.utils.Acceptor;
+import promise.utils.Visitor;
 
 /**
  * Base class for classes annotated with DatabaseEntity
@@ -34,6 +38,8 @@ public FastDatabase getDatabaseInstance() {
     return fastDatabase;
   }
 
+  public abstract <T extends Identifiable<Integer>> Visitor<Class<? extends T>, FastTable<T>> getEntityClassVisitor();
+
   /**
    * returns the table associated with the entity class
    *
@@ -42,7 +48,11 @@ public FastDatabase getDatabaseInstance() {
    * @return FastTable of the entity
    * @throws IllegalArgumentException if entity is not registered with the database
    */
-  public abstract <T extends Identifiable<Integer>> FastTable<T> tableOf(Class<? extends T> entityClass) throws IllegalArgumentException;
+  public  <T extends Identifiable<Integer>> FastTable<T> tableOf(Class<? extends T> entityClass) throws IllegalArgumentException {
+    Visitor<? super Class<? extends T>, ? extends FastTable<T>> t = getEntityClassVisitor();
+    return t.visit(entityClass);
+  }
+
 }
 
 
diff --git a/database/src/main/java/promise/db/ReactiveFastDatabase.kt b/database/src/main/java/promise/db/ReactiveFastDatabase.kt
index 0d2a2bc..40e55a0 100644
--- a/database/src/main/java/promise/db/ReactiveFastDatabase.kt
+++ b/database/src/main/java/promise/db/ReactiveFastDatabase.kt
@@ -45,15 +45,11 @@ class ReactiveFastDatabase private constructor(
 
   constructor(name: String?, version: Int) : this(name, version,  null)
 
-  private fun <T : Identifiable<Int>> dropAsync(tableCrud: TableCrud<T, in SupportSQLiteDatabase>,
-                                                database: SupportSQLiteDatabase): Single<Boolean> =
-      Single.fromCallable { tableCrud.onDrop(database) }
-
   override fun queryAsync(queryBuilder: QueryBuilder): Single<Cursor> = Single.fromCallable { query(queryBuilder) }
 
   @Throws(TableError::class)
   override fun <T : Identifiable<Int>> readAsync(tableCrud: TableCrud<T, in SupportSQLiteDatabase>): ReactiveTable.Extras<T> =
-      object : QueryExtras<T>(tableCrud, readableDatabase) {
+      object : QueryExtras<T>(tableCrud) {
         override fun serialize(t: T): ContentValues = tableCrud.serialize(t)
         override fun deserialize(e: Cursor): T = tableCrud.deserialize(e)
       }
@@ -62,33 +58,33 @@ class ReactiveFastDatabase private constructor(
       Maybe.fromCallable { findAll(tableCrud) }
 
   override fun <T : Identifiable<Int>> readAllAsync(tableCrud: TableCrud<T, in SupportSQLiteDatabase>, vararg column: Column<*>): Maybe<IdentifiableList<out T>> =
-      Maybe.fromCallable { tableCrud.onFindAll(readableDatabase, *column) }
+      Maybe.fromCallable { findAll(tableCrud, *column) }
 
   override fun <T : Identifiable<Int>> updateAsync(t: T, tableCrud: TableCrud<T, in SupportSQLiteDatabase>, column: Column<*>): Maybe<Boolean> =
-      Maybe.fromCallable { tableCrud.onUpdate(t, writableDatabase, column) }
+      Maybe.fromCallable { update(t, tableCrud, column) }
 
   override fun <T : Identifiable<Int>> updateAsync(t: T, tableCrud: TableCrud<T, in SupportSQLiteDatabase>): Maybe<Boolean> =
-      Maybe.fromCallable { tableCrud.onUpdate(t, writableDatabase) }
+      Maybe.fromCallable { update(t, tableCrud) }
 
   override fun <T : Identifiable<Int>> deleteAsync(tableCrud: TableCrud<T, in SupportSQLiteDatabase>, column: Column<*>): Maybe<Boolean> =
-      Maybe.fromCallable { tableCrud.onDelete(writableDatabase, column) }
+      Maybe.fromCallable { delete(tableCrud, column) }
 
   override fun <T : Identifiable<Int>> deleteAsync(tableCrud: TableCrud<T, in SupportSQLiteDatabase>, t: T): Maybe<Boolean> =
-      Maybe.fromCallable { tableCrud.onDelete(t, writableDatabase) }
+      Maybe.fromCallable { delete(tableCrud, t) }
 
   override fun deleteAsync(tableCrud: TableCrud<*, in SupportSQLiteDatabase>): Maybe<Boolean> =
-      Maybe.fromCallable { tableCrud.onDelete(writableDatabase) }
+      Maybe.fromCallable { delete(tableCrud) }
 
   override fun <C> deleteAsync(tableCrud: TableCrud<*, in SupportSQLiteDatabase>,
                                column: Column<C>,
                                list: List<out C>): Maybe<Boolean> =
-      Maybe.fromCallable { tableCrud.onDelete(writableDatabase, column, list) }
+      Maybe.fromCallable { delete(tableCrud, column, list) }
 
   override fun <T : Identifiable<Int>> saveAsync(t: T, tableCrud: TableCrud<T, in SupportSQLiteDatabase>): Single<Long> =
-      Single.fromCallable { tableCrud.onSave(t, writableDatabase) }
+      Single.fromCallable { save(t, tableCrud) }
 
   override fun <T : Identifiable<Int>> saveAsync(list: IdentifiableList<out T>, tableCrud: TableCrud<T, in SupportSQLiteDatabase>): Single<Boolean> =
-      Single.fromCallable { tableCrud.onSave(list, writableDatabase) }
+      Single.fromCallable { save(list, tableCrud) }
 
   override fun deleteAllAsync(): Maybe<Boolean> =
       Maybe.zip(tables().map { tableCrud: TableCrud<*, in SupportSQLiteDatabase> -> this.deleteAsync(tableCrud) }
@@ -99,49 +95,49 @@ class ReactiveFastDatabase private constructor(
       }
 
   override fun <T : Identifiable<Int>> getLastIdAsync(tableCrud: TableCrud<T, in SupportSQLiteDatabase>): Maybe<Int> =
-      Maybe.fromCallable { tableCrud.onGetLastId(readableDatabase) }
+      Maybe.fromCallable { getLastId(tableCrud) }
 
-  private abstract inner class QueryExtras<T : Identifiable<Int>> internal constructor(private val tableCrud: TableCrud<T, in SupportSQLiteDatabase>,
-                                                                                       private val database: SupportSQLiteDatabase) :
+  private abstract inner class QueryExtras<T : Identifiable<Int>>
+  internal constructor(private val tableCrud: TableCrud<T, in SupportSQLiteDatabase>) :
       ReactiveTable.Extras<T>, DoubleConverter<T, Cursor, ContentValues> {
 
-    override fun first(): Maybe<T> = Maybe.fromCallable { tableCrud.onFind(database).first() }
+    override fun first(): Maybe<T> = Maybe.fromCallable { find(tableCrud).first() }
 
-    override fun last(): Maybe<T> = Maybe.fromCallable { tableCrud.onFind(database).last() }
+    override fun last(): Maybe<T> = Maybe.fromCallable { find(tableCrud).last() }
 
     override fun all(): Maybe<IdentifiableList<out T>> =
-        Maybe.fromCallable { tableCrud.onFind(database).all() }
+        Maybe.fromCallable { find(tableCrud).all() }
 
     override fun limit(limit: Int): Maybe<IdentifiableList<out T>> =
-        Maybe.fromCallable { tableCrud.onFind(database).limit(limit) }
+        Maybe.fromCallable { find(tableCrud).limit(limit) }
 
     override fun paginate(skip: Int, limit: Int): Maybe<IdentifiableList<out T>> =
-        Maybe.fromCallable { tableCrud.onFind(database).paginate(skip, limit) }
+        Maybe.fromCallable { find(tableCrud).paginate(skip, limit) }
 
     override fun paginateDescending(skip: Int, limit: Int): Maybe<IdentifiableList<out T>> =
-        Maybe.fromCallable { tableCrud.onFind(database).paginateDescending(skip, limit) }
+        Maybe.fromCallable { find(tableCrud).paginateDescending(skip, limit) }
 
     override fun between(column: Column<Number>, a: Number, b: Number): Maybe<IdentifiableList<out T>> =
-        Maybe.fromCallable { tableCrud.onFind(database).between(column, a, b) }
+        Maybe.fromCallable { find(tableCrud).between(column, a, b) }
 
     override fun where(vararg column: Column<*>): Maybe<IdentifiableList<out T>> =
-        Maybe.fromCallable { tableCrud.onFind(database).where(*column) }
+        Maybe.fromCallable { find(tableCrud).where(*column) }
 
     @SafeVarargs
     override fun notIn(column: Column<Number>, vararg bounds: Number): Maybe<IdentifiableList<out T>> =
-        Maybe.fromCallable { tableCrud.onFind(database).notIn(column, *bounds) }
+        Maybe.fromCallable { find(tableCrud).notIn(column, *bounds) }
 
     override fun like(vararg column: Column<String>): Maybe<IdentifiableList<out T>> =
-        Maybe.fromCallable { tableCrud.onFind(database).like(*column) }
+        Maybe.fromCallable { find(tableCrud).like(*column) }
 
     override fun orderBy(column: Column<*>): Maybe<IdentifiableList<out T>> =
-        Maybe.fromCallable { tableCrud.onFind(database).orderBy(column) }
+        Maybe.fromCallable { find(tableCrud).orderBy(column) }
 
     override fun groupBy(column: Column<*>): Maybe<IdentifiableList<out T>> =
-        Maybe.fromCallable { tableCrud.onFind(database).groupBy(column) }
+        Maybe.fromCallable { find(tableCrud).groupBy(column) }
 
     override fun groupAndOrderBy(column: Column<*>, column1: Column<*>): Maybe<IdentifiableList<out T>> =
-        Maybe.fromCallable { tableCrud.onFind(database).groupAndOrderBy(column, column1) }
+        Maybe.fromCallable { find(tableCrud).groupAndOrderBy(column, column1) }
   }
 
 }
\ No newline at end of file
diff --git a/database/src/main/java/promise/db/TableCrud.kt b/database/src/main/java/promise/db/TableCrud.kt
index 09b3b23..0a8d981 100644
--- a/database/src/main/java/promise/db/TableCrud.kt
+++ b/database/src/main/java/promise/db/TableCrud.kt
@@ -15,9 +15,10 @@ package promise.db
 import android.content.ContentValues
 import android.database.Cursor
 import promise.commons.model.Identifiable
-import promise.commons.model.List
 import promise.commons.util.DoubleConverter
 import promise.model.IdentifiableList
+import promise.utils.Acceptor
+import promise.utils.Visitor
 
 /**
  * the abstract implementation of all possible operations to be done on an table
@@ -31,125 +32,22 @@ import promise.model.IdentifiableList
  * @param <T> the type to be stored in this particular table must be a type of [Identifiable]
  * @param <X> the type of database that this table resides in
 </X></T> */
-interface TableCrud<T : Identifiable<Int>, X> : DoubleConverter<T, Cursor, ContentValues>, DDLFunctions<X> {
+interface TableCrud<T : Identifiable<Int>, X> : DoubleConverter<T, Cursor, ContentValues>,
+    DDLFunctions<X>,
+    Acceptor<TableCrud<T, X>, Any> {
 
-  /**
-   * provides concise readAsync from the table
-   * see [Extras]
-   *
-   * @param x the database instance
-   * @return an instance of extras with more concise methods for querying the data set
-   */
-  fun onFind(x: X): Extras<T>
+  override fun accept(t: Visitor<TableCrud<T, X>, Any>): Any = t.visit(this)
 
-  /**
-   * gets all the records in the table
-   *
-   * @param x     the database instance
-   * @param close if the connection is to be closed
-   * @return a list if the records
-   */
-  fun onFindAll(x: X, close: Boolean): IdentifiableList<out T>
+  fun acceptErasure(t: Visitor<TableCrud<*, X>, Any>): Any = t.visit(this)
 
-  /**
-   * gets all the records matching the conditions specified in the columns
-   *
-   * @param x      database instance
-   * @param column specifies where or order by conditions
-   * @return a list if records
-   */
-  fun onFindAll(x: X, vararg column: Column<*>): IdentifiableList<out T>
+  fun queryBuilder(): QueryBuilder
 
-  /**
-   * updates an item in the table specified by the condition in the column
-   * see [Column.getOperand] for sample conditional operations
-   *
-   * @param t      record to updateAsync
-   * @param x      database instance
-   * @param column field specifying the updateAsync condition
-   * @return true id record is updated
-   * @throws TableError if there is missing updating information or error in sql script
-   */
-  @Throws(TableError::class)
-  fun onUpdate(t: T, x: X, column: Column<*>): Boolean
+  fun single(cursor: Cursor): T
 
-  /**
-   * updates an item with an id with a value more that zero
-   * see [FastTable.id]
-   *
-   * @param t record to updateAsync
-   * @param x database instance
-   * @return true if record is updated otherwise false
-   */
-  fun onUpdate(t: T, x: X): Boolean
+  fun collection(cursor: Cursor): IdentifiableList<out T>
 
-  /**
-   * deleteAsync a record from the table specified by the condition in the column
-   * see [Column.getOperand] for sample conditional operations
-   *
-   * @param x      database instance
-   * @param column field to infer where condition
-   * @return true if record deleted otherwise false
-   */
-  fun onDelete(x: X, column: Column<*>): Boolean
-
-  /**
-   * deletes an item with an id with a value more that zero
-   * see [FastTable.id]
-   *
-   * @param t record to updateAsync
-   * @param x database instance
-   * @return true if record is deleted otherwise false
-   */
-  fun onDelete(t: T, x: X): Boolean
-
-  /**
-   * truncates the table
-   *
-   * @param x database instance
-   * @return true if truncated otherwise false
-   */
-  fun onDelete(x: X): Boolean
-
-  /**
-   * deletes a number of rows where the column matches each item in list
-   *
-   * @param x      database instance
-   * @param column field to match each item in list
-   * @param list   matches to deleteAsync from
-   * @param <C>    type of match must not be derived
-   * @return true if deleted otherwise false
-  </C> */
-  fun <C> onDelete(x: X, column: Column<C>, list: List<out C>): Boolean
-
-  /**
-   * saves an item in the table
-   * if it has an id more than zero, it updates it instead
-   *
-   * @param t item to saveAsync
-   * @param x database instance
-   * @return reference of affected row
-   */
-  fun onSave(t: T, x: X): Long
-
-  /**
-   * saveAsync multiple items to the table
-   *
-   * @param list items to saveAsync
-   * @param x    database instance
-   * @return true if all items are saved otherwise false
-   */
-  fun onSave(list: IdentifiableList<out T>, x: X): Boolean
-
-  /**
-   * @param x
-   * @return
-   * @throws TableError
-   */
-  @Throws(TableError::class)
-  fun onDrop(x: X): Boolean
 
-  fun onGetLastId(x: X): Int
+  val TAG: String
 
   /**
    * @return tableName of this table
diff --git a/database/src/main/java/promise/utils/Acceptor.kt b/database/src/main/java/promise/utils/Acceptor.kt
new file mode 100644
index 0000000..1f9d72a
--- /dev/null
+++ b/database/src/main/java/promise/utils/Acceptor.kt
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.utils
+
+interface Acceptor<T, R> {
+  fun accept(t: Visitor<T, R>): R
+}
\ No newline at end of file
diff --git a/database/src/main/java/promise/utils/Visitor.kt b/database/src/main/java/promise/utils/Visitor.kt
new file mode 100644
index 0000000..d514473
--- /dev/null
+++ b/database/src/main/java/promise/utils/Visitor.kt
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.utils
+
+interface Visitor<in T, out R> {
+  fun visit(t: T): R
+}
\ No newline at end of file
diff --git a/schemas/promise.base.AppDatabase.yml b/schemas/promise.base.AppDatabase.yml
index 7064386..2a892fe 100644
--- a/schemas/promise.base.AppDatabase.yml
+++ b/schemas/promise.base.AppDatabase.yml
@@ -1,115 +1,87 @@
 ---
-dbVersion: 3
+dbVersion: 1
 tableMetaData:
 - tableName: "likes"
   fields:
   - fieldName: "uId"
     columnName: "uId"
     nullable: true
-    length: 0
   - fieldName: "post"
     columnName: "post"
     nullable: true
-    length: 0
   migrations: []
 - tableName: "postComments"
   fields:
   - fieldName: "name"
     columnName: "name"
     nullable: true
-    length: 0
   - fieldName: "uId"
     columnName: "uId"
     nullable: true
-    length: 0
   - fieldName: "body"
     columnName: "body"
     nullable: true
-    length: 0
   - fieldName: "email"
     columnName: "email"
     nullable: true
-    length: 0
   - fieldName: "postCommentId"
     columnName: "postCommentId"
     nullable: true
-    length: 0
   - fieldName: "post"
     columnName: "post"
     nullable: true
-    length: 0
   migrations: []
 - tableName: "posts"
   fields:
   - fieldName: "uId"
     columnName: "uId"
     nullable: true
-    length: 0
   - fieldName: "title"
     columnName: "title"
     nullable: true
-    length: 0
   - fieldName: "body"
     columnName: "body"
     nullable: true
-    length: 0
   - fieldName: "userId"
     columnName: "userId"
     nullable: true
-    length: 0
   - fieldName: "publishedDate"
     columnName: "publishedDate"
     nullable: true
-    length: 0
-  migrations:
-  - versionChange:
-      fromVersion: 2
-      toVersion: 3
-    field: "publishedDateColumn"
-    action: "CREATE"
+  migrations: []
 - tableName: "todoes"
   fields:
   - fieldName: "uid"
     columnName: "uid"
     nullable: true
-    length: 0
   - fieldName: "completed"
     columnName: "completed"
     nullable: true
-    length: 0
   - fieldName: "title"
     columnName: "title"
     nullable: true
-    length: 0
   - fieldName: "description"
     columnName: "description"
     nullable: true
-    length: 0
   - fieldName: "photo"
     columnName: "photo"
     nullable: true
-    length: 0
   migrations: []
 - tableName: "photos"
   fields:
   - fieldName: "albumId"
     columnName: "albumId"
     nullable: true
-    length: 0
   - fieldName: "title"
     columnName: "title"
     nullable: true
-    length: 0
   - fieldName: "url"
     columnName: "url"
     nullable: true
-    length: 0
   - fieldName: "thumbnailUrl"
     columnName: "thumbnailUrl"
     nullable: true
-    length: 0
   - fieldName: "post"
     columnName: "post"
     nullable: true
-    length: 0
   migrations: []

From 4cc181146ca6740884cd6a23ea02140b73294b15 Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Thu, 20 Aug 2020 03:10:07 +0300
Subject: [PATCH 26/34] prep 1.0.3-alpha6

---
 app/build.gradle                              |   2 +-
 app/schemas/promise.base.AppDatabase/1.yml    | 171 +++++++-------
 app/schemas/promise.base.AppDatabase/2.yml    |  98 ++++++++
 app/schemas/promise.base.AppDatabase/3.yml    | 101 ++++++++
 app/schemas/promise.base.AppDatabase/4.yml    | 109 +++++++++
 app/schemas/promise.base.AppDatabase/5.yml    | 106 +++++++++
 app/src/main/java/promise/base/AppDatabase.kt |  17 ++
 .../java/promise/base/AppTypeConverter.kt     |   1 +
 app/src/main/java/promise/base/ID.kt          |   3 -
 .../main/java/promise/base/comment/Like.java  |  57 ++---
 .../promise/base/comment/PostComment.java     | 152 ++++++------
 .../comment/PostCommentToReplyRelation.java   |   2 +-
 app/src/main/java/promise/base/photo/Photo.kt |  21 +-
 app/src/main/java/promise/base/post/Post.java | 220 +++++++++---------
 .../java/promise/base/post/PostRepository.kt  |   3 +-
 app/src/main/java/promise/base/todo/Todo.java | 148 ++++++------
 .../promise/dbapp/ActivityBuildersModule.kt   |   2 +-
 .../main/java/promise/dbapp/AppComponent.kt   |   4 +-
 .../promise/dbapp/DatabaseDependencies.kt     |  25 +-
 .../dbapp/test/PostCommentsDaoImpl.java       |   3 +-
 app/src/main/res/layout/content_main.xml      |   9 +-
 compiler/build.gradle                         |   2 +-
 .../compiler/DAOAnnotatedProcessor.kt         |  39 ++--
 .../DatabaseAbstractMethodsGenerator.kt       |   3 +-
 .../compiler/DatabaseAnnotationGenerator.kt   |   5 +-
 .../DatabaseEntityAnnotatedProcessor.kt       |   1 -
 .../compiler/DatabaseMetaDataWriter.kt        |  23 +-
 .../compiler/EntityAnnotatedProcessor.kt      |   4 +-
 .../compiler/PromiseDatabaseCompiler.kt       |   3 +-
 .../compiler/RelationsDaoGenerator.java       |   6 +-
 .../compiler/RelationsDaoProcessor.kt         |   2 +-
 .../compiler/TableAnnotationGenerator.java    |   1 -
 .../compiler/TableColumnFieldsGenerator.kt    |   7 +-
 .../TableDeserializerMethodGenerator.kt       |   1 -
 .../database/compiler/TableMetaDataWriter.kt  |  90 ++++---
 .../TypeConverterAnnotatedProcessor.kt        |   8 +-
 .../compiler/migration/TableMetaData.kt       |   2 +-
 .../compiler/migration/TableMigration.kt      |  70 +++---
 .../compiler/migration/VersionChange.kt       |   4 +-
 .../database/compiler/utils/JavaUtils.java    |  14 +-
 .../promise/database/compiler/utils/List.java |   8 +-
 .../database/compiler/utils/LogUtil.java      |  17 +-
 .../compiler/utils/PersistableEntityUtils.kt  |   4 +-
 .../promise/database/compiler/utils/Utils.kt  |  10 +-
 .../utils/function/GroupFunction3.java        |   1 -
 .../utils/function/ReduceFunction.java        |   1 -
 .../src/main/java/promise/db/Corrupt.java     |   5 +-
 .../promise/db/DatabaseCreationCallback.kt    |   1 -
 .../src/main/java/promise/db/FastDatabase.kt  |  44 +++-
 .../main/java/promise/db/FastDatabaseImpl.kt  |  80 +++----
 .../promise/db/FastDatabaseOpenHelper.java    |  18 +-
 .../src/main/java/promise/db/FastTable.kt     |   1 +
 .../db/{FetchVisitor.kt => FetchVisitors.kt}  |  26 ++-
 .../src/main/java/promise/db/Migration.kt     |   1 -
 ...romiseDatabase.java => PromiseDatabase.kt} |  42 ++--
 .../java/promise/db/ReactiveFastDatabase.kt   |  21 +-
 56 files changed, 1132 insertions(+), 687 deletions(-)
 create mode 100644 app/schemas/promise.base.AppDatabase/2.yml
 create mode 100644 app/schemas/promise.base.AppDatabase/3.yml
 create mode 100644 app/schemas/promise.base.AppDatabase/4.yml
 create mode 100644 app/schemas/promise.base.AppDatabase/5.yml
 rename database/src/main/java/promise/db/{FetchVisitor.kt => FetchVisitors.kt} (97%)
 rename database/src/main/java/promise/db/{PromiseDatabase.java => PromiseDatabase.kt} (52%)

diff --git a/app/build.gradle b/app/build.gradle
index c36e547..3b848c8 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -36,7 +36,7 @@ android {
         javaCompileOptions {
             annotationProcessorOptions {
                 arguments = [
-                        "promise.database.projectDir"  : "$projectDir".toString()
+                        "promise.database.projectDir": "$projectDir".toString()
                 ]
             }
         }
diff --git a/app/schemas/promise.base.AppDatabase/1.yml b/app/schemas/promise.base.AppDatabase/1.yml
index 2a892fe..8fd04d8 100644
--- a/app/schemas/promise.base.AppDatabase/1.yml
+++ b/app/schemas/promise.base.AppDatabase/1.yml
@@ -1,87 +1,90 @@
 ---
 dbVersion: 1
 tableMetaData:
-- tableName: "likes"
-  fields:
-  - fieldName: "uId"
-    columnName: "uId"
-    nullable: true
-  - fieldName: "post"
-    columnName: "post"
-    nullable: true
-  migrations: []
-- tableName: "postComments"
-  fields:
-  - fieldName: "name"
-    columnName: "name"
-    nullable: true
-  - fieldName: "uId"
-    columnName: "uId"
-    nullable: true
-  - fieldName: "body"
-    columnName: "body"
-    nullable: true
-  - fieldName: "email"
-    columnName: "email"
-    nullable: true
-  - fieldName: "postCommentId"
-    columnName: "postCommentId"
-    nullable: true
-  - fieldName: "post"
-    columnName: "post"
-    nullable: true
-  migrations: []
-- tableName: "posts"
-  fields:
-  - fieldName: "uId"
-    columnName: "uId"
-    nullable: true
-  - fieldName: "title"
-    columnName: "title"
-    nullable: true
-  - fieldName: "body"
-    columnName: "body"
-    nullable: true
-  - fieldName: "userId"
-    columnName: "userId"
-    nullable: true
-  - fieldName: "publishedDate"
-    columnName: "publishedDate"
-    nullable: true
-  migrations: []
-- tableName: "todoes"
-  fields:
-  - fieldName: "uid"
-    columnName: "uid"
-    nullable: true
-  - fieldName: "completed"
-    columnName: "completed"
-    nullable: true
-  - fieldName: "title"
-    columnName: "title"
-    nullable: true
-  - fieldName: "description"
-    columnName: "description"
-    nullable: true
-  - fieldName: "photo"
-    columnName: "photo"
-    nullable: true
-  migrations: []
-- tableName: "photos"
-  fields:
-  - fieldName: "albumId"
-    columnName: "albumId"
-    nullable: true
-  - fieldName: "title"
-    columnName: "title"
-    nullable: true
-  - fieldName: "url"
-    columnName: "url"
-    nullable: true
-  - fieldName: "thumbnailUrl"
-    columnName: "thumbnailUrl"
-    nullable: true
-  - fieldName: "post"
-    columnName: "post"
-    nullable: true
-  migrations: []
+  - tableName: "likes"
+    fields:
+      - fieldName: "uId"
+        columnName: "uId"
+        nullable: true
+      - fieldName: "post"
+        columnName: "post"
+        nullable: true
+    migrations: []
+  - tableName: "postComments"
+    fields:
+      - fieldName: "name"
+        columnName: "name"
+        nullable: true
+      - fieldName: "uId"
+        columnName: "uId"
+        nullable: true
+      - fieldName: "body"
+        columnName: "body"
+        nullable: true
+      - fieldName: "email"
+        columnName: "email"
+        nullable: true
+      - fieldName: "postCommentId"
+        columnName: "postCommentId"
+        nullable: true
+      - fieldName: "post"
+        columnName: "post"
+        nullable: true
+    migrations: []
+  - tableName: "posts"
+    fields:
+      - fieldName: "uId"
+        columnName: "uId"
+        nullable: true
+      - fieldName: "title"
+        columnName: "title"
+        nullable: true
+      - fieldName: "body"
+        columnName: "body"
+        nullable: true
+      - fieldName: "userId"
+        columnName: "userId"
+        nullable: true
+      - fieldName: "publishedDate"
+        columnName: "publishedDate"
+        nullable: true
+    migrations: []
+  - tableName: "todoes"
+    fields:
+      - fieldName: "uid"
+        columnName: "uid"
+        nullable: true
+      - fieldName: "completed"
+        columnName: "completed"
+        nullable: true
+      - fieldName: "title"
+        columnName: "title"
+        nullable: true
+      - fieldName: "timeStarted"
+        columnName: "timeStarted"
+        nullable: true
+      - fieldName: "description"
+        columnName: "description"
+        nullable: true
+      - fieldName: "photo"
+        columnName: "photo"
+        nullable: true
+    migrations: []
+  - tableName: "photos"
+    fields:
+      - fieldName: "albumId"
+        columnName: "albumId"
+        nullable: true
+      - fieldName: "title"
+        columnName: "title"
+        nullable: true
+      - fieldName: "url"
+        columnName: "url"
+        nullable: true
+      - fieldName: "thumbnailUrl"
+        columnName: "thumbnailUrl"
+        nullable: true
+      - fieldName: "post"
+        columnName: "post"
+        nullable: true
+    migrations: []
diff --git a/app/schemas/promise.base.AppDatabase/2.yml b/app/schemas/promise.base.AppDatabase/2.yml
new file mode 100644
index 0000000..38b5012
--- /dev/null
+++ b/app/schemas/promise.base.AppDatabase/2.yml
@@ -0,0 +1,98 @@
+---
+dbVersion: 2
+tableMetaData:
+  - tableName: "likes"
+    fields:
+      - fieldName: "uId"
+        columnName: "uId"
+        nullable: true
+      - fieldName: "post"
+        columnName: "post"
+        nullable: true
+    migrations: []
+  - tableName: "postComments"
+    fields:
+      - fieldName: "name"
+        columnName: "name"
+        nullable: true
+      - fieldName: "uId"
+        columnName: "uId"
+        nullable: true
+      - fieldName: "body"
+        columnName: "body"
+        nullable: true
+      - fieldName: "email"
+        columnName: "email"
+        nullable: true
+      - fieldName: "postCommentId"
+        columnName: "postCommentId"
+        nullable: true
+      - fieldName: "post"
+        columnName: "post"
+        nullable: true
+    migrations: []
+  - tableName: "posts"
+    fields:
+      - fieldName: "uId"
+        columnName: "uId"
+        nullable: true
+      - fieldName: "title"
+        columnName: "title"
+        nullable: true
+      - fieldName: "body"
+        columnName: "body"
+        nullable: true
+      - fieldName: "userId"
+        columnName: "userId"
+        nullable: true
+      - fieldName: "publishedDate"
+        columnName: "publishedDate"
+        nullable: true
+    migrations: []
+  - tableName: "todoes"
+    fields:
+      - fieldName: "uid"
+        columnName: "uid"
+        nullable: true
+      - fieldName: "completed"
+        columnName: "completed"
+        nullable: true
+      - fieldName: "title"
+        columnName: "title"
+        nullable: true
+      - fieldName: "timeStarted"
+        columnName: "timeStarted"
+        nullable: true
+      - fieldName: "timeFinished"
+        columnName: "timeFinished"
+        nullable: true
+      - fieldName: "description"
+        columnName: "description"
+        nullable: true
+      - fieldName: "photo"
+        columnName: "photo"
+        nullable: true
+    migrations:
+      - versionChange:
+          fromVersion: 1
+          toVersion: 2
+        field: "timeFinishedColumn"
+        action: "CREATE"
+  - tableName: "photos"
+    fields:
+      - fieldName: "albumId"
+        columnName: "albumId"
+        nullable: true
+      - fieldName: "title"
+        columnName: "title"
+        nullable: true
+      - fieldName: "url"
+        columnName: "url"
+        nullable: true
+      - fieldName: "thumbnailUrl"
+        columnName: "thumbnailUrl"
+        nullable: true
+      - fieldName: "post"
+        columnName: "post"
+        nullable: true
+    migrations: []
diff --git a/app/schemas/promise.base.AppDatabase/3.yml b/app/schemas/promise.base.AppDatabase/3.yml
new file mode 100644
index 0000000..3fbfdf3
--- /dev/null
+++ b/app/schemas/promise.base.AppDatabase/3.yml
@@ -0,0 +1,101 @@
+---
+dbVersion: 3
+tableMetaData:
+  - tableName: "likes"
+    fields:
+      - fieldName: "uId"
+        columnName: "uId"
+        nullable: true
+      - fieldName: "post"
+        columnName: "post"
+        nullable: true
+    migrations: []
+  - tableName: "postComments"
+    fields:
+      - fieldName: "name"
+        columnName: "name"
+        nullable: true
+      - fieldName: "uId"
+        columnName: "uId"
+        nullable: true
+      - fieldName: "body"
+        columnName: "body"
+        nullable: true
+      - fieldName: "email"
+        columnName: "email"
+        nullable: true
+      - fieldName: "postCommentId"
+        columnName: "postCommentId"
+        nullable: true
+      - fieldName: "post"
+        columnName: "post"
+        nullable: true
+    migrations: []
+  - tableName: "posts"
+    fields:
+      - fieldName: "uId"
+        columnName: "uId"
+        nullable: true
+      - fieldName: "title"
+        columnName: "title"
+        nullable: true
+      - fieldName: "body"
+        columnName: "body"
+        nullable: true
+      - fieldName: "userId"
+        columnName: "userId"
+        nullable: true
+      - fieldName: "numberOfViews"
+        columnName: "numberOfViews"
+        nullable: true
+      - fieldName: "publishedDate"
+        columnName: "publishedDate"
+        nullable: true
+    migrations:
+      - versionChange:
+          fromVersion: 2
+          toVersion: 3
+        field: "numberOfViewsColumn"
+        action: "CREATE"
+  - tableName: "todoes"
+    fields:
+      - fieldName: "uid"
+        columnName: "uid"
+        nullable: true
+      - fieldName: "completed"
+        columnName: "completed"
+        nullable: true
+      - fieldName: "title"
+        columnName: "title"
+        nullable: true
+      - fieldName: "timeStarted"
+        columnName: "timeStarted"
+        nullable: true
+      - fieldName: "timeFinished"
+        columnName: "timeFinished"
+        nullable: true
+      - fieldName: "description"
+        columnName: "description"
+        nullable: true
+      - fieldName: "photo"
+        columnName: "photo"
+        nullable: true
+    migrations: []
+  - tableName: "photos"
+    fields:
+      - fieldName: "albumId"
+        columnName: "albumId"
+        nullable: true
+      - fieldName: "title"
+        columnName: "title"
+        nullable: true
+      - fieldName: "url"
+        columnName: "url"
+        nullable: true
+      - fieldName: "thumbnailUrl"
+        columnName: "thumbnailUrl"
+        nullable: true
+      - fieldName: "post"
+        columnName: "post"
+        nullable: true
+    migrations: []
diff --git a/app/schemas/promise.base.AppDatabase/4.yml b/app/schemas/promise.base.AppDatabase/4.yml
new file mode 100644
index 0000000..e53a677
--- /dev/null
+++ b/app/schemas/promise.base.AppDatabase/4.yml
@@ -0,0 +1,109 @@
+---
+dbVersion: 4
+tableMetaData:
+  - tableName: "likes"
+    fields:
+      - fieldName: "uId"
+        columnName: "uId"
+        nullable: true
+      - fieldName: "post"
+        columnName: "post"
+        nullable: true
+    migrations: []
+  - tableName: "postComments"
+    fields:
+      - fieldName: "name"
+        columnName: "name"
+        nullable: true
+      - fieldName: "uId"
+        columnName: "uId"
+        nullable: true
+      - fieldName: "body"
+        columnName: "body"
+        nullable: true
+      - fieldName: "email"
+        columnName: "email"
+        nullable: true
+      - fieldName: "postCommentId"
+        columnName: "postCommentId"
+        nullable: true
+      - fieldName: "post"
+        columnName: "post"
+        nullable: true
+    migrations: []
+  - tableName: "posts"
+    fields:
+      - fieldName: "uId"
+        columnName: "uId"
+        nullable: true
+      - fieldName: "title"
+        columnName: "title"
+        nullable: true
+      - fieldName: "body"
+        columnName: "body"
+        nullable: true
+      - fieldName: "userId"
+        columnName: "userId"
+        nullable: true
+      - fieldName: "numberOfViews"
+        columnName: "numberOfViews"
+        nullable: true
+      - fieldName: "publishedDate"
+        columnName: "publishedDate"
+        nullable: true
+    migrations:
+      - versionChange:
+          fromVersion: 2
+          toVersion: 3
+        field: "numberOfViewsColumn"
+        action: "CREATE"
+  - tableName: "todoes"
+    fields:
+      - fieldName: "uid"
+        columnName: "uid"
+        nullable: true
+      - fieldName: "completed"
+        columnName: "completed"
+        nullable: true
+      - fieldName: "sentToServer"
+        columnName: "sentToServer"
+        nullable: true
+      - fieldName: "title"
+        columnName: "title"
+        nullable: true
+      - fieldName: "timeStarted"
+        columnName: "timeStarted"
+        nullable: true
+      - fieldName: "timeFinished"
+        columnName: "timeFinished"
+        nullable: true
+      - fieldName: "description"
+        columnName: "description"
+        nullable: true
+      - fieldName: "photo"
+        columnName: "photo"
+        nullable: true
+    migrations:
+      - versionChange:
+          fromVersion: 3
+          toVersion: 4
+        field: "sentToServerColumn"
+        action: "CREATE"
+  - tableName: "photos"
+    fields:
+      - fieldName: "albumId"
+        columnName: "albumId"
+        nullable: true
+      - fieldName: "title"
+        columnName: "title"
+        nullable: true
+      - fieldName: "url"
+        columnName: "url"
+        nullable: true
+      - fieldName: "thumbnailUrl"
+        columnName: "thumbnailUrl"
+        nullable: true
+      - fieldName: "post"
+        columnName: "post"
+        nullable: true
+    migrations: []
diff --git a/app/schemas/promise.base.AppDatabase/5.yml b/app/schemas/promise.base.AppDatabase/5.yml
new file mode 100644
index 0000000..9724130
--- /dev/null
+++ b/app/schemas/promise.base.AppDatabase/5.yml
@@ -0,0 +1,106 @@
+---
+dbVersion: 5
+tableMetaData:
+- tableName: "likes"
+  fields:
+  - fieldName: "uId"
+    columnName: "uId"
+    nullable: true
+  - fieldName: "post"
+    columnName: "post"
+    nullable: true
+  migrations: []
+- tableName: "postComments"
+  fields:
+  - fieldName: "name"
+    columnName: "name"
+    nullable: true
+  - fieldName: "uId"
+    columnName: "uId"
+    nullable: true
+  - fieldName: "body"
+    columnName: "body"
+    nullable: true
+  - fieldName: "email"
+    columnName: "email"
+    nullable: true
+  - fieldName: "postCommentId"
+    columnName: "postCommentId"
+    nullable: true
+  - fieldName: "post"
+    columnName: "post"
+    nullable: true
+  migrations: []
+- tableName: "posts"
+  fields:
+  - fieldName: "uId"
+    columnName: "uId"
+    nullable: true
+  - fieldName: "title"
+    columnName: "title"
+    nullable: true
+  - fieldName: "body"
+    columnName: "body"
+    nullable: true
+  - fieldName: "userId"
+    columnName: "userId"
+    nullable: true
+  - fieldName: "numberOfViews"
+    columnName: "numberOfViews"
+    nullable: true
+  - fieldName: "publishedDate"
+    columnName: "publishedDate"
+    nullable: true
+  migrations:
+  - versionChange:
+      fromVersion: 2
+      toVersion: 3
+    field: "numberOfViewsColumn"
+    action: "CREATE"
+- tableName: "todoes"
+  fields:
+  - fieldName: "uid"
+    columnName: "uid"
+    nullable: true
+  - fieldName: "completed"
+    columnName: "completed"
+    nullable: true
+  - fieldName: "title"
+    columnName: "title"
+    nullable: true
+  - fieldName: "timeStarted"
+    columnName: "timeStarted"
+    nullable: true
+  - fieldName: "timeFinished"
+    columnName: "timeFinished"
+    nullable: true
+  - fieldName: "description"
+    columnName: "description"
+    nullable: true
+  - fieldName: "photo"
+    columnName: "photo"
+    nullable: true
+  migrations:
+  - versionChange:
+      fromVersion: 4
+      toVersion: 5
+    field: "\"sentToServer\""
+    action: "DROP"
+- tableName: "photos"
+  fields:
+  - fieldName: "albumId"
+    columnName: "albumId"
+    nullable: true
+  - fieldName: "title"
+    columnName: "title"
+    nullable: true
+  - fieldName: "url"
+    columnName: "url"
+    nullable: true
+  - fieldName: "thumbnailUrl"
+    columnName: "thumbnailUrl"
+    nullable: true
+  - fieldName: "post"
+    columnName: "post"
+    nullable: true
+  migrations: []
diff --git a/app/src/main/java/promise/base/AppDatabase.kt b/app/src/main/java/promise/base/AppDatabase.kt
index a5ab05d..73e8a57 100644
--- a/app/src/main/java/promise/base/AppDatabase.kt
+++ b/app/src/main/java/promise/base/AppDatabase.kt
@@ -19,9 +19,11 @@ import promise.base.comment.PostCommentDao
 import promise.base.photo.Photo
 import promise.base.post.Post
 import promise.base.todo.Todo
+import promise.commons.data.log.LogUtil
 import promise.database.DatabaseEntity
 import promise.db.FastDatabase
 import promise.db.PromiseDatabase
+import promise.utils.Visitor
 
 @DatabaseEntity(
     persistableEntities = [
@@ -35,5 +37,20 @@ import promise.db.PromiseDatabase
 abstract class AppDatabase(fastDatabase: FastDatabase)
   : PromiseDatabase(fastDatabase) {
 
+  init {
+    fastDatabase.accept(object : Visitor<FastDatabase, Unit> {
+      override fun visit(t: FastDatabase) {
+        t.setErrorHandler {
+          LogUtil.e(TAG, "database error: ${it.path}")
+        }
+        t.fallBackToDestructiveMigration()
+      }
+    })
+  }
+
   abstract fun getPostCommentsDao(): PostCommentDao
+
+  companion object {
+    val TAG: String = LogUtil.makeTag(AppDatabase::class.java)
+  }
 }
diff --git a/app/src/main/java/promise/base/AppTypeConverter.kt b/app/src/main/java/promise/base/AppTypeConverter.kt
index 190200b..3b5f5c7 100644
--- a/app/src/main/java/promise/base/AppTypeConverter.kt
+++ b/app/src/main/java/promise/base/AppTypeConverter.kt
@@ -12,6 +12,7 @@
  */
 
 package promise.base
+
 import promise.database.TypeConverter
 import java.util.*
 
diff --git a/app/src/main/java/promise/base/ID.kt b/app/src/main/java/promise/base/ID.kt
index 59ce5f4..4a106d3 100644
--- a/app/src/main/java/promise/base/ID.kt
+++ b/app/src/main/java/promise/base/ID.kt
@@ -13,7 +13,4 @@
 
 package promise.base
 
-import android.os.Parcel
-import android.os.Parcelable
-
 data class ID(val id: String)
diff --git a/app/src/main/java/promise/base/comment/Like.java b/app/src/main/java/promise/base/comment/Like.java
index 5c87946..ab6b8a9 100644
--- a/app/src/main/java/promise/base/comment/Like.java
+++ b/app/src/main/java/promise/base/comment/Like.java
@@ -14,10 +14,11 @@
 package promise.base.comment;
 
 import android.annotation.SuppressLint;
+
 import org.jetbrains.annotations.NotNull;
+
 import promise.base.ID;
 import promise.base.post.Post;
-import promise.database.AddedEntity;
 import promise.database.Entity;
 import promise.database.HasOne;
 import promise.db.ActiveRecord;
@@ -26,39 +27,39 @@
 @Entity
 //@AddedEntity(fromVersion = 1, toVersion = 2)
 public class Like extends ActiveRecord<Like> {
-	private ID uId;
+  private ID uId;
 
-	@HasOne
-	private Post post;
+  @HasOne
+  private Post post;
 
-	@Override
- 	public String toString(){
-		return 
-			"Comment{" +
-			",id = '" + uId + '\'' +
+  @Override
+  public String toString() {
+    return
+        "Comment{" +
+            ",id = '" + uId + '\'' +
 
-			"}";
-		}
+            "}";
+  }
 
-	@NotNull
-	@Override
-	public Like getEntity() {
-		return this;
-	}
+  @NotNull
+  @Override
+  public Like getEntity() {
+    return this;
+  }
 
-	public ID getUId() {
-		return uId;
-	}
+  public ID getUId() {
+    return uId;
+  }
 
-	public void setUId(ID uId) {
-		this.uId = uId;
-	}
+  public void setUId(ID uId) {
+    this.uId = uId;
+  }
 
-	public void setPost(Post post) {
-		this.post = post;
-	}
+  public Post getPost() {
+    return post;
+  }
 
-	public Post getPost() {
-		return post;
-	}
+  public void setPost(Post post) {
+    this.post = post;
+  }
 }
diff --git a/app/src/main/java/promise/base/comment/PostComment.java b/app/src/main/java/promise/base/comment/PostComment.java
index b3bb08c..8c616dd 100644
--- a/app/src/main/java/promise/base/comment/PostComment.java
+++ b/app/src/main/java/promise/base/comment/PostComment.java
@@ -6,87 +6,85 @@
 
 import promise.base.ID;
 import promise.base.post.Post;
-import promise.database.Migrate;
-import promise.database.MigrationOptions;
-import promise.db.ActiveRecord;
 import promise.database.Entity;
 import promise.database.HasOne;
+import promise.db.ActiveRecord;
 
 @SuppressLint("ParcelCreator")
 @Entity
 public class PostComment extends ActiveRecord<PostComment> {
-	private String name;
-	private ID uId;
-	private String body;
-	private String email;
-
-	private String postCommentId = "";
-
-	@HasOne
-	private Post post;
-
-	public void setName(String name){
-		this.name = name;
-	}
-
-	public String getName(){
-		return name;
-	}
-
-	public void setBody(String body){
-		this.body = body;
-	}
-
-	public String getBody(){
-		return body;
-	}
-
-	public void setEmail(String email){
-		this.email = email;
-	}
-
-	public String getEmail(){
-		return email;
-	}
-
-	public Post getPost() {
-		return post;
-	}
-
-	public void setPost(Post post) {
-		this.post = post;
-	}
-
-	public String getPostCommentId() {
-		return postCommentId;
-	}
-
-	public void setPostCommentId(String postCommentId) {
-		this.postCommentId = postCommentId;
-	}
-
-	@Override
- 	public String toString(){
-		return 
-			"Comment{" + 
-			"name = '" + name + '\'' +
-			",id = '" + uId + '\'' +
-			",body = '" + body + '\'' + 
-			",email = '" + email + '\'' + 
-			"}";
-		}
-
-	@NotNull
-	@Override
-	public PostComment getEntity() {
-		return this;
-	}
-
-	public ID getUId() {
-		return uId;
-	}
-
-	public void setUId(ID uId) {
-		this.uId = uId;
-	}
+  private String name;
+  private ID uId;
+  private String body;
+  private String email;
+
+  private String postCommentId = "";
+
+  @HasOne
+  private Post post;
+
+  public String getName() {
+    return name;
+  }
+
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  public String getBody() {
+    return body;
+  }
+
+  public void setBody(String body) {
+    this.body = body;
+  }
+
+  public String getEmail() {
+    return email;
+  }
+
+  public void setEmail(String email) {
+    this.email = email;
+  }
+
+  public Post getPost() {
+    return post;
+  }
+
+  public void setPost(Post post) {
+    this.post = post;
+  }
+
+  public String getPostCommentId() {
+    return postCommentId;
+  }
+
+  public void setPostCommentId(String postCommentId) {
+    this.postCommentId = postCommentId;
+  }
+
+  @Override
+  public String toString() {
+    return
+        "Comment{" +
+            "name = '" + name + '\'' +
+            ",id = '" + uId + '\'' +
+            ",body = '" + body + '\'' +
+            ",email = '" + email + '\'' +
+            "}";
+  }
+
+  @NotNull
+  @Override
+  public PostComment getEntity() {
+    return this;
+  }
+
+  public ID getUId() {
+    return uId;
+  }
+
+  public void setUId(ID uId) {
+    this.uId = uId;
+  }
 }
diff --git a/app/src/main/java/promise/base/comment/PostCommentToReplyRelation.java b/app/src/main/java/promise/base/comment/PostCommentToReplyRelation.java
index 8061977..307f599 100644
--- a/app/src/main/java/promise/base/comment/PostCommentToReplyRelation.java
+++ b/app/src/main/java/promise/base/comment/PostCommentToReplyRelation.java
@@ -16,8 +16,8 @@
 import java.util.List;
 
 import promise.database.Child;
-import promise.database.Relation;
 import promise.database.Parent;
+import promise.database.Relation;
 
 @Relation
 public class PostCommentToReplyRelation {
diff --git a/app/src/main/java/promise/base/photo/Photo.kt b/app/src/main/java/promise/base/photo/Photo.kt
index 34c0adf..60b0703 100644
--- a/app/src/main/java/promise/base/photo/Photo.kt
+++ b/app/src/main/java/promise/base/photo/Photo.kt
@@ -2,22 +2,23 @@ package promise.base.photo
 
 import android.annotation.SuppressLint
 import promise.base.post.Post
-import promise.db.ActiveRecord
 import promise.database.Entity
 import promise.database.HasOne
+import promise.db.ActiveRecord
 
 @SuppressLint("ParcelCreator")
 @Entity
-class Photo: ActiveRecord<Photo>() {
-	var albumId: Int? = null
-	var title: String? = null
-	var url: String? = null
-	var thumbnailUrl: String? = null
-	@HasOne var post: Post? = null
+class Photo : ActiveRecord<Photo>() {
+  var albumId: Int? = null
+  var title: String? = null
+  var url: String? = null
+  var thumbnailUrl: String? = null
+  @HasOne
+  var post: Post? = null
 
-	override fun getEntity(): Photo {
-		return this
-	}
+  override fun getEntity(): Photo {
+    return this
+  }
 
 }
 
diff --git a/app/src/main/java/promise/base/post/Post.java b/app/src/main/java/promise/base/post/Post.java
index 974621a..dc81b28 100644
--- a/app/src/main/java/promise/base/post/Post.java
+++ b/app/src/main/java/promise/base/post/Post.java
@@ -13,117 +13,123 @@
 import promise.base.comment.Like;
 import promise.base.comment.PostComment;
 import promise.base.photo.Photo;
-import promise.db.ActiveRecord;
 import promise.database.Entity;
 import promise.database.HasMany;
+import promise.db.ActiveRecord;
 
 @SuppressLint("ParcelCreator")
 @Entity
 public class Post extends ActiveRecord<Post> {
-	private ID uId;
-	private String title;
-	private String body;
-	private int userId;
-
-	private Date publishedDate;
-
-	@NonNull
-	@Override
-	public String toString() {
-		return "Post{" +
-				"uId=" + uId +
-				", title='" + title + '\'' +
-				", body='" + body + '\'' +
-				", userId=" + userId +
-				", comments=" + comments +
-				", photos=" + photos +
-				'}';
-	}
-
-	@HasMany
-	private List<PostComment> comments;
-
-	@HasMany
-	private List<Photo> photos;
-
-	@HasMany
-	private List<Like> likes;
-
-	public String getTitle(){
-		return title;
-	}
-
-	public String getBody(){
-		return body;
-	}
-
-	public int getUserId(){
-		return userId;
-	}
-
-	public ID getUId() {
-		return uId;
-	}
-
-	public void setUId(ID uId) {
-		this.uId = uId;
-	}
-
-	public void setTitle(String title) {
-		this.title = title;
-	}
-
-	public void setBody(String body) {
-		this.body = body;
-	}
-
-	public void setUserId(int userId) {
-		this.userId = userId;
-	}
-
-	public ID getuId() {
-		return uId;
-	}
-
-	public void setuId(ID uId) {
-		this.uId = uId;
-	}
-
-	public List<PostComment> getComments() {
-		return comments;
-	}
-
-	public void setComments(List<PostComment> comments) {
-		this.comments = comments;
-	}
-
-	public List<Photo> getPhotos() {
-		return photos;
-	}
-
-	public void setPhotos(List<Photo> photos) {
-		this.photos = photos;
-	}
-
-	public List<Like> getLikes() {
-		return likes;
-	}
-
-	public void setLikes(List<Like> likes) {
-		this.likes = likes;
-	}
-
-	@NotNull
-	@Override
-	public Post getEntity() {
-		return this;
-	}
-
-	public Date getPublishedDate() {
-		return publishedDate;
-	}
-
-	public void setPublishedDate(Date publishedDate) {
-		this.publishedDate = publishedDate;
-	}
+  private ID uId;
+  private String title;
+  private String body;
+  private int userId;
+
+  private int numberOfViews;
+  private Date publishedDate;
+  @HasMany
+  private List<PostComment> comments;
+  @HasMany
+  private List<Photo> photos;
+  @HasMany
+  private List<Like> likes;
+
+  public int getNumberOfViews() {
+    return numberOfViews;
+  }
+
+  public void setNumberOfViews(int numberOfViews) {
+    this.numberOfViews = numberOfViews;
+  }
+
+  @NonNull
+  @Override
+  public String toString() {
+    return "Post{" +
+        "uId=" + uId +
+        ", title='" + title + '\'' +
+        ", body='" + body + '\'' +
+        ", userId=" + userId +
+        ", comments=" + comments +
+        ", photos=" + photos +
+        '}';
+  }
+
+  public String getTitle() {
+    return title;
+  }
+
+  public void setTitle(String title) {
+    this.title = title;
+  }
+
+  public String getBody() {
+    return body;
+  }
+
+  public void setBody(String body) {
+    this.body = body;
+  }
+
+  public int getUserId() {
+    return userId;
+  }
+
+  public void setUserId(int userId) {
+    this.userId = userId;
+  }
+
+  public ID getUId() {
+    return uId;
+  }
+
+  public void setUId(ID uId) {
+    this.uId = uId;
+  }
+
+  public ID getuId() {
+    return uId;
+  }
+
+  public void setuId(ID uId) {
+    this.uId = uId;
+  }
+
+  public List<PostComment> getComments() {
+    return comments;
+  }
+
+  public void setComments(List<PostComment> comments) {
+    this.comments = comments;
+  }
+
+  public List<Photo> getPhotos() {
+    return photos;
+  }
+
+  public void setPhotos(List<Photo> photos) {
+    this.photos = photos;
+  }
+
+  public List<Like> getLikes() {
+    return likes;
+  }
+
+  public void setLikes(List<Like> likes) {
+    this.likes = likes;
+  }
+
+  @NotNull
+  @Override
+  public Post getEntity() {
+    return this;
+  }
+
+  public Date getPublishedDate() {
+    return publishedDate;
+  }
+
+  public void setPublishedDate(Date publishedDate) {
+    this.publishedDate = publishedDate;
+  }
 }
diff --git a/app/src/main/java/promise/base/post/PostRepository.kt b/app/src/main/java/promise/base/post/PostRepository.kt
index 8fbb41d..594b9fe 100644
--- a/app/src/main/java/promise/base/post/PostRepository.kt
+++ b/app/src/main/java/promise/base/post/PostRepository.kt
@@ -58,8 +58,9 @@ class PostRepositoryImpl @Inject constructor(
   }
 
   override fun getPosts(): List<Post> = postRelationsDao.listWithComments()
+
   override fun deletePosts() {
-    val persons = postRelationsDao.listWithComments()
+    val persons = getPosts()
     persons.forEach {
       postRelationsDao.deleteComments(it)
       it.delete()
diff --git a/app/src/main/java/promise/base/todo/Todo.java b/app/src/main/java/promise/base/todo/Todo.java
index f41dddc..5886ae4 100644
--- a/app/src/main/java/promise/base/todo/Todo.java
+++ b/app/src/main/java/promise/base/todo/Todo.java
@@ -5,75 +5,93 @@
 import org.jetbrains.annotations.NotNull;
 
 import promise.base.photo.Photo;
-import promise.db.ActiveRecord;
 import promise.database.Entity;
 import promise.database.HasOne;
+import promise.db.ActiveRecord;
 
 @SuppressLint("ParcelCreator")
 @Entity
 public class Todo extends ActiveRecord<Todo> {
-	private int uid;
-	private boolean completed;
-	private String title;
-
-	private String description;
-
-	@HasOne
-	private Photo photo;
-
-	public int getUid() {
-		return uid;
-	}
-
-	public void setUid(int uid) {
-		this.uid = uid;
-	}
-
-	public Photo getPhoto() {
-		return photo;
-	}
-
-	public void setPhoto(Photo photo) {
-		this.photo = photo;
-	}
-
-	public void setCompleted(boolean completed){
-		this.completed = completed;
-	}
-
-	public boolean isCompleted(){
-		return completed;
-	}
-
-	public void setTitle(String title){
-		this.title = title;
-	}
-
-	public String getTitle(){
-		return title;
-	}
-
-	public String getDescription() {
-		return description;
-	}
-
-	public void setDescription(String description) {
-		this.description = description;
-	}
-
-	@Override
- 	public String toString(){
-		return 
-			"Todo{" + 
-			"id = '" + uid + '\'' +
-			",completed = '" + completed + '\'' + 
-			",title = '" + title + '\'' +
-			"}";
-		}
-
-	@NotNull
-	@Override
-	public Todo getEntity() {
-		return this;
-	}
+  private int uid;
+  private boolean completed;
+
+  private String title;
+
+  private long timeStarted;
+  private long timeFinished;
+  private String description;
+  @HasOne
+  private Photo photo;
+
+  public long getTimeFinished() {
+    return timeFinished;
+  }
+
+  public void setTimeFinished(long timeFinished) {
+    this.timeFinished = timeFinished;
+  }
+
+  public long getTimeStarted() {
+    return timeStarted;
+  }
+
+  public void setTimeStarted(long timeStarted) {
+    this.timeStarted = timeStarted;
+  }
+
+  public int getUid() {
+    return uid;
+  }
+
+  public void setUid(int uid) {
+    this.uid = uid;
+  }
+
+  public Photo getPhoto() {
+    return photo;
+  }
+
+  public void setPhoto(Photo photo) {
+    this.photo = photo;
+  }
+
+  public boolean isCompleted() {
+    return completed;
+  }
+
+  public void setCompleted(boolean completed) {
+    this.completed = completed;
+  }
+
+  public String getTitle() {
+    return title;
+  }
+
+  public void setTitle(String title) {
+    this.title = title;
+  }
+
+  public String getDescription() {
+    return description;
+  }
+
+  public void setDescription(String description) {
+    this.description = description;
+  }
+
+  @Override
+  public String toString() {
+    return
+        "Todo{" +
+            "id = '" + uid + '\'' +
+            ",completed = '" + completed + '\'' +
+            ",title = '" + title + '\'' +
+            "}";
+  }
+
+  @NotNull
+  @Override
+  public Todo getEntity() {
+    return this;
+  }
 }
diff --git a/app/src/main/java/promise/dbapp/ActivityBuildersModule.kt b/app/src/main/java/promise/dbapp/ActivityBuildersModule.kt
index 747e490..fd9ece4 100644
--- a/app/src/main/java/promise/dbapp/ActivityBuildersModule.kt
+++ b/app/src/main/java/promise/dbapp/ActivityBuildersModule.kt
@@ -18,7 +18,7 @@ import dagger.android.ContributesAndroidInjector
 
 @Module
 abstract class ActivityBuildersModule {
-  @ContributesAndroidInjector (
+  @ContributesAndroidInjector(
       modules = [
         ReposModule::class
       ]
diff --git a/app/src/main/java/promise/dbapp/AppComponent.kt b/app/src/main/java/promise/dbapp/AppComponent.kt
index 3cd63cf..4c8637c 100644
--- a/app/src/main/java/promise/dbapp/AppComponent.kt
+++ b/app/src/main/java/promise/dbapp/AppComponent.kt
@@ -17,8 +17,6 @@ import dagger.BindsInstance
 import dagger.Component
 import dagger.android.AndroidInjector
 import dagger.android.support.AndroidSupportInjectionModule
-import promise.base.post.PostRelationsDao
-import promise.base.post.PostsTable
 import javax.inject.Singleton
 
 @Component(
@@ -31,7 +29,7 @@ import javax.inject.Singleton
 @Singleton
 interface AppComponent : AndroidInjector<App> {
 
-//  fun postsTable(): PostsTable
+  //  fun postsTable(): PostsTable
 //  fun postRelationsDao(): PostRelationsDao
   @Component.Builder
   interface Builder {
diff --git a/app/src/main/java/promise/dbapp/DatabaseDependencies.kt b/app/src/main/java/promise/dbapp/DatabaseDependencies.kt
index e866ae7..3c8492f 100644
--- a/app/src/main/java/promise/dbapp/DatabaseDependencies.kt
+++ b/app/src/main/java/promise/dbapp/DatabaseDependencies.kt
@@ -23,18 +23,19 @@ import javax.inject.Singleton
 @Module
 object DatabaseDependencies {
 
- @Provides
- @Singleton
- @JvmStatic
- fun provideAppDatabase(): AppDatabaseImpl = AppDatabaseImpl.createDatabase("blog_db")
+  @Provides
+  @Singleton
+  @JvmStatic
+  fun provideAppDatabase(): AppDatabaseImpl = AppDatabaseImpl.createDatabase("blog_db")
 
- @Provides
- @JvmStatic
- fun providePostRelationsDao(appDatabase: AppDatabaseImpl): PostRelationsDao =
-     appDatabase.postRelationsDao
- @Provides
- @JvmStatic
- fun providePostTable(appDatabase: AppDatabaseImpl): PostsTable =
-     appDatabase.postsTable
+  @Provides
+  @JvmStatic
+  fun providePostRelationsDao(appDatabase: AppDatabaseImpl): PostRelationsDao =
+      appDatabase.postRelationsDao
+
+  @Provides
+  @JvmStatic
+  fun providePostTable(appDatabase: AppDatabaseImpl): PostsTable =
+      appDatabase.postsTable
 
 }
\ No newline at end of file
diff --git a/app/src/main/java/promise/dbapp/test/PostCommentsDaoImpl.java b/app/src/main/java/promise/dbapp/test/PostCommentsDaoImpl.java
index b450eda..2c4ea97 100644
--- a/app/src/main/java/promise/dbapp/test/PostCommentsDaoImpl.java
+++ b/app/src/main/java/promise/dbapp/test/PostCommentsDaoImpl.java
@@ -27,8 +27,7 @@
 import promise.model.IdentifiableList;
 
 public class PostCommentsDaoImpl
-    implements PostCommentDao
-{
+    implements PostCommentDao {
 
   private PromiseDatabase promiseDatabase;
 
diff --git a/app/src/main/res/layout/content_main.xml b/app/src/main/res/layout/content_main.xml
index d11903e..5234446 100644
--- a/app/src/main/res/layout/content_main.xml
+++ b/app/src/main/res/layout/content_main.xml
@@ -11,8 +11,7 @@
   ~ limitations under the License.
   -->
 
-<ScrollView
-    xmlns:android="http://schemas.android.com/apk/res/android"
+<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
     xmlns:tools="http://schemas.android.com/tools"
     android:layout_width="match_parent"
@@ -20,16 +19,18 @@
     app:layout_behavior="@string/appbar_scrolling_view_behavior"
     tools:context=".MainActivity"
     tools:showIn="@layout/activity_main">
+
     <androidx.appcompat.widget.LinearLayoutCompat
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
         android:orientation="vertical">
+
         <TextView
             android:id="@+id/complex_values_textview"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
-            android:text="Hello World!"
-            />
+            android:text="Hello World!" />
+
         <Button
             android:id="@+id/clear_button"
             android:layout_width="match_parent"
diff --git a/compiler/build.gradle b/compiler/build.gradle
index 3ad1290..7af5e55 100644
--- a/compiler/build.gradle
+++ b/compiler/build.gradle
@@ -27,7 +27,7 @@ dependencies {
     implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:2.9.0'
     implementation 'com.fasterxml.jackson.core:jackson-databind:2.9.0'
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
-    implementation'org.atteo:evo-inflector:1.0.1'
+    implementation 'org.atteo:evo-inflector:1.0.1'
     implementation 'com.squareup:javapoet:1.13.0'
     implementation "org.jetbrains.kotlin:kotlin-reflect:1.3.72"
     implementation 'com.google.auto:auto-common:0.10'
diff --git a/compiler/src/main/java/promise/database/compiler/DAOAnnotatedProcessor.kt b/compiler/src/main/java/promise/database/compiler/DAOAnnotatedProcessor.kt
index 6b48662..dd88761 100644
--- a/compiler/src/main/java/promise/database/compiler/DAOAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/database/compiler/DAOAnnotatedProcessor.kt
@@ -13,7 +13,9 @@
 
 package promise.database.compiler
 
+import com.google.auto.common.MoreElements
 import com.google.auto.common.MoreTypes
+import com.google.common.util.concurrent.MoreExecutors
 import com.squareup.javapoet.AnnotationSpec
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
@@ -30,6 +32,7 @@ import promise.database.Relation
 import promise.database.compiler.utils.JavaUtils
 import promise.database.compiler.utils.LogUtil
 import promise.database.compiler.utils.asTableClassName
+import promise.database.compiler.utils.asTypeElement
 import promise.database.compiler.utils.camelCase
 import promise.database.compiler.utils.toTypeName
 import javax.annotation.processing.ProcessingEnvironment
@@ -38,6 +41,7 @@ import javax.lang.model.element.Element
 import javax.lang.model.element.ElementKind
 import javax.lang.model.element.Modifier
 import javax.lang.model.element.TypeElement
+import javax.lang.model.element.TypeParameterElement
 import javax.lang.model.element.VariableElement
 import javax.lang.model.util.ElementFilter
 
@@ -104,24 +108,23 @@ class DAOAnnotatedProcessor(private val processingEnv: ProcessingEnvironment) :
       classBuilder.addMethod(MethodSpec.overriding(executableElement)
           .addCode("return null;").build())
       var relationType: Element?
-      if (MoreTypes.isType(executableElement.returnType) &&
-          MoreTypes.isTypeOf(Collection::class.java, executableElement.returnType)) {
-        val typeMirrors =
-            JavaUtils.getParameterizedTypeMirrors(MoreTypes.asDeclared(executableElement.returnType) as VariableElement)
-
-        val typeMirror = typeMirrors[0]
-        relationType = processingEnv.typeUtils.asElement(typeMirror)
-        LogUtil.n(Exception("Return type is collection: ${relationType}"))
-        //generateGetRelationMethod(classBuilder, relationType)
-      }
-
-      else {
-        relationType = processingEnv.typeUtils.asElement(executableElement.returnType)
-        LogUtil.n(Exception("Return type is : ${relationType}"))
-        //generateGetRelationMethod(classBuilder, relationType)
-      }
-
-      if (relationType == null) throw IllegalStateException("Failed to determine relation class")
+//      val ssElement = executableElement.enclosingElement
+//      if (ssElement is TypeParameterElement) {
+//
+//      }
+//      if (JavaUtils.isCollectionType(processingEnv, ssElement)) {
+//        val typeMirrors =
+//            JavaUtils.getParameterizedTypeMirrors(ssElement)
+//        val typeMirror = typeMirrors[0]
+//        relationType = processingEnv.typeUtils.asElement(typeMirror)
+//        LogUtil.n(Exception("Return type is collection: ${relationType}"))
+//      } else {
+//        relationType = processingEnv.typeUtils.asElement(executableElement.returnType)
+//        LogUtil.n(Exception("Return type is : ${relationType}"))
+//        //generateGetRelationMethod(classBuilder, relationType)
+//      }
+
+      //if (relationType == null) throw IllegalStateException("Failed to determine relation class")
 
 //      classBuilder.addMethod(MethodSpec.methodBuilder("get${relationType.simpleName}Impl")
 //          .addParameter(ClassName.get("android.database", "Cursor"), "cursor")
diff --git a/compiler/src/main/java/promise/database/compiler/DatabaseAbstractMethodsGenerator.kt b/compiler/src/main/java/promise/database/compiler/DatabaseAbstractMethodsGenerator.kt
index 632a4ef..91c0ea4 100644
--- a/compiler/src/main/java/promise/database/compiler/DatabaseAbstractMethodsGenerator.kt
+++ b/compiler/src/main/java/promise/database/compiler/DatabaseAbstractMethodsGenerator.kt
@@ -88,7 +88,8 @@ class DatabaseAbstractMethodsGenerator(
             ),
             ParameterizedTypeName.get(
                 ClassName.get("promise.db", "FastTable"),
-                TypeVariableName.get("T"))))
+                TypeVariableName.get("T"))
+        ))
         .addCode(codeBlock.build())
         .build())
 
diff --git a/compiler/src/main/java/promise/database/compiler/DatabaseAnnotationGenerator.kt b/compiler/src/main/java/promise/database/compiler/DatabaseAnnotationGenerator.kt
index b5a1b0c..d9b4904 100644
--- a/compiler/src/main/java/promise/database/compiler/DatabaseAnnotationGenerator.kt
+++ b/compiler/src/main/java/promise/database/compiler/DatabaseAnnotationGenerator.kt
@@ -17,8 +17,8 @@ import com.squareup.javapoet.AnnotationSpec
 import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.CodeBlock
 import promise.database.compiler.utils.LogUtil
-import promise.database.compiler.utils.getTableClassNameString
 import promise.database.compiler.utils.getDatabaseVersion
+import promise.database.compiler.utils.getTableClassNameString
 import promise.database.compiler.utils.getTableEntities
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.Element
@@ -35,7 +35,8 @@ class DatabaseAnnotationGenerator(
       var entities: Array<TypeElement>? = null
       try {
         entities = element.getTableEntities(processingEnv)
-      } catch (e: Throwable) { LogUtil.e(e)
+      } catch (e: Throwable) {
+        LogUtil.e(e)
       }
       val generatedVersion = TableMetaDataWriter.finalMaxDbVersion()
       val version = max(element.getDatabaseVersion(), generatedVersion)
diff --git a/compiler/src/main/java/promise/database/compiler/DatabaseEntityAnnotatedProcessor.kt b/compiler/src/main/java/promise/database/compiler/DatabaseEntityAnnotatedProcessor.kt
index afe6b3b..b08971f 100644
--- a/compiler/src/main/java/promise/database/compiler/DatabaseEntityAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/database/compiler/DatabaseEntityAnnotatedProcessor.kt
@@ -28,7 +28,6 @@ import javax.annotation.processing.RoundEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
 import javax.lang.model.element.TypeElement
-import javax.tools.Diagnostic
 
 class DatabaseEntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment,
                                        private val database: TypeElement) : AnnotatedClassProcessor() {
diff --git a/compiler/src/main/java/promise/database/compiler/DatabaseMetaDataWriter.kt b/compiler/src/main/java/promise/database/compiler/DatabaseMetaDataWriter.kt
index c508d8a..ce119a4 100644
--- a/compiler/src/main/java/promise/database/compiler/DatabaseMetaDataWriter.kt
+++ b/compiler/src/main/java/promise/database/compiler/DatabaseMetaDataWriter.kt
@@ -13,7 +13,6 @@
 
 package promise.database.compiler
 
-import com.fasterxml.jackson.annotation.JsonInclude
 import com.fasterxml.jackson.core.JsonProcessingException
 import com.fasterxml.jackson.databind.ObjectMapper
 import com.fasterxml.jackson.dataformat.yaml.YAMLFactory
@@ -35,27 +34,31 @@ class DatabaseMetaDataWriter
   init {
     val dir = File(schemasPath)
     dir.parentFile.mkdirs()
-   dir.mkdirs()
+    dir.mkdirs()
   }
 
   var currentDatabaseMetaData: DatabaseMetaData? = null
 
+  @Suppress("RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS")
   fun loadCurrentMetaData() = try {
     val file = File(schemasPath)
     if (file.exists() && file.isDirectory) {
-     val files = file.listFiles()
+      var files = file.listFiles { pathname -> pathname.isFile && pathname.name.endsWith(".yml") }
+          .toList()
       if (files.isNotEmpty()) {
-        files.sortBy { it.name }
-        val currentFile = files.last()
+        val currentFile: File
+        if (files.size == 1) currentFile = files[0] else {
+          files = files.sortedWith(Comparator<File> { o1, o2 -> o1.name.compareTo(o2.name) })
+          currentFile = files.last()
+        }
+        //LogUtil.n("Current file: ${currentFile.name}")
         val om = ObjectMapper(YAMLFactory())
         //xmlMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
         val fileWriter = FileReader(currentFile)
-        currentDatabaseMetaData = om.readValue(fileWriter,  DatabaseMetaData::class.java)
+        currentDatabaseMetaData = om.readValue(fileWriter, DatabaseMetaData::class.java)
         fileWriter.close()
-      }
-      else currentDatabaseMetaData = DatabaseMetaData()
-    }
-    else currentDatabaseMetaData = DatabaseMetaData()
+      } else currentDatabaseMetaData = DatabaseMetaData()
+    } else currentDatabaseMetaData = DatabaseMetaData()
   } catch (e: JsonProcessingException) {
     LogUtil.e(e)
   } catch (e: IOException) {
diff --git a/compiler/src/main/java/promise/database/compiler/EntityAnnotatedProcessor.kt b/compiler/src/main/java/promise/database/compiler/EntityAnnotatedProcessor.kt
index 00a197b..3593166 100644
--- a/compiler/src/main/java/promise/database/compiler/EntityAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/database/compiler/EntityAnnotatedProcessor.kt
@@ -45,7 +45,7 @@ class EntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment,
     environment?.getElementsAnnotatedWith(Entity::class.java)
         ?.forEach { element ->
           val identifiableInterface = processingEnv.elementUtils.getTypeElement("promise.commons.model.Identifiable")
-          val declaredInterface =JavaUtils.toWildCardType(processingEnv, identifiableInterface, 1)
+          val declaredInterface = JavaUtils.toWildCardType(processingEnv, identifiableInterface, 1)
           if (!JavaUtils.isSubTypeOfDeclaredType(processingEnv, element as TypeElement, declaredInterface))
             LogUtil.e(Exception("The Entity class ${element.simpleName} must implement Identifiable"), element)
           else javaFiles.add(processAnnotation(element))
@@ -84,7 +84,7 @@ class EntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment,
     classBuilder.addAnnotation(tableAnnotationSpec)
 
     val activeRecordType = processingEnv.elementUtils.getTypeElement("promise.db.ActiveRecord")
-    val declaredActiveRecordType =JavaUtils.toWildCardType(processingEnv, activeRecordType, 1)
+    val declaredActiveRecordType = JavaUtils.toWildCardType(processingEnv, activeRecordType, 1)
 
     if (JavaUtils.isSubTypeOfDeclaredType(processingEnv, (element as TypeElement), declaredActiveRecordType))
       classBuilder.addMethod(MethodSpec.methodBuilder("createEntityInstance")
diff --git a/compiler/src/main/java/promise/database/compiler/PromiseDatabaseCompiler.kt b/compiler/src/main/java/promise/database/compiler/PromiseDatabaseCompiler.kt
index 761f1d8..44d80dc 100644
--- a/compiler/src/main/java/promise/database/compiler/PromiseDatabaseCompiler.kt
+++ b/compiler/src/main/java/promise/database/compiler/PromiseDatabaseCompiler.kt
@@ -18,7 +18,6 @@ import com.squareup.javapoet.JavaFile
 import promise.database.DAO
 import promise.database.DatabaseEntity
 import promise.database.Entity
-import promise.database.Relation
 import promise.database.TypeConverter
 import promise.database.compiler.utils.JavaUtils
 import promise.database.compiler.utils.LogUtil
@@ -83,7 +82,7 @@ class PromiseDatabaseCompiler : AbstractProcessor() {
       processors.add(TypeConverterAnnotatedProcessor(processingEnv))
       processors.add(EntityAnnotatedProcessor(processingEnv, database!!))
       processors.add(RelationsDaoProcessor(processingEnv))
-      processors.add(DAOAnnotatedProcessor(processingEnv))
+      //processors.add(DAOAnnotatedProcessor(processingEnv))
       processors.add(DatabaseEntityAnnotatedProcessor(processingEnv, database))
       processors.forEach {
         val builders = it.process(environment)
diff --git a/compiler/src/main/java/promise/database/compiler/RelationsDaoGenerator.java b/compiler/src/main/java/promise/database/compiler/RelationsDaoGenerator.java
index 4fb3c74..6d851fa 100644
--- a/compiler/src/main/java/promise/database/compiler/RelationsDaoGenerator.java
+++ b/compiler/src/main/java/promise/database/compiler/RelationsDaoGenerator.java
@@ -496,7 +496,7 @@ private Pair<ClassName, Element> generateForHasOneRelation(Element hasOneRelatio
                 .add("@Override\n")
                 .beginControlFlow("public void accept($T " + parentElementVarName + ")",
                     TypeName.get(element.asType()))
-                .addStatement("saveWith"+capitalizeFirst(hasOneRelationFieldName)+"("+parentElementVarName+")")
+                .addStatement("saveWith" + capitalizeFirst(hasOneRelationFieldName) + "(" + parentElementVarName + ")")
                 .endControlFlow()
                 .endControlFlow(")")
                 .addStatement("return true")
@@ -507,8 +507,8 @@ private Pair<ClassName, Element> generateForHasOneRelation(Element hasOneRelatio
             .addModifiers(Modifier.PUBLIC)
             .addParameter(TypeName.get(element.asType()), parentElementVarName)
             .addCode(CodeBlock.builder()
-                .addStatement("return "+getParentElementTableVarName+".update("+parentElementVarName+") &&\n" +
-                    " "+relationElementTableVarName+".update("+parentElementVarName+".get"+capitalizeFirst(hasOneRelationFieldName)+"())")
+                .addStatement("return " + getParentElementTableVarName + ".update(" + parentElementVarName + ") &&\n" +
+                    " " + relationElementTableVarName + ".update(" + parentElementVarName + ".get" + capitalizeFirst(hasOneRelationFieldName) + "())")
                 .build())
             .returns(boolean.class)
             .build());
diff --git a/compiler/src/main/java/promise/database/compiler/RelationsDaoProcessor.kt b/compiler/src/main/java/promise/database/compiler/RelationsDaoProcessor.kt
index d10174e..6de5007 100644
--- a/compiler/src/main/java/promise/database/compiler/RelationsDaoProcessor.kt
+++ b/compiler/src/main/java/promise/database/compiler/RelationsDaoProcessor.kt
@@ -22,7 +22,7 @@ import javax.lang.model.element.Element
 import javax.lang.model.element.TypeElement
 import javax.lang.model.util.ElementFilter
 
-class RelationsDaoProcessor(private val processingEnv: ProcessingEnvironment): AnnotatedClassProcessor() {
+class RelationsDaoProcessor(private val processingEnv: ProcessingEnvironment) : AnnotatedClassProcessor() {
   override fun process(environment: RoundEnvironment?): List<JavaFile.Builder?>? {
     val javaFiles = ArrayList<JavaFile.Builder?>()
     environment?.getElementsAnnotatedWith(Entity::class.java)
diff --git a/compiler/src/main/java/promise/database/compiler/TableAnnotationGenerator.java b/compiler/src/main/java/promise/database/compiler/TableAnnotationGenerator.java
index 8c7cdac..1fa8425 100644
--- a/compiler/src/main/java/promise/database/compiler/TableAnnotationGenerator.java
+++ b/compiler/src/main/java/promise/database/compiler/TableAnnotationGenerator.java
@@ -26,7 +26,6 @@
 import promise.database.Entity;
 import promise.database.Table;
 import promise.database.compiler.utils.LogUtil;
-import promise.database.compiler.utils.LogUtil;
 import promise.database.compiler.utils.PersistableEntityUtilsKt;
 
 public class TableAnnotationGenerator implements CodeGenerator<AnnotationSpec> {
diff --git a/compiler/src/main/java/promise/database/compiler/TableColumnFieldsGenerator.kt b/compiler/src/main/java/promise/database/compiler/TableColumnFieldsGenerator.kt
index b8c26d6..c764eea 100644
--- a/compiler/src/main/java/promise/database/compiler/TableColumnFieldsGenerator.kt
+++ b/compiler/src/main/java/promise/database/compiler/TableColumnFieldsGenerator.kt
@@ -72,8 +72,7 @@ class TableColumnFieldsGenerator(
           val pair: Pair<Pair<String, Element>, String> = Pair(Pair(element.simpleName.toString(), element), colVariableName)
           genColValues.add(pair)
         }
-      }
-      else if (element.isElementAnnotatedAsRelation()) {
+      } else if (element.isElementAnnotatedAsRelation()) {
         val hasOneAnnotation = element.getAnnotation(HasOne::class.java)
         if (hasOneAnnotation != null) {
           nameOfColumn = "${element.simpleName}Id"
@@ -95,8 +94,7 @@ class TableColumnFieldsGenerator(
           val pair: Pair<Pair<String, Element>, String> = Pair(Pair(element.simpleName.toString(), element), colVariableName)
           genColValues.add(pair)
         }
-      }
-      else if (element.isPersistable()) {
+      } else if (element.isPersistable()) {
         val spec = processField(element, nameOfColumn, i)
         map[Pair(element, colVariableName)] = spec
         val pair: Pair<Pair<String, Element>, String> = Pair(Pair(element.simpleName.toString(), element), colVariableName)
@@ -126,7 +124,6 @@ class TableColumnFieldsGenerator(
         .build()
   }
 
-
   private fun getColumnInitializer(element: Element, classTypeName: TypeName): String {
     var str = "Column.Type"
     if (classTypeName.isSameAs(Integer::class.java) ||
diff --git a/compiler/src/main/java/promise/database/compiler/TableDeserializerMethodGenerator.kt b/compiler/src/main/java/promise/database/compiler/TableDeserializerMethodGenerator.kt
index 943005b..2c3c180 100644
--- a/compiler/src/main/java/promise/database/compiler/TableDeserializerMethodGenerator.kt
+++ b/compiler/src/main/java/promise/database/compiler/TableDeserializerMethodGenerator.kt
@@ -26,7 +26,6 @@ import promise.database.compiler.utils.getConverterCompatibleMethod
 import promise.database.compiler.utils.isElementAnnotatedAsRelation
 import promise.database.compiler.utils.isSameAs
 import promise.database.compiler.utils.toTypeName
-import promise.database.compiler.utils.*
 import javax.lang.model.element.Element
 import javax.lang.model.element.Modifier
 
diff --git a/compiler/src/main/java/promise/database/compiler/TableMetaDataWriter.kt b/compiler/src/main/java/promise/database/compiler/TableMetaDataWriter.kt
index a08aac3..0387723 100644
--- a/compiler/src/main/java/promise/database/compiler/TableMetaDataWriter.kt
+++ b/compiler/src/main/java/promise/database/compiler/TableMetaDataWriter.kt
@@ -15,7 +15,9 @@ package promise.database.compiler
 
 import promise.database.HasMany
 import promise.database.Ignore
+import promise.database.Migrate
 import promise.database.MigrationOptions
+import promise.database.Migrations
 import promise.database.compiler.migration.Field
 import promise.database.compiler.migration.TableMetaData
 import promise.database.compiler.migration.TableMigration
@@ -37,8 +39,7 @@ class TableMetaDataWriter(
     fun finalMaxDbVersion(): Int {
       if (tableMetaData.isNotEmpty()) {
         val versionChanges: ArrayList<VersionChange?> = ArrayList()
-        tableMetaData.map {
-          metaData -> metaData.migrations.map { it.versionChange } }
+        tableMetaData.map { metaData -> metaData.migrations.map { it.versionChange } }
             .forEach {
               versionChanges.addAll(it)
             }
@@ -56,62 +57,59 @@ class TableMetaDataWriter(
   fun process(
       //elements: Map<Element, String>
   ): promise.database.compiler.utils.List<TableMigration> {
+    val tableMigrations = promise.database.compiler.utils.List<TableMigration>()
+
+    val migrateFields = elements.filter {
+      it.key.getAnnotation(Migrate::class.java) != null ||
+          it.key.getAnnotation(Migrations::class.java) != null
+    }
+
+    if (migrateFields.isNotEmpty()) migrateFields.forEach { entry ->
+      if (entry.key.getAnnotation(Migrate::class.java) != null) {
+        val migration = entry.key.getAnnotation(Migrate::class.java)
+        tableMigrations.add(TableMigration().apply {
+          versionChange = VersionChange().apply {
+            fromVersion = migration.fromVersion
+            toVersion = migration.toVersion
+          }
+          field = if (migration.action == MigrationOptions.CREATE_INDEX) entry.key.getNameOfColumn() else entry.value
+          action = migration.action
+        })
+      } else if (entry.key.getAnnotation(Migrations::class.java) != null) {
+        val migrations = entry.key.getAnnotation(Migrations::class.java)
+        migrations.values.forEach {
+          val migration = it
+          tableMigrations.add(TableMigration().apply {
+            versionChange = VersionChange().apply {
+              fromVersion = migration.fromVersion
+              toVersion = migration.toVersion
+            }
+            field = if (migration.action == MigrationOptions.CREATE_INDEX) entry.key.getNameOfColumn() else entry.value
+            action = migration.action
+          })
+        }
+      }
+    }
 
-//
-//
-//    val migrateFields = elements.filter {
-//      it.key.getAnnotation(Migrate::class.java) != null ||
-//          it.key.getAnnotation(Migrations::class.java) != null
-//    }
-
-//    if (migrateFields.isEmpty()) {
-//
-//    }
-//    else {
-//      migrateFields.forEach { entry ->
-//        if (entry.key.getAnnotation(Migrate::class.java) != null) {
-//          val migration = entry.key.getAnnotation(Migrate::class.java)
-//          tableMigrations.add(TableMigration().apply {
-//            versionChange = VersionChange().apply {
-//              fromVersion = migration.fromVersion
-//              toVersion = migration.toVersion
-//            }
-//            field = if (migration.action == MigrationOptions.CREATE_INDEX) entry.key.getNameOfColumn() else entry.value
-//            action = migration.action
-//          })
-//        } else if (entry.key.getAnnotation(Migrations::class.java) != null) {
-//          val migrations = entry.key.getAnnotation(Migrations::class.java)
-//          migrations.values.forEach {
-//            val migration = it
-//            tableMigrations.add(TableMigration().apply {
-//              versionChange = VersionChange().apply {
-//                fromVersion = migration.fromVersion
-//                toVersion = migration.toVersion
-//              }
-//              field = if (migration.action == MigrationOptions.CREATE_INDEX) entry.key.getNameOfColumn() else entry.value
-//              action = migration.action
-//            })
-//          }
-//        }
-//      }
-//    }
     val metaData = TableMetaData()
     val oldMetaData = promise.database.compiler.utils.List<TableMetaData>(
         PromiseDatabaseCompiler.databaseMetaDataWriter.currentDatabaseMetaData!!.tableMetaData)
         .find {
           it.tableName == entityElement.getTableName()
         }
-    val tableMigrations = promise.database.compiler.utils.List<TableMigration>()
+
     if (oldMetaData != null) {
       tableMigrations.addAll(generateRequiredTableMigrations(
           PromiseDatabaseCompiler.databaseMetaDataWriter.currentDatabaseMetaData!!.dbVersion,
           promise.database.compiler.utils.List(oldMetaData.fields),
-          elements))
-      val diffMigrations = promise.database.compiler.utils.List(oldMetaData.migrations).joinOn(
-          promise.database.compiler.utils.List(tableMigrations)) { t, u -> t != u }
-      tableMigrations.addAll(diffMigrations)
-      metaData.migrations = tableMigrations
+          elements.filter {
+            it.key.getAnnotation(Migrate::class.java) == null &&
+                it.key.getAnnotation(Migrations::class.java) == null
+          }))
+      tableMigrations.addAll(promise.database.compiler.utils.List(oldMetaData.migrations))
+      metaData.migrations = tableMigrations.uniques()
     } else metaData.migrations = tableMigrations
+
     val fields: ArrayList<Field> = ArrayList()
     /**
      * ignore fields with Has many relation and ones with Ignore annotation
diff --git a/compiler/src/main/java/promise/database/compiler/TypeConverterAnnotatedProcessor.kt b/compiler/src/main/java/promise/database/compiler/TypeConverterAnnotatedProcessor.kt
index 9de821b..b64e565 100644
--- a/compiler/src/main/java/promise/database/compiler/TypeConverterAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/database/compiler/TypeConverterAnnotatedProcessor.kt
@@ -29,12 +29,12 @@ class TypeConverterAnnotatedProcessor(private val processingEnv: ProcessingEnvir
     val typeConverters = environment?.getElementsAnnotatedWith(TypeConverter::class.java)
     if (typeConverters != null) {
       if (typeConverters.size > 1)
-       LogUtil.e(Exception("There can only be one typeConverter in the module"))
+        LogUtil.e(Exception("There can only be one typeConverter in the module"))
       else if (typeConverters.size == 1) try {
         typeConverter = typeConverters.first() as TypeElement
         return Collections.singletonList(processElement(typeConverter!!))
       } catch (e: Throwable) {
-       LogUtil.e(e, typeConverter)
+        LogUtil.e(e, typeConverter)
       }
     }
     return null
@@ -42,10 +42,10 @@ class TypeConverterAnnotatedProcessor(private val processingEnv: ProcessingEnvir
 
   private fun processElement(element: TypeElement): JavaFile.Builder {
     val className = element.simpleName.toString()
-   val pack = processingEnv.elementUtils.getPackageOf(element).toString()
+    val pack = processingEnv.elementUtils.getPackageOf(element).toString()
     return Utils.generateInstanceProviderHolder(ClassName.get(pack, className))
   }
-;
+  ;
   companion object {
     var typeConverter: TypeElement? = null
   }
diff --git a/compiler/src/main/java/promise/database/compiler/migration/TableMetaData.kt b/compiler/src/main/java/promise/database/compiler/migration/TableMetaData.kt
index da9f78d..d502653 100644
--- a/compiler/src/main/java/promise/database/compiler/migration/TableMetaData.kt
+++ b/compiler/src/main/java/promise/database/compiler/migration/TableMetaData.kt
@@ -26,5 +26,5 @@ class TableMetaData {
   var fields: List<Field> = emptyList()
 
   @JsonInclude(JsonInclude.Include.NON_NULL)
-  var migrations : List<TableMigration> = emptyList()
+  var migrations: List<TableMigration> = emptyList()
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/database/compiler/migration/TableMigration.kt b/compiler/src/main/java/promise/database/compiler/migration/TableMigration.kt
index f1e326d..e3def9b 100644
--- a/compiler/src/main/java/promise/database/compiler/migration/TableMigration.kt
+++ b/compiler/src/main/java/promise/database/compiler/migration/TableMigration.kt
@@ -16,49 +16,49 @@ package promise.database.compiler.migration
 import promise.database.MigrationOptions
 
 open class TableMigration {
-   var versionChange: VersionChange? = null
-   var field: String? = null
-   var action: MigrationOptions? = null
+  var versionChange: VersionChange? = null
+  var field: String? = null
+  var action: MigrationOptions? = null
 
-   override fun equals(other: Any?): Boolean {
-      if (javaClass != other?.javaClass) return false
-      other as TableMigration
+  override fun equals(other: Any?): Boolean {
+    if (javaClass != other?.javaClass) return false
+    other as TableMigration
 
-      if (versionChange != other.versionChange) return false
-      if (field != other.field) return false
-      if (action != other.action) return false
-      return true
-   }
+    if (versionChange != other.versionChange) return false
+    if (field != other.field) return false
+    if (action != other.action) return false
+    return true
+  }
 
-   override fun hashCode(): Int {
-      var result = versionChange?.hashCode() ?: 0
-      result = 31 * result + (field?.hashCode() ?: 0)
-      result = 31 * result + (action?.hashCode() ?: 0)
-      return result
-   }
+  override fun hashCode(): Int {
+    var result = versionChange?.hashCode() ?: 0
+    result = 31 * result + (field?.hashCode() ?: 0)
+    result = 31 * result + (action?.hashCode() ?: 0)
+    return result
+  }
 }
 
-class RenameColumnTableMigration: TableMigration() {
+class RenameColumnTableMigration : TableMigration() {
 
-   var oldColumnName: String? = null
+  var oldColumnName: String? = null
 
-   init {
-     super.action = MigrationOptions.RENAME_COLUMN
-   }
+  init {
+    super.action = MigrationOptions.RENAME_COLUMN
+  }
 
-   override fun equals(other: Any?): Boolean {
-      if (this === other) return true
-      if (javaClass != other?.javaClass) return false
-      if (!super.equals(other)) return false
-      other as RenameColumnTableMigration
-      if (oldColumnName != other.oldColumnName) return false
-      return true
-   }
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (javaClass != other?.javaClass) return false
+    if (!super.equals(other)) return false
+    other as RenameColumnTableMigration
+    if (oldColumnName != other.oldColumnName) return false
+    return true
+  }
 
-   override fun hashCode(): Int {
-      var result = 0
-      result = 31 * result + (oldColumnName?.hashCode() ?: 0)
-      return result
-   }
+  override fun hashCode(): Int {
+    var result = 0
+    result = 31 * result + (oldColumnName?.hashCode() ?: 0)
+    return result
+  }
 
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/database/compiler/migration/VersionChange.kt b/compiler/src/main/java/promise/database/compiler/migration/VersionChange.kt
index acc1b53..dd3e347 100644
--- a/compiler/src/main/java/promise/database/compiler/migration/VersionChange.kt
+++ b/compiler/src/main/java/promise/database/compiler/migration/VersionChange.kt
@@ -14,8 +14,8 @@
 package promise.database.compiler.migration
 
 class VersionChange {
-   var fromVersion: Int = 0
-    var toVersion: Int = 0
+  var fromVersion: Int = 0
+  var toVersion: Int = 0
   override fun equals(other: Any?): Boolean {
     if (this === other) return true
     if (javaClass != other?.javaClass) return false
diff --git a/compiler/src/main/java/promise/database/compiler/utils/JavaUtils.java b/compiler/src/main/java/promise/database/compiler/utils/JavaUtils.java
index 04ac53f..ea9d7e1 100644
--- a/compiler/src/main/java/promise/database/compiler/utils/JavaUtils.java
+++ b/compiler/src/main/java/promise/database/compiler/utils/JavaUtils.java
@@ -26,7 +26,6 @@
 
 import javax.annotation.processing.ProcessingEnvironment;
 import javax.lang.model.element.Element;
-import javax.lang.model.element.ExecutableElement;
 import javax.lang.model.element.Modifier;
 import javax.lang.model.element.TypeElement;
 import javax.lang.model.element.VariableElement;
@@ -86,7 +85,7 @@ public static CodeBlock.Builder generateGetRelationDaoCodeBlock(Map.Entry<ClassN
         ClassName.get("promise.commons", "SingletonInstanceProvider"),
         providerClassName,
         relationDao.getKey());
-    for (Map.Entry<ClassName, Element> tableAndEntity: relationDao.getValue().entrySet())
+    for (Map.Entry<ClassName, Element> tableAndEntity : relationDao.getValue().entrySet())
       codeBlock.add(".set" + tableAndEntity.getKey().simpleName() + "(get" + tableAndEntity.getKey().simpleName() + "())\n");
     codeBlock.addStatement(".build())).get()");
     return codeBlock;
@@ -116,11 +115,11 @@ public static CodeBlock generateGetTableStatement(
       ProcessingEnvironment processingEnv,
       TypeElement entity) {
     String pack = processingEnv.getElementUtils().getPackageOf(entity).toString();
-      return CodeBlock.builder()
-          .addStatement("return ($T) tableOf($T.class)",
-              ClassName.get(pack, PersistableEntityUtilsKt.getTableClassNameString(entity)),
-              TypeName.get(entity.asType()))
-          .build();
+    return CodeBlock.builder()
+        .addStatement("return ($T) tableOf($T.class)",
+            ClassName.get(pack, PersistableEntityUtilsKt.getTableClassNameString(entity)),
+            TypeName.get(entity.asType()))
+        .build();
   }
 
   public static CodeBlock generateSerializerRelationPutStatement(Element element, String colName) {
@@ -209,7 +208,6 @@ public static boolean isCollectionType(ProcessingEnvironment processingEnvironme
     return isSubTypeOfDeclaredType(processingEnvironment, variableElement, collectionType);
   }
 
-
   public static List<? extends TypeMirror> getParameterizedTypeMirrors(VariableElement variableElement) {
     if (variableElement.asType() instanceof DeclaredType) {
       DeclaredType declaredType = (DeclaredType) variableElement.asType();
diff --git a/compiler/src/main/java/promise/database/compiler/utils/List.java b/compiler/src/main/java/promise/database/compiler/utils/List.java
index 5935a56..2a7bc44 100644
--- a/compiler/src/main/java/promise/database/compiler/utils/List.java
+++ b/compiler/src/main/java/promise/database/compiler/utils/List.java
@@ -33,12 +33,6 @@
 import promise.database.compiler.utils.function.FilterFunction2;
 import promise.database.compiler.utils.function.GroupFunction;
 import promise.database.compiler.utils.function.GroupFunction2;
-import promise.database.compiler.utils.function.BIConsumer;
-import promise.database.compiler.utils.function.Combiner;
-import promise.database.compiler.utils.function.FilterFunction;
-import promise.database.compiler.utils.function.FilterFunction2;
-import promise.database.compiler.utils.function.GroupFunction;
-import promise.database.compiler.utils.function.GroupFunction2;
 import promise.database.compiler.utils.function.GroupFunction3;
 import promise.database.compiler.utils.function.JoinFunction;
 import promise.database.compiler.utils.function.MapFunction;
@@ -359,7 +353,7 @@ public <K> List<T> uniques(MapFunction<? extends K, ? super T> function, JoinFun
    *
    * @param uList    list to compare from
    * @param function filter function for each item
-   * @param equals  flags to compare equality or no equality
+   * @param equals   flags to compare equality or no equality
    * @param <U>      type of list item to compare from
    * @param <K>      type of attribute to compare
    * @return a reduced list
diff --git a/compiler/src/main/java/promise/database/compiler/utils/LogUtil.java b/compiler/src/main/java/promise/database/compiler/utils/LogUtil.java
index fe6064f..ad669a9 100644
--- a/compiler/src/main/java/promise/database/compiler/utils/LogUtil.java
+++ b/compiler/src/main/java/promise/database/compiler/utils/LogUtil.java
@@ -21,22 +21,21 @@
 
 public class LogUtil {
 
+  private static final String TAG = "PromiseDatabaseCompiler: ";
   private static ProcessingEnvironment processingEnv;
 
-  private static final String TAG = "PromiseDatabaseCompiler: ";
+  private LogUtil() {
+    //no instance
+  }
 
   public static void initLogger(ProcessingEnvironment processingEnvironment) {
     LogUtil.processingEnv = processingEnvironment;
   }
 
-  private LogUtil() {
-    //no instance
-  }
-
-  public static void w( Object... messages) {
+  public static void w(Object... messages) {
     StringBuilder builder = new StringBuilder();
     builder.append(TAG);
-    for (Object message: messages) {
+    for (Object message : messages) {
       builder.append(message.toString());
     }
     processingEnv.getMessager().printMessage(Diagnostic.Kind.WARNING, builder.toString());
@@ -47,7 +46,7 @@ public static void n(Object... messages) {
     StringBuilder builder = new StringBuilder();
 
     builder.append(TAG);
-    for (Object message: messages) {
+    for (Object message : messages) {
       builder.append(message.toString());
     }
     processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, builder.toString());
@@ -55,7 +54,7 @@ public static void n(Object... messages) {
 
   public static void e(Throwable t) {
     processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR,
-        TAG +  Utils.INSTANCE.getStackTraceString(t));
+        TAG + Utils.INSTANCE.getStackTraceString(t));
   }
 
   public static void eTrace(Throwable t) {
diff --git a/compiler/src/main/java/promise/database/compiler/utils/PersistableEntityUtils.kt b/compiler/src/main/java/promise/database/compiler/utils/PersistableEntityUtils.kt
index 877bdb9..18c0666 100644
--- a/compiler/src/main/java/promise/database/compiler/utils/PersistableEntityUtils.kt
+++ b/compiler/src/main/java/promise/database/compiler/utils/PersistableEntityUtils.kt
@@ -136,6 +136,7 @@ fun Element.getNameOfColumn(): String {
   var name: String? = null
   if ((this.toTypeName().isSameAs(Integer::class.java) ||
           this.toTypeName().isSameAs(Float::class.java) ||
+          this.toTypeName().isSameAs(Long::class.java) ||
           this.toTypeName().isSameAs(Double::class.java) ||
           this.toTypeName().isSameAs(Boolean::class.java)) &&
       this.getAnnotation(promise.database.Number::class.java) != null) {
@@ -156,6 +157,7 @@ fun Element.isColumnNullable(): Boolean {
   var nullable: Boolean = true
   if ((this.toTypeName().isSameAs(Integer::class.java) ||
           this.toTypeName().isSameAs(Float::class.java) ||
+          this.toTypeName().isSameAs(Long::class.java) ||
           this.toTypeName().isSameAs(Double::class.java) ||
           this.toTypeName().isSameAs(Boolean::class.java)) &&
       this.getAnnotation(promise.database.Number::class.java) != null) {
@@ -225,11 +227,11 @@ fun Element.isElementAnnotatedAsRelation(): Boolean {
 
 fun Element.isPersistable(): Boolean = try {
   this.toTypeName().isSameAs(Integer::class.java) ||
+      this.toTypeName().isSameAs(Long::class.java) ||
       this.toTypeName().isSameAs(String::class.java) ||
       this.toTypeName().isSameAs(Float::class.java) ||
       this.toTypeName().isSameAs(Double::class.java) ||
       this.toTypeName().isSameAs(Boolean::class.java)
 } catch (e: Throwable) {
-
   false
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/database/compiler/utils/Utils.kt b/compiler/src/main/java/promise/database/compiler/utils/Utils.kt
index ae13163..43def75 100644
--- a/compiler/src/main/java/promise/database/compiler/utils/Utils.kt
+++ b/compiler/src/main/java/promise/database/compiler/utils/Utils.kt
@@ -33,12 +33,10 @@ import javax.lang.model.element.ExecutableElement
 import javax.lang.model.element.Modifier
 import javax.lang.model.element.TypeElement
 import javax.lang.model.element.VariableElement
-import javax.lang.model.type.*
-import javax.lang.model.util.SimpleTypeVisitor6
-import javax.lang.model.util.SimpleTypeVisitor7
+import javax.lang.model.type.MirroredTypeException
+import javax.lang.model.type.TypeKind
+import javax.lang.model.type.TypeMirror
 import javax.lang.model.util.Types
-import kotlin.contracts.ExperimentalContracts
-import kotlin.contracts.contract
 import kotlin.reflect.KClass
 
 
@@ -171,7 +169,7 @@ object Utils {
        * Typename for this provider
        */
       element: ClassName
-      ): JavaFile.Builder {
+  ): JavaFile.Builder {
 
     val className = element.simpleName()
 
diff --git a/compiler/src/main/java/promise/database/compiler/utils/function/GroupFunction3.java b/compiler/src/main/java/promise/database/compiler/utils/function/GroupFunction3.java
index 27c4039..e0c950c 100644
--- a/compiler/src/main/java/promise/database/compiler/utils/function/GroupFunction3.java
+++ b/compiler/src/main/java/promise/database/compiler/utils/function/GroupFunction3.java
@@ -14,7 +14,6 @@
 package promise.database.compiler.utils.function;
 
 
-import promise.database.compiler.utils.List;
 import promise.database.compiler.utils.List;
 
 public interface GroupFunction3<E, T> {
diff --git a/compiler/src/main/java/promise/database/compiler/utils/function/ReduceFunction.java b/compiler/src/main/java/promise/database/compiler/utils/function/ReduceFunction.java
index febe2d6..036bc9c 100644
--- a/compiler/src/main/java/promise/database/compiler/utils/function/ReduceFunction.java
+++ b/compiler/src/main/java/promise/database/compiler/utils/function/ReduceFunction.java
@@ -14,7 +14,6 @@
 package promise.database.compiler.utils.function;
 
 
-import promise.database.compiler.utils.List;
 import promise.database.compiler.utils.List;
 
 public interface ReduceFunction<K, T> {
diff --git a/database/src/main/java/promise/db/Corrupt.java b/database/src/main/java/promise/db/Corrupt.java
index 08b6efb..8fe1c68 100644
--- a/database/src/main/java/promise/db/Corrupt.java
+++ b/database/src/main/java/promise/db/Corrupt.java
@@ -13,7 +13,8 @@
 
 package promise.db;
 
-public interface Corrupt {
+import androidx.sqlite.db.SupportSQLiteDatabase;
 
-  void onCorrupt();
+public interface Corrupt {
+  void onCorrupt(SupportSQLiteDatabase database);
 }
diff --git a/database/src/main/java/promise/db/DatabaseCreationCallback.kt b/database/src/main/java/promise/db/DatabaseCreationCallback.kt
index dc38b00..026e169 100644
--- a/database/src/main/java/promise/db/DatabaseCreationCallback.kt
+++ b/database/src/main/java/promise/db/DatabaseCreationCallback.kt
@@ -13,7 +13,6 @@
 
 package promise.db
 
-import android.database.sqlite.SQLiteDatabase
 import androidx.sqlite.db.SupportSQLiteDatabase
 
 interface DatabaseCreationCallback {
diff --git a/database/src/main/java/promise/db/FastDatabase.kt b/database/src/main/java/promise/db/FastDatabase.kt
index dbfbafd..fda39e0 100644
--- a/database/src/main/java/promise/db/FastDatabase.kt
+++ b/database/src/main/java/promise/db/FastDatabase.kt
@@ -14,39 +14,73 @@
 package promise.db
 
 import android.database.Cursor
-import android.database.DatabaseErrorHandler
-import android.database.sqlite.SQLiteDatabase
 import androidx.collection.ArrayMap
 import androidx.sqlite.db.SupportSQLiteDatabase
 import promise.commons.makeInstance
 import promise.commons.model.List
 import promise.commons.util.ClassUtil
+import promise.utils.Visitor
 
 abstract class FastDatabase internal constructor(
     name: String?,
-    version: Int,
-    errorHandler: DatabaseErrorHandler) : FastDatabaseOpenHelper(name, version, errorHandler), Crud<SupportSQLiteDatabase> {
-
+    version: Int) : FastDatabaseOpenHelper(name, version),
+    Crud<SupportSQLiteDatabase> {
+  /**
+   * adds tables to the existing database
+   */
   abstract fun add(database: SupportSQLiteDatabase, vararg tables: TableCrud<*, in SupportSQLiteDatabase>): Boolean
 
+  /**
+   * returns a table instance provided the class of the table
+   * the class provided must be annotated with @Table
+   */
   abstract fun <T : TableCrud<*, in SupportSQLiteDatabase>> obtain(tableClass: Class<out TableCrud<*, in SupportSQLiteDatabase>>): T
 
+  /**
+   * queries the given sql and returns a cursor
+   */
   abstract fun querySql(sql: String): Cursor
 
+  /**
+   * pass a visitor to merge multiple operations
+   */
+  abstract fun <R : Any> accept(visitor: Visitor<FastDatabase, R>): R
+
+  /**
+   * queries the given query builder and returns a cursor
+   */
   abstract fun query(queryBuilder: QueryBuilder): Cursor
 
+  /**
+   * returns a writable version of the database
+   */
   abstract fun writableDatabase(): SupportSQLiteDatabase
 
+  /**
+   * executes query transaction
+   */
   abstract fun transact(block: FastDatabase.() -> Unit)
 
+  /**
+   * clear records in the passed tables
+   */
   abstract fun delete(vararg tableCruds: TableCrud<*, in SupportSQLiteDatabase>): Boolean
 
+  /**
+   * returns the name of the database
+   */
   abstract fun name(): String
 
+  /**
+   * in case migrations have not been done successfully, calling this ensures the database drops and creates all the tables afresh
+   */
+  abstract fun fallBackToDestructiveMigration()
+
   companion object {
     private val dbCache: ArrayMap<String, FastDatabase> = ArrayMap()
     private val lock = Any()
     const val DEFAULT_NAME = "fast"
+
     @JvmOverloads
     @JvmStatic
     fun createDatabase(dbClass: Class<*>,
diff --git a/database/src/main/java/promise/db/FastDatabaseImpl.kt b/database/src/main/java/promise/db/FastDatabaseImpl.kt
index 78a51b9..1459824 100644
--- a/database/src/main/java/promise/db/FastDatabaseImpl.kt
+++ b/database/src/main/java/promise/db/FastDatabaseImpl.kt
@@ -12,10 +12,7 @@
  */
 package promise.db
 
-import android.annotation.TargetApi
 import android.database.Cursor
-import android.database.DatabaseErrorHandler
-import android.os.Build
 import androidx.collection.ArrayMap
 import androidx.sqlite.db.SupportSQLiteDatabase
 import promise.commons.createInstance
@@ -26,13 +23,20 @@ import promise.commons.util.ClassUtil
 import promise.commons.util.Conditions
 import promise.database.Table
 import promise.model.IdentifiableList
+import promise.utils.Visitor
 import java.util.*
 
-open class FastDatabaseImpl internal constructor(
+@Suppress("UNCHECKED_CAST")
+open class FastDatabaseImpl constructor(
     name: String?,
-    version: Int,
-    errorHandler: DatabaseErrorHandler)
-  : FastDatabase(name, version, errorHandler) {
+    version: Int)
+  : FastDatabase(name, version) {
+
+  private var fallBackToDestructiveMigration: Boolean = false
+
+  override fun fallBackToDestructiveMigration() {
+    this.fallBackToDestructiveMigration = true
+  }
 
   private val cacheMap: ArrayMap<String, Any> = ArrayMap()
 
@@ -40,19 +44,6 @@ open class FastDatabaseImpl internal constructor(
 
   private var databaseCreationCallback: DatabaseCreationCallback? = null
 
-  @TargetApi(Build.VERSION_CODES.HONEYCOMB)
-  private constructor(name: String?,
-                      version: Int,
-                      listener: Corrupt?) : this(
-      name,
-      version,
-      DatabaseErrorHandler {
-        assert(listener != null)
-        listener!!.onCorrupt()
-      })
-
-  constructor(name: String?, version: Int) : this(name, version, null)
-
   final override fun onCreate(db: SupportSQLiteDatabase) {
     if (databaseCreationCallback != null) {
       databaseCreationCallback!!.beforeCreate(db)
@@ -62,17 +53,27 @@ open class FastDatabaseImpl internal constructor(
   }
 
   final override fun onUpgrade(database: SupportSQLiteDatabase, oldVersion: Int, newVersion: Int) {
-    LogUtil.d(TAG, "onUpgrade", oldVersion, newVersion)
-    if (newVersion - oldVersion == 1)
-      onUpgradeDatabase(database, oldVersion, newVersion)
-    else {
-      var i = oldVersion
-      while (i < newVersion) {
-        onUpgradeDatabase(database, i, i + 1)
-        i++
+    try {
+      if (newVersion - oldVersion == 1)
+        onUpgradeDatabase(database, oldVersion, newVersion)
+      else {
+        var i = oldVersion
+        while (i < newVersion) {
+          onUpgradeDatabase(database, i, i + 1)
+          i++
+        }
       }
+      upgradeTables(database, oldVersion, newVersion)
+    } catch (e: Throwable) {
+      if (fallBackToDestructiveMigration) {
+        for (table in Conditions.checkNotNull(tables())) try {
+          drop(table, database)
+        } catch (tableError: TableError) {
+          LogUtil.e(TAG, tableError)
+        }
+        onCreate(database)
+      } else LogUtil.e(TAG, e)
     }
-    upgradeTables(database, oldVersion, newVersion)
   }
 
   private fun onUpgradeDatabase(database: SupportSQLiteDatabase, oldVersion: Int, newVersion: Int) {
@@ -92,7 +93,7 @@ open class FastDatabaseImpl internal constructor(
       if (ClassUtil.hasAnnotation(tableClass, Table::class.java)) {
         val table = tableClass.getAnnotation(Table::class.java)!!
         if (cacheMap.containsKey(table.tableName)) return cacheMap[table.tableName] as T
-        val tableObject: FastTable<*> = createInstance<FastTable<*>>(tableClass.kotlin, arrayOf(this))
+        val tableObject: FastTable<*> = createInstance<FastTable<*>>(clazz = tableClass.kotlin, args = arrayOf(this))
         tableObject.setNameOfTable(table.tableName)
         tableObject.setArgs(ArrayMap<String, Any>().apply {
           put(INDEXES, table.indices)
@@ -162,18 +163,6 @@ open class FastDatabaseImpl internal constructor(
     return created
   }
 
-  private fun drop(database: SupportSQLiteDatabase): Boolean {
-    /*for (Map.Entry<IndexCreated, Table<, SupportSQLiteDatabase>> entry :
-        indexCreatedTableHashMap.entrySet()) {
-      try {
-        dropped = dropped && drop(checkTableExist(entry.getValue()), database);
-      } catch (DBError dbError) {
-        dbError.printStackTrace();
-        return false;
-      }
-    }*/return true
-  }
-
   @Throws(DBError::class)
   private fun create(tableCrud: TableCrud<*, in SupportSQLiteDatabase>, database: SupportSQLiteDatabase): Boolean {
     try {
@@ -255,15 +244,14 @@ open class FastDatabaseImpl internal constructor(
   override fun <T : Identifiable<Int>> save(list: IdentifiableList<out T>, tableCrud: TableCrud<T, in SupportSQLiteDatabase>): Boolean =
       checkTableExist(tableCrud).accept(SaveListVisitor(writableDatabase, list)) as Boolean
 
-
   override fun deleteAll(): Boolean = synchronized(FastDatabaseImpl::class.java) {
     var deleted = true
     try {
-      writableDatabase.execSQL("PRAGMA foreign_keys = FALSE");
+      writableDatabase.execSQL("PRAGMA foreign_keys = FALSE")
       transact {
         for (table in Conditions.checkNotNull(tables())) deleted = deleted && delete(checkTableExist(table))
       }
-      writableDatabase.execSQL("PRAGMA foreign_keys = TRUE");
+      writableDatabase.execSQL("PRAGMA foreign_keys = TRUE")
     } catch (e: Exception) {
     }
     return deleted
@@ -283,6 +271,8 @@ open class FastDatabaseImpl internal constructor(
     }
   }
 
+  override fun <R : Any> accept(visitor: Visitor<FastDatabase, R>): R = visitor.visit(this)
+
   private fun <T : Identifiable<Int>> checkTableExist(tableCrud: TableCrud<T, in SupportSQLiteDatabase>): TableCrud<T, in SupportSQLiteDatabase> =
       Conditions.checkNotNull(tableCrud)
 
diff --git a/database/src/main/java/promise/db/FastDatabaseOpenHelper.java b/database/src/main/java/promise/db/FastDatabaseOpenHelper.java
index 22c463d..6105081 100644
--- a/database/src/main/java/promise/db/FastDatabaseOpenHelper.java
+++ b/database/src/main/java/promise/db/FastDatabaseOpenHelper.java
@@ -13,8 +13,6 @@
 
 package promise.db;
 
-import android.database.DatabaseErrorHandler;
-
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.sqlite.db.SupportSQLiteDatabase;
@@ -27,14 +25,12 @@ public abstract class FastDatabaseOpenHelper extends SupportSQLiteOpenHelper.Cal
 
   private SupportSQLiteOpenHelper helper;
 
-  private DatabaseErrorHandler errorHandler;
+  private Corrupt errorHandler;
 
   public FastDatabaseOpenHelper(@Nullable String name,
-                                int version,
-                                @Nullable DatabaseErrorHandler errorHandler) {
+                                int version) {
     super(version);
     SupportSQLiteOpenHelper.Factory factory = new FrameworkSQLiteOpenHelperFactory();
-    this.errorHandler = errorHandler;
     SupportSQLiteOpenHelper.Configuration configuration = SupportSQLiteOpenHelper.Configuration
         .builder(AndroidPromise.instance().context())
         .name(name)
@@ -42,11 +38,15 @@ public FastDatabaseOpenHelper(@Nullable String name,
         .build();
 
     this.helper = factory.create(configuration);
-   // super(AndroidPromise.instance().context(), name, version, errorHandler);
+    // super(AndroidPromise.instance().context(), name, version, errorHandler);
+  }
+
+  public void setErrorHandler(Corrupt errorHandler) {
+    this.errorHandler = errorHandler;
   }
 
-  public void onCorruption(SupportSQLiteDatabase db) {
-    //if (this.errorHandler != null) this.errorHandler.onCorruption(db);
+  public void onCorruption(@NonNull SupportSQLiteDatabase db) {
+    if (this.errorHandler != null) this.errorHandler.onCorrupt(db);
   }
 
 
diff --git a/database/src/main/java/promise/db/FastTable.kt b/database/src/main/java/promise/db/FastTable.kt
index 1c0b4a2..6200427 100644
--- a/database/src/main/java/promise/db/FastTable.kt
+++ b/database/src/main/java/promise/db/FastTable.kt
@@ -37,6 +37,7 @@ internal const val FOREIGN_kEYS = "foreign_keys"
  *
  * @param <T> [Identifiable] instance to be persisted by the model
 </T> */
+@Suppress("UNCHECKED_CAST")
 abstract class FastTable<T : Identifiable<Int>>
 /**
  * @param database
diff --git a/database/src/main/java/promise/db/FetchVisitor.kt b/database/src/main/java/promise/db/FetchVisitors.kt
similarity index 97%
rename from database/src/main/java/promise/db/FetchVisitor.kt
rename to database/src/main/java/promise/db/FetchVisitors.kt
index 1624527..9e117b2 100644
--- a/database/src/main/java/promise/db/FetchVisitor.kt
+++ b/database/src/main/java/promise/db/FetchVisitors.kt
@@ -53,11 +53,12 @@ class FetchAllVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteDatabas
       cursor = x.query(builder.build(), builder.buildParameters())
       t.collection(cursor)
     } catch (e: SQLiteException) {
-      IdentifiableList<T>()
+      IdentifiableList()
     }
   }
 }
 
+@Suppress("KDocUnresolvedReference")
 class FetchExtrasVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteDatabase) : Visitor<TableCrud<T, in SupportSQLiteDatabase>, TableCrud.Extras<T>> {
 
   override fun visit(t: TableCrud<T, in SupportSQLiteDatabase>): TableCrud.Extras<T> =
@@ -73,6 +74,7 @@ class FetchExtrasVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteData
    *
    * @param <Q> The type of the items in the table
   </Q> */
+  @Suppress("UNCHECKED_CAST")
   private abstract inner class QueryExtras<Q : Identifiable<Int>> internal constructor(
       /**
        * the database instance to readAsync fromm
@@ -151,7 +153,7 @@ class FetchExtrasVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteData
         while (cursor.moveToNext() && !cursor.isClosed) ts.add(getWithId(cursor))
         ts
       } catch (e: SQLiteException) {
-        IdentifiableList<Q>()
+        IdentifiableList()
       }
     }
 
@@ -171,7 +173,7 @@ class FetchExtrasVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteData
         ts
       } catch (e: SQLiteException) {
         LogUtil.e(fastTable.TAG, e)
-        IdentifiableList<Q>()
+        IdentifiableList()
       }
     }
 
@@ -192,7 +194,7 @@ class FetchExtrasVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteData
         ts
       } catch (e: SQLiteException) {
         LogUtil.e(fastTable.TAG, e)
-        IdentifiableList<Q>()
+        IdentifiableList()
       }
     }
 
@@ -206,7 +208,7 @@ class FetchExtrasVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteData
         ts
       } catch (e: SQLiteException) {
         LogUtil.e(fastTable.TAG, e)
-        IdentifiableList<Q>()
+        IdentifiableList()
       }
     }
 
@@ -228,7 +230,7 @@ class FetchExtrasVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteData
         ts
       } catch (e: SQLiteException) {
         LogUtil.e(fastTable.TAG, e)
-        IdentifiableList<Q>()
+        IdentifiableList()
       }
     }
 
@@ -249,7 +251,7 @@ class FetchExtrasVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteData
         ts
       } catch (e: SQLiteException) {
         LogUtil.e(fastTable.TAG, e)
-        IdentifiableList<Q>()
+        IdentifiableList()
       }
     }
 
@@ -278,7 +280,7 @@ class FetchExtrasVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteData
         /*database.close();*/ts
       } catch (e: SQLiteException) {
         LogUtil.e(fastTable.TAG, e)
-        IdentifiableList<Q>()
+        IdentifiableList()
       }
     }
 
@@ -303,7 +305,7 @@ class FetchExtrasVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteData
         /*database.close();*/ts
       } catch (e: SQLiteException) {
         LogUtil.e(fastTable.TAG, e)
-        IdentifiableList<Q>()
+        IdentifiableList()
       }
     }
 
@@ -330,7 +332,7 @@ class FetchExtrasVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteData
         /*database.close();*/ts
       } catch (e: SQLiteException) {
         LogUtil.e(fastTable.TAG, e)
-        IdentifiableList<Q>()
+        IdentifiableList()
       }
     }
 
@@ -354,7 +356,7 @@ class FetchExtrasVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteData
         /*database.close();*/ts
       } catch (e: SQLiteException) {
         LogUtil.e(fastTable.TAG, e)
-        IdentifiableList<Q>()
+        IdentifiableList()
       }
     }
 
@@ -382,7 +384,7 @@ class FetchExtrasVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteData
         /*database.close();*/ts
       } catch (e: SQLiteException) {
         LogUtil.e(fastTable.TAG, e)
-        IdentifiableList<Q>()
+        IdentifiableList()
       }
     }
   }
diff --git a/database/src/main/java/promise/db/Migration.kt b/database/src/main/java/promise/db/Migration.kt
index 4373b61..4341d17 100644
--- a/database/src/main/java/promise/db/Migration.kt
+++ b/database/src/main/java/promise/db/Migration.kt
@@ -13,7 +13,6 @@
 
 package promise.db
 
-import android.database.sqlite.SQLiteDatabase
 import androidx.sqlite.db.SupportSQLiteDatabase
 
 interface Migration {
diff --git a/database/src/main/java/promise/db/PromiseDatabase.java b/database/src/main/java/promise/db/PromiseDatabase.kt
similarity index 52%
rename from database/src/main/java/promise/db/PromiseDatabase.java
rename to database/src/main/java/promise/db/PromiseDatabase.kt
index 9db1b3c..f3e54b0 100644
--- a/database/src/main/java/promise/db/PromiseDatabase.java
+++ b/database/src/main/java/promise/db/PromiseDatabase.kt
@@ -10,35 +10,26 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+package promise.db
 
-package promise.db;
-
-import org.jetbrains.annotations.NotNull;
-
-import promise.commons.model.Identifiable;
-import promise.utils.Acceptor;
-import promise.utils.Visitor;
+import promise.commons.model.Identifiable
+import promise.utils.Visitor
 
 /**
  * Base class for classes annotated with DatabaseEntity
  */
-public abstract class PromiseDatabase {
-
-  private FastDatabase fastDatabase;
-
-  public PromiseDatabase(FastDatabase fastDatabase) {
-    this.fastDatabase = fastDatabase;
-  }
+abstract class PromiseDatabase(private val fastDatabase: FastDatabase?) {
 
   /**
    * @return an instance of FastDatabase
    */
-  public FastDatabase getDatabaseInstance() {
-    if (fastDatabase == null) throw new IllegalStateException("Database not initialized or created yet");
-    return fastDatabase;
-  }
+  val databaseInstance: FastDatabase
+    get() {
+      checkNotNull(fastDatabase) { "Database not initialized or created yet" }
+      return fastDatabase
+    }
 
-  public abstract <T extends Identifiable<Integer>> Visitor<Class<? extends T>, FastTable<T>> getEntityClassVisitor();
+  abstract fun <T : Identifiable<Int>> getEntityClassVisitor(): Visitor<Class<out T>, FastTable<T>>
 
   /**
    * returns the table associated with the entity class
@@ -47,12 +38,11 @@ public FastDatabase getDatabaseInstance() {
    * @param <T>         entity
    * @return FastTable of the entity
    * @throws IllegalArgumentException if entity is not registered with the database
-   */
-  public  <T extends Identifiable<Integer>> FastTable<T> tableOf(Class<? extends T> entityClass) throws IllegalArgumentException {
-    Visitor<? super Class<? extends T>, ? extends FastTable<T>> t = getEntityClassVisitor();
-    return t.visit(entityClass);
+  </T> */
+  @Throws(IllegalArgumentException::class)
+  fun <T : Identifiable<Int>> tableOf(entityClass: Class<out T>): FastTable<T> {
+    val t: Visitor<Class<out T>, FastTable<T>> = getEntityClassVisitor()
+    return t.visit(entityClass)
   }
 
-}
-
-
+}
\ No newline at end of file
diff --git a/database/src/main/java/promise/db/ReactiveFastDatabase.kt b/database/src/main/java/promise/db/ReactiveFastDatabase.kt
index 40e55a0..2b8b1a1 100644
--- a/database/src/main/java/promise/db/ReactiveFastDatabase.kt
+++ b/database/src/main/java/promise/db/ReactiveFastDatabase.kt
@@ -12,11 +12,8 @@
  */
 package promise.db
 
-import android.annotation.TargetApi
 import android.content.ContentValues
 import android.database.Cursor
-import android.database.DatabaseErrorHandler
-import android.os.Build
 import androidx.sqlite.db.SupportSQLiteDatabase
 import io.reactivex.Maybe
 import io.reactivex.Single
@@ -25,26 +22,14 @@ import promise.commons.model.List
 import promise.commons.util.DoubleConverter
 import promise.model.IdentifiableList
 
-class ReactiveFastDatabase private constructor(
+class ReactiveFastDatabase constructor(
     name: String?,
-    version: Int,
-    errorHandler: DatabaseErrorHandler) :
-    FastDatabaseImpl(name, version, errorHandler),
+    version: Int) :
+    FastDatabaseImpl(name, version),
     ReactiveCrud<SupportSQLiteDatabase> {
 
-  @TargetApi(Build.VERSION_CODES.HONEYCOMB)
-  internal constructor(name: String?, version: Int, listener: Corrupt?) : this(
-      name,
-      version,
-      DatabaseErrorHandler {
-        assert(listener != null)
-        listener!!.onCorrupt()
-      })
-
   internal constructor(version: Int) : this(DEFAULT_NAME, version)
 
-  constructor(name: String?, version: Int) : this(name, version,  null)
-
   override fun queryAsync(queryBuilder: QueryBuilder): Single<Cursor> = Single.fromCallable { query(queryBuilder) }
 
   @Throws(TableError::class)

From 405a1b6994d48bc0ceecb88b3079fe81afedf88e Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Thu, 20 Aug 2020 03:15:19 +0300
Subject: [PATCH 27/34] updated commons dep

---
 compiler/build.gradle | 4 ++--
 database/build.gradle | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/compiler/build.gradle b/compiler/build.gradle
index 7af5e55..661c6d3 100644
--- a/compiler/build.gradle
+++ b/compiler/build.gradle
@@ -19,8 +19,8 @@ apply plugin: 'kotlin-kapt'
 apply plugin: 'maven'
 
 dependencies {
-    //compileOnly 'com.github.android-promise.database:commons:1.0.3-alpha4'
-    compileOnly project(path: ':commons')
+    compileOnly 'com.github.android-promise.database:commons:dev-4cc181146c-1'
+    //compileOnly project(path: ':commons')
     compileOnly files(Jvm.current().getToolsJar())
     implementation 'com.google.auto.value:auto-value-annotations:1.7.4'
     kapt 'com.google.auto.value:auto-value:1.7.4'
diff --git a/database/build.gradle b/database/build.gradle
index 95f1aad..9c09f24 100644
--- a/database/build.gradle
+++ b/database/build.gradle
@@ -42,8 +42,8 @@ android {
 }
 
 dependencies {
-    //api 'com.github.android-promise.database:commons:1.0.3-alpha4'
-    api project(path: ':commons')
+    api 'com.github.android-promise.database:commons:dev-4cc181146c-1'
+    //api project(path: ':commons')
     api 'androidx.sqlite:sqlite:2.1.0'
     implementation 'androidx.sqlite:sqlite-framework:2.1.0'
     compileOnly 'io.reactivex.rxjava2:rxjava:2.2.17'

From fc969ef95dd61ca10a022e4d598b30953d6d7d9b Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Thu, 20 Aug 2020 03:29:01 +0300
Subject: [PATCH 28/34] updated commons dep

---
 compiler/build.gradle | 2 +-
 database/build.gradle | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/build.gradle b/compiler/build.gradle
index 661c6d3..f61dc69 100644
--- a/compiler/build.gradle
+++ b/compiler/build.gradle
@@ -19,7 +19,7 @@ apply plugin: 'kotlin-kapt'
 apply plugin: 'maven'
 
 dependencies {
-    compileOnly 'com.github.android-promise.database:commons:dev-4cc181146c-1'
+    compileOnly 'com.github.android-promise.database:commons:1.0.3-alpha7'
     //compileOnly project(path: ':commons')
     compileOnly files(Jvm.current().getToolsJar())
     implementation 'com.google.auto.value:auto-value-annotations:1.7.4'
diff --git a/database/build.gradle b/database/build.gradle
index 9c09f24..d7134b0 100644
--- a/database/build.gradle
+++ b/database/build.gradle
@@ -42,7 +42,7 @@ android {
 }
 
 dependencies {
-    api 'com.github.android-promise.database:commons:dev-4cc181146c-1'
+    api 'com.github.android-promise.database:commons:1.0.3-alpha7'
     //api project(path: ':commons')
     api 'androidx.sqlite:sqlite:2.1.0'
     implementation 'androidx.sqlite:sqlite-framework:2.1.0'

From 14757e4087549d9a8274e8045409d6ef5b367ae9 Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Thu, 20 Aug 2020 04:22:58 +0300
Subject: [PATCH 29/34] updated readme

---
 .gitignore        |   1 +
 README.md         | 339 +++++-------------
 blueprint.md      | 523 +++++++++++++++++++++++++++
 package-lock.json | 886 ++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 1492 insertions(+), 257 deletions(-)
 create mode 100644 blueprint.md
 create mode 100644 package-lock.json

diff --git a/.gitignore b/.gitignore
index 1c60545..283edf3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,5 +9,6 @@
 /build
 /captures
 .externalNativeBuild
+/node_modules
 
 
diff --git a/README.md b/README.md
index e49c2db..48ca931 100644
--- a/README.md
+++ b/README.md
@@ -1,9 +1,14 @@
-# Android Promise Database [![](https://jitpack.io/v/android-promise/database.svg)](https://jitpack.io/#android-promise/database)
- Manage SqLite databases in android with ease
 
-# Table of Contents
+[![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#android-promise-database-httpsjitpackiovandroid-promisedatabasesvghttpsjitpackioandroid-promisedatabase)
+
+# ➤ Android Promise Database [![](https://jitpack.io/v/android-promise/database.svg)](https://jitpack.io/#android-promise/database)
+ Manage SqLite databases in android with ease by It mapping Pojo and data classes to the SQlite tables, In most of database interactions, most queries are generated at runtime.
+
+
+[![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#table-of-contents)
+
+# ➤ Table of Contents
 
-**[Sample](##Sample)**<br>
 ***[Entity](***Entity)***<br>
 ***[Database](###Database)***<br>
 ***[TypeConverter](###TypeConverter)***<br>
@@ -13,15 +18,18 @@
 **[Setup](##Setup)**<br>
 **[Next Steps, Credits, Feedback, License](#next-steps)**<br>
 
-## Sample
+
+[![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#sample)
+
 ### Entity
-Pojo classes to be persisted are annotated with @Entity
-The classes can either implement Identifiable<Integer> or extend from ActiveRecord
-This classes must hava a no args constructor or no constructors at all
+Pojo classes to be persisted are annotated with `@Entity`
+
+The classes can either implement `Identifiable<Integer>` or extend from `ActiveRecord`
+
+**This classes must hava a no args constructor or no constructors at all**
 
 > Optionally add the table name in the annotation
 
-#### Photo Class
 ```kotlin
 
 @SuppressLint("ParcelCreator")
@@ -37,48 +45,7 @@ class Photo: ActiveRecord<Photo>() {
 
 	override fun getEntity(): Photo {
 		return this
-	}
-
-}
-  
-}
-```
-#### Todo Class
-```java
-
-@SuppressLint("ParcelCreator")
-@Entity
-public class Todo extends ActiveRecord<Todo> {
-	private int uid;
-	private boolean completed;
-	private String title;
-  private int userId;
-  
-  // denotes a todo item has one photo record
-	@HasOne
-  private Photo photo;
-  // include parcelable implementation if extending from ActiveRecord
-  
-}
-```
-#### Post Class
-```java
-
-@SuppressLint("ParcelCreator")
-@Entity
-public class Post extends ActiveRecord<Post> {
-	private ID uId;
-	private String title;
-	private String body;
-	private int userId;
-
-  // denotes a post has many post comments
-	@HasMany
-	private List<PostComment> comments;
-
-  // denotes a post has many photos
-	@HasMany
-	private List<Photo> photos;
+	}  
 }
 ```
 
@@ -86,10 +53,13 @@ public class Post extends ActiveRecord<Post> {
 
 > BOOLEAN fields MUST NOT start with `is`
 
+> Kotlin data classes are not supported yet 
+
 ### Database
-Database classe is annotated with @DatabaseEntity and contain a list
+Database classe is annotated with `@DatabaseEntity` and contain a list
 of persistable entity classes
-The class must be abstract and extend from PromiseDatabase
+
+*The class must be abstract and extend from `PromiseDatabase`*
 > **There can only be one database class in a module**
 ```kotlin
 @DatabaseEntity(
@@ -97,39 +67,55 @@ The class must be abstract and extend from PromiseDatabase
       PostComment::class,
       Photo::class,
       Post::class,
-      Todo::class
+      Todo::class,
+      Like::class
     ]
 )
 abstract class AppDatabase(fastDatabase: FastDatabase)
-  : PromiseDatabase(fastDatabase)
-```
+  : PromiseDatabase(fastDatabase) {
 
-Rebuild your project to generate database implementation
+  init {
+    fastDatabase.accept(object : Visitor<FastDatabase, Unit> {
+      override fun visit(t: FastDatabase) {
+        t.setErrorHandler {
+          LogUtil.e(TAG, "database error: ${it.path}")
+        }
+        t.fallBackToDestructiveMigration()
+      }
+    })
+  }
+
+  companion object {
+    val TAG: String = LogUtil.makeTag(AppDatabase::class.java)
+  }
+}
+```
+*Rebuild your project to generate database implementation*
 
 ### TypeConverter
-A type converter is a utility that helps to convert fields not directly persistable to persistable,
+A type converter is a utility that helps to convert fields not directly persistable to be persistable by converting to and from String,
 For instance the Post entity has named uId with a type
 ```kotlin
 data class ID(val id: String)
 ```
-To make the uId field persistable, we provide a type converter
+To make the uId field persistable, provide a type converter
 ```kotlin
 @TypeConverter
 class AppTypeConverter {
-
   fun toUniqueId(data: String): ID = ID(data)
-
   fun toString(data: ID?): String = data?.id ?: ""
-
 }
 ```
-A type converter must be annotated with @TypeConverter and contain non static methods that converts between the non persistable type to a string and vice verser
-Conversion methods in a type converter should have only one parameter and must return
-` Type converter is not for fields that are relations`
+A type converter must be annotated with `@TypeConverter` and contain *non static* methods that converts between the non persistable type to a string and vice verser
+Methods in a type converter should have only one parameter and must return
+
+*Type converter is not for fields that are relations*
+
 **There can only be one type converter in one module**
 
 > Without a type converter provision, the compiler will not generate columns for non persistable fields
 
+
 ### Relations
 
 #### HasOne Relation
@@ -139,49 +125,39 @@ Denotes one entity has one other entity, a sample
 public class Todo extends ActiveRecord<Todo> {
   // other fields
 	...
-
   // denotes this todo has one photo
   @HasOne
   private Photo photo;
 }
 ```
-To utilize the relation, the compiler will generate a class called TodoRelationsDao with convenient methods, a snippet of generated code below
+To utilize the relation, the compiler will generate a class called `TodoRelationsDao` with convenient methods, a snippet of generated code below
 ```java
-
 public final class TodoRelationsDao {
   private TodoesTable todoesTable;
-
   private PhotosTable photosTable;
-
   private TodoRelationsDao(TodoesTable todoesTable, PhotosTable photosTable) {
     this.todoesTable = todoesTable;
     this.photosTable = photosTable;
   }
-
   public IdentifiableList<? extends Todo> paginateWithPhotos(int skip, int limit) {
     IdentifiableList<? extends Todo> todoes = todoesTable.find().paginateDescending(skip, limit);
     return populateWithPhotos(todoes);
   }
-
   ...
   // other convenient methods
   ...
-  
   public Photo getPhoto(Todo todo) {
     return photosTable.findById(todo.getPhoto().getId());
   }
-
 }
 ```
-Instances of RelationDaos are retrieved from the generated database class
+
+> Instances of RelationDaos are retrieved from the generated database class
 
 
 #### HasMany Relation
 Denotes one entity has many entities of same type and the other entity has one entity of this type, a sample a post has many post comments and a post comment has one post
-
-Post Entity
 ```java
-
 @Entity
 public class Post extends ActiveRecord<Post> {
   // other fields
@@ -189,49 +165,30 @@ public class Post extends ActiveRecord<Post> {
 	@HasMany
   private List<PostComment> comments;
 }
-
 ```
-PostComment Entity
 ```java
 @SuppressLint("ParcelCreator")
 @Entity
 public class PostComment extends ActiveRecord<PostComment> {
   // other fields
 	...
-
 	@HasOne
   private Post post;
 }
 ```
 **Both relations must exist at the same time**
-To utilize the relation, the compiler will generate a class called PostRelationsDao with convenient methods, a snippet of generated code below
+To utilize the relation, the compiler will generate a class called `PostRelationsDao` with convenient methods, a snippet of generated code below
 ```java
-
 public final class PostRelationsDao {
   private PostsTable postsTable;
-
   private PostCommentsTable postCommentsTable;
-
   private PhotosTable photosTable;
-
   private PostRelationsDao(PostsTable postsTable, PostCommentsTable postCommentsTable,
       PhotosTable photosTable) {
     this.postsTable = postsTable;
     this.postCommentsTable = postCommentsTable;
     this.photosTable = photosTable;
   }
-
-  public IdentifiableList<? extends Post> paginateWithComments(int skip, int limit) {
-    IdentifiableList<? extends Post> posts = postsTable.find().paginateDescending(skip, limit);
-    posts.forEach(new Consumer<Post>() {
-      @Override
-      public void accept(Post post) {
-        post.setComments(new IdentifiableList<>(getComments(post)));
-      }
-    } );
-    return posts;
-  }
-
   public IdentifiableList<? extends Post> listWithComments() {
     IdentifiableList<? extends Post> posts = postsTable.findAll();
     posts.forEach(new Consumer<Post>() {
@@ -239,148 +196,21 @@ public final class PostRelationsDao {
       public void accept(Post post) {
         post.setComments(new IdentifiableList<>(getComments(post)));
       }
-    } );
+    });
     return posts;
   }
   ...
   // more convenience methods
 }
 ```
-Instances of RelationDaos are retrieved from the generated database class
-
-Snippet of RelationDao usage in main activity
-```kotlin
-...
-// generate 5 posts and each post 4 comments
-val posts = IdentifiableList(List.generate(5) {
-      Post().apply {
-        uId = ID(it.toString())
-        title = "post".plus(it)
-        body = "body".plus(it)
-        userId = it
-        comments = List.generate(4) {
-          PostComment().apply {
-            name = "nm".repeat(it)
-            uId = ID((it + 1).toString())
-            body = "hbytcvbcrxgfvbtrxt"
-            email = "ejmail;jgfccghcfcvhbhcgvb"
-          }
-        }
-      }
-    })
-
-  // save the posts
-   postRelationsDao.saveWithComments(posts)
-  // reading the posts
-   val posts1 = postRelationsDao.listWithComments()
-  // display the posts
-   complex_values_textview.text = posts1.toString()
-  // delete comments for each post and then delete the post
-   posts1.forEach {
-     postRelationsDao.deleteComments(it)
-     it.delete()
-   }
- ...
-```
 
+> Instances of RelationDaos are retrieved from the generated database class
 
 ### Initialization
-The compiler generates a database class for creating your database implementation and accesing tables
-and relation daos, sampled code from generated database file below
-
-```java
- /**
-   * Creates the simplest database with name specified
-   * @Param name the name of the database
-   */
-  public static AppDatabaseImpl createDatabase(String name) {
-    if (initialized) throw new IllegalStateException("Database already created");
-    initialized = true;
-    return new AppDatabaseImpl(FastDatabase.createDatabase(AppDatabaseImpl.class, name, getMigration()));
-  }
-
-  /**
-   * Creates the simplest database with name specified with callback
-   * Callback can be used to pre populate database with records or
-   * set flags like foreign keys
-   * @Param name the name of the database
-   * @Param databaseCreationCallback callback
-   */
-  public static AppDatabaseImpl createDatabase(String name,
-      DatabaseCreationCallback databaseCreationCallback) {
-    if (initialized) throw new IllegalStateException("Database already created");
-    initialized = true;
-    return new AppDatabaseImpl(FastDatabase.createDatabase(AppDatabaseImpl.class, name, getMigration(), databaseCreationCallback));
-  }
-
-  /**
-   * Creates an in memory database, useful for tests
-   */
-  public static AppDatabaseImpl createInMemoryDatabase() {
-    if (initialized) throw new IllegalStateException("Database already created");
-    initialized = true;
-    return new AppDatabaseImpl(FastDatabase.createInMemoryDatabase(AppDatabaseImpl.class));
-  }
+The compiler generates a database class, *In this case the case the generated java file will be named `AppDatabaseIimpl`* ,
 
-  /**
-   * Creates an in memory database, useful for tests
-   * Callback can be used to pre populate database with records or
-   * set flags like foreign keys
-   * @Param databaseCreationCallback callback
-   */
-  public static AppDatabaseImpl createInMemoryDatabase(
-      DatabaseCreationCallback databaseCreationCallback) {
-    if (initialized) throw new IllegalStateException("Database already created");
-    initialized = true;
-    return new AppDatabaseImpl(FastDatabase.createInMemoryDatabase(AppDatabaseImpl.class, databaseCreationCallback));
-  }
-
-  /**
-   * Creates an in memory database, enables calling rx DML functions in the tables
-   */
-  public static AppDatabaseImpl createReactiveInMemoryDatabase() {
-    if (initialized) throw new IllegalStateException("Database already created");
-    initialized = true;
-    return new AppDatabaseImpl(FastDatabase.createInMemoryReactiveDatabase(AppDatabaseImpl.class));
-  }
-
-  /**
-   * Creates an in memory database, enables calling rx DML functions in the tables
-   * Callback can be used to pre populate database with records or
-   * set flags like foreign keys
-   * @Param databaseCreationCallback callback
-   */
-  public static AppDatabaseImpl createReactiveInMemoryDatabase(
-      DatabaseCreationCallback databaseCreationCallback) {
-    if (initialized) throw new IllegalStateException("Database already created");
-    initialized = true;
-    return new AppDatabaseImpl(FastDatabase.createInMemoryReactiveDatabase(AppDatabaseImpl.class, databaseCreationCallback));
-  }
-
-  /**
-   * Creates database, that enables calling rx DML functions in the tables
-   * @Param name name of the database 
-   */
-  public static AppDatabaseImpl createReactiveDatabase(String name) {
-    if (initialized) throw new IllegalStateException("Database already created");
-     initialized = true;
-    return new AppDatabaseImpl(FastDatabase.createReactiveDatabase(AppDatabaseImpl.class, name, getMigration()));
-  }
-
-  /**
-   * Creates database, that enables calling rx DML functions in the tables
-   * Callback can be used to pre populate database with records or
-   * set flags like foreign keys
-   * @Param name name of the database 
-   * @Param databaseCreationCallback callback
-   */
-  public static AppDatabaseImpl createReactiveDatabase(String name,
-      DatabaseCreationCallback databaseCreationCallback) {
-    if (initialized) throw new IllegalStateException("Database already created");
-     initialized = true;
-    return new AppDatabaseImpl(FastDatabase.createReactiveDatabase(AppDatabaseImpl.class, name, getMigration(), databaseCreationCallback));
-  }
-```
+for creating your database implementation and accesing tables
+and relation daos, sampled code from generated database file below
 
 
 ### Migrations
@@ -388,52 +218,40 @@ and relation daos, sampled code from generated database file below
 #### Migrations For Entities
 Adding an entity to be persisted to the database from version 1 to version 2 of the database
 Annotate it with AddedEntity
-##### Sales Entity
 ```java
-
 @Entity
 // register it for migration from version 1 of database to version 2
 @AddedEntity(fromVersion = 1, toVersion = 2)
 public class Sales extends ActiveRecord<Sales> {
-
   private String salesId;
   private double salePrice;
-
   @Text(columnName = "descrip", nullable = false)
   private String description;
-
   @Index
   private String pickupDate;
   // other fields follow
-
   public Sales() {
   }
 }
   // getters and setters and parcelable implementation
 ```
 And then add the new entity to the database and upgrade database version to 2
-
 ```kotlin
-
 @DatabaseEntity(
-   
     persistableEntities = [
       /// other entities
       Sales::class
     ],
     version = 2
 )
-
 abstract class AppDatabase(fastDatabase: FastDatabase) : PromiseDatabase(fastDatabas) 
 ```
 
-Adding columns to an existing entity, annotate the new field with Migrate, a migration will be generated by the compiler >
-
 #### Migrations For Columns
-Annotate the added field with @Migrate and include fromVersion and toVersion
-If a field is to pass multiple migrations, annotate it with @Migrations and add the migrate annotations in the 
+The compiler generates this migrations on the fly otherwise you may still do it manually by
+annotating the added field with `@Migrate` and include fromVersion and toVersion
+If a field is to pass multiple migrations, annotate it with `@Migrations` and add the migrate annotations in the 
 migrations annotation
-##### Sales Entity
 ```java
 ...
   // added new field
@@ -442,10 +260,12 @@ migrations annotation
 ...
 ```
 
-## Setup
+[![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#setup)
+
+## ➤ Setup
 ##### Project level build.gradle
 Add jitpack repository
-```
+```gradle
 allprojects {
     repositories {
         ...
@@ -456,7 +276,7 @@ allprojects {
 ```
 ##### Module level build.gradle
 Compile with java 8, add rxJava dependency of using rx DML functions in the tables
-```
+```gradle
 android {
     ...
     compileOptions {
@@ -467,15 +287,13 @@ android {
 
 dependencies {
      ...
-     implementation 'com.github.android-promise.database:database:1.0.3-alpha5'
-     kapt 'com.github.android-promise.database:compiler:1.0.3-alpha5'
+     implementation 'com.github.android-promise.database:database:1.0.3-alpha8'
+     kapt 'com.github.android-promise.database:compiler:1.0.3-alpha8'
      implementation 'com.github.android-promise:commons:1.1-alpha03'
 }
 ```
 ##### Initialization
 Initialize Promise in your main application class
-
-##### App.java
 ```java
 public class App extends Application {
   @Override
@@ -483,7 +301,6 @@ public class App extends Application {
     super.onCreate();
     AndroidPromise.init(this, BuildConfig.DEBUG);
   }
-
   @Override
   public void onTerminate() {
     super.onTerminate();
@@ -492,20 +309,28 @@ public class App extends Application {
 }
 ```
 
-## New features on the way
+[![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#new-features-on-the-way)
+
+## ➤ New features on the way
 watch this repo to stay updated 
 
-# Developed By
+[![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#developed-by)
+
+# ➤ Developed By
 * Peter Vincent - [Portfolio](https://dev4vin.github.io/info)
 
-# Donations
+[![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#donations)
+
+# ➤ Donations
 If you'd like to support this library development, you could buy me coffee here:
 * [![Become a Patreon]("https://c6.patreon.com/becomePatronButton.bundle.js")](https://www.patreon.com/bePatron?u=31932751)
 
 #### Pull requests / Issues / Improvement requests
 Feel free to contribute and ask!<br/>
 
-# License
+[![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#license)
+
+# ➤ License
 
     Copyright 2018 Android Promise Database
 
diff --git a/blueprint.md b/blueprint.md
new file mode 100644
index 0000000..e49c2db
--- /dev/null
+++ b/blueprint.md
@@ -0,0 +1,523 @@
+# Android Promise Database [![](https://jitpack.io/v/android-promise/database.svg)](https://jitpack.io/#android-promise/database)
+ Manage SqLite databases in android with ease
+
+# Table of Contents
+
+**[Sample](##Sample)**<br>
+***[Entity](***Entity)***<br>
+***[Database](###Database)***<br>
+***[TypeConverter](###TypeConverter)***<br>
+***[Relations](###Relations)***<br>
+***[Initialization](###Initialization)***<br>
+***[Migrations](###Migrations)***<br>
+**[Setup](##Setup)**<br>
+**[Next Steps, Credits, Feedback, License](#next-steps)**<br>
+
+## Sample
+### Entity
+Pojo classes to be persisted are annotated with @Entity
+The classes can either implement Identifiable<Integer> or extend from ActiveRecord
+This classes must hava a no args constructor or no constructors at all
+
+> Optionally add the table name in the annotation
+
+#### Photo Class
+```kotlin
+
+@SuppressLint("ParcelCreator")
+@Entity
+class Photo: ActiveRecord<Photo>() {
+	var albumId: Int? = null
+	var title: String? = null
+	var url: String? = null
+	var thumbnailUrl: String? = null
+
+  // denotes a photo has one post
+	@HasOne var post: Post? = null
+
+	override fun getEntity(): Photo {
+		return this
+	}
+
+}
+  
+}
+```
+#### Todo Class
+```java
+
+@SuppressLint("ParcelCreator")
+@Entity
+public class Todo extends ActiveRecord<Todo> {
+	private int uid;
+	private boolean completed;
+	private String title;
+  private int userId;
+  
+  // denotes a todo item has one photo record
+	@HasOne
+  private Photo photo;
+  // include parcelable implementation if extending from ActiveRecord
+  
+}
+```
+#### Post Class
+```java
+
+@SuppressLint("ParcelCreator")
+@Entity
+public class Post extends ActiveRecord<Post> {
+	private ID uId;
+	private String title;
+	private String body;
+	private int userId;
+
+  // denotes a post has many post comments
+	@HasMany
+	private List<PostComment> comments;
+
+  // denotes a post has many photos
+	@HasMany
+	private List<Photo> photos;
+}
+```
+
+> Include correct getter and setter signatures for Java file or generated code will not compile, including fields convertable via type converter and fields marked as relation
+
+> BOOLEAN fields MUST NOT start with `is`
+
+### Database
+Database classe is annotated with @DatabaseEntity and contain a list
+of persistable entity classes
+The class must be abstract and extend from PromiseDatabase
+> **There can only be one database class in a module**
+```kotlin
+@DatabaseEntity(
+    persistableEntities = [
+      PostComment::class,
+      Photo::class,
+      Post::class,
+      Todo::class
+    ]
+)
+abstract class AppDatabase(fastDatabase: FastDatabase)
+  : PromiseDatabase(fastDatabase)
+```
+
+Rebuild your project to generate database implementation
+
+### TypeConverter
+A type converter is a utility that helps to convert fields not directly persistable to persistable,
+For instance the Post entity has named uId with a type
+```kotlin
+data class ID(val id: String)
+```
+To make the uId field persistable, we provide a type converter
+```kotlin
+@TypeConverter
+class AppTypeConverter {
+
+  fun toUniqueId(data: String): ID = ID(data)
+
+  fun toString(data: ID?): String = data?.id ?: ""
+
+}
+```
+A type converter must be annotated with @TypeConverter and contain non static methods that converts between the non persistable type to a string and vice verser
+Conversion methods in a type converter should have only one parameter and must return
+` Type converter is not for fields that are relations`
+**There can only be one type converter in one module**
+
+> Without a type converter provision, the compiler will not generate columns for non persistable fields
+
+### Relations
+
+#### HasOne Relation
+Denotes one entity has one other entity, a sample
+```java
+@Entity
+public class Todo extends ActiveRecord<Todo> {
+  // other fields
+	...
+
+  // denotes this todo has one photo
+  @HasOne
+  private Photo photo;
+}
+```
+To utilize the relation, the compiler will generate a class called TodoRelationsDao with convenient methods, a snippet of generated code below
+```java
+
+public final class TodoRelationsDao {
+  private TodoesTable todoesTable;
+
+  private PhotosTable photosTable;
+
+  private TodoRelationsDao(TodoesTable todoesTable, PhotosTable photosTable) {
+    this.todoesTable = todoesTable;
+    this.photosTable = photosTable;
+  }
+
+  public IdentifiableList<? extends Todo> paginateWithPhotos(int skip, int limit) {
+    IdentifiableList<? extends Todo> todoes = todoesTable.find().paginateDescending(skip, limit);
+    return populateWithPhotos(todoes);
+  }
+
+  ...
+  // other convenient methods
+  ...
+  
+  public Photo getPhoto(Todo todo) {
+    return photosTable.findById(todo.getPhoto().getId());
+  }
+
+}
+```
+Instances of RelationDaos are retrieved from the generated database class
+
+
+#### HasMany Relation
+Denotes one entity has many entities of same type and the other entity has one entity of this type, a sample a post has many post comments and a post comment has one post
+
+Post Entity
+```java
+
+@Entity
+public class Post extends ActiveRecord<Post> {
+  // other fields
+	...
+	@HasMany
+  private List<PostComment> comments;
+}
+
+```
+PostComment Entity
+```java
+@SuppressLint("ParcelCreator")
+@Entity
+public class PostComment extends ActiveRecord<PostComment> {
+  // other fields
+	...
+
+	@HasOne
+  private Post post;
+}
+```
+**Both relations must exist at the same time**
+To utilize the relation, the compiler will generate a class called PostRelationsDao with convenient methods, a snippet of generated code below
+```java
+
+public final class PostRelationsDao {
+  private PostsTable postsTable;
+
+  private PostCommentsTable postCommentsTable;
+
+  private PhotosTable photosTable;
+
+  private PostRelationsDao(PostsTable postsTable, PostCommentsTable postCommentsTable,
+      PhotosTable photosTable) {
+    this.postsTable = postsTable;
+    this.postCommentsTable = postCommentsTable;
+    this.photosTable = photosTable;
+  }
+
+  public IdentifiableList<? extends Post> paginateWithComments(int skip, int limit) {
+    IdentifiableList<? extends Post> posts = postsTable.find().paginateDescending(skip, limit);
+    posts.forEach(new Consumer<Post>() {
+      @Override
+      public void accept(Post post) {
+        post.setComments(new IdentifiableList<>(getComments(post)));
+      }
+    } );
+    return posts;
+  }
+
+  public IdentifiableList<? extends Post> listWithComments() {
+    IdentifiableList<? extends Post> posts = postsTable.findAll();
+    posts.forEach(new Consumer<Post>() {
+      @Override
+      public void accept(Post post) {
+        post.setComments(new IdentifiableList<>(getComments(post)));
+      }
+    } );
+    return posts;
+  }
+  ...
+  // more convenience methods
+}
+```
+Instances of RelationDaos are retrieved from the generated database class
+
+Snippet of RelationDao usage in main activity
+```kotlin
+...
+// generate 5 posts and each post 4 comments
+val posts = IdentifiableList(List.generate(5) {
+      Post().apply {
+        uId = ID(it.toString())
+        title = "post".plus(it)
+        body = "body".plus(it)
+        userId = it
+        comments = List.generate(4) {
+          PostComment().apply {
+            name = "nm".repeat(it)
+            uId = ID((it + 1).toString())
+            body = "hbytcvbcrxgfvbtrxt"
+            email = "ejmail;jgfccghcfcvhbhcgvb"
+          }
+        }
+      }
+    })
+
+  // save the posts
+   postRelationsDao.saveWithComments(posts)
+  // reading the posts
+   val posts1 = postRelationsDao.listWithComments()
+  // display the posts
+   complex_values_textview.text = posts1.toString()
+  // delete comments for each post and then delete the post
+   posts1.forEach {
+     postRelationsDao.deleteComments(it)
+     it.delete()
+   }
+ ...
+```
+
+
+### Initialization
+The compiler generates a database class for creating your database implementation and accesing tables
+and relation daos, sampled code from generated database file below
+
+```java
+ /**
+   * Creates the simplest database with name specified
+   * @Param name the name of the database
+   */
+  public static AppDatabaseImpl createDatabase(String name) {
+    if (initialized) throw new IllegalStateException("Database already created");
+    initialized = true;
+    return new AppDatabaseImpl(FastDatabase.createDatabase(AppDatabaseImpl.class, name, getMigration()));
+  }
+
+  /**
+   * Creates the simplest database with name specified with callback
+   * Callback can be used to pre populate database with records or
+   * set flags like foreign keys
+   * @Param name the name of the database
+   * @Param databaseCreationCallback callback
+   */
+  public static AppDatabaseImpl createDatabase(String name,
+      DatabaseCreationCallback databaseCreationCallback) {
+    if (initialized) throw new IllegalStateException("Database already created");
+    initialized = true;
+    return new AppDatabaseImpl(FastDatabase.createDatabase(AppDatabaseImpl.class, name, getMigration(), databaseCreationCallback));
+  }
+
+  /**
+   * Creates an in memory database, useful for tests
+   */
+  public static AppDatabaseImpl createInMemoryDatabase() {
+    if (initialized) throw new IllegalStateException("Database already created");
+    initialized = true;
+    return new AppDatabaseImpl(FastDatabase.createInMemoryDatabase(AppDatabaseImpl.class));
+  }
+
+  /**
+   * Creates an in memory database, useful for tests
+   * Callback can be used to pre populate database with records or
+   * set flags like foreign keys
+   * @Param databaseCreationCallback callback
+   */
+  public static AppDatabaseImpl createInMemoryDatabase(
+      DatabaseCreationCallback databaseCreationCallback) {
+    if (initialized) throw new IllegalStateException("Database already created");
+    initialized = true;
+    return new AppDatabaseImpl(FastDatabase.createInMemoryDatabase(AppDatabaseImpl.class, databaseCreationCallback));
+  }
+
+  /**
+   * Creates an in memory database, enables calling rx DML functions in the tables
+   */
+  public static AppDatabaseImpl createReactiveInMemoryDatabase() {
+    if (initialized) throw new IllegalStateException("Database already created");
+    initialized = true;
+    return new AppDatabaseImpl(FastDatabase.createInMemoryReactiveDatabase(AppDatabaseImpl.class));
+  }
+
+  /**
+   * Creates an in memory database, enables calling rx DML functions in the tables
+   * Callback can be used to pre populate database with records or
+   * set flags like foreign keys
+   * @Param databaseCreationCallback callback
+   */
+  public static AppDatabaseImpl createReactiveInMemoryDatabase(
+      DatabaseCreationCallback databaseCreationCallback) {
+    if (initialized) throw new IllegalStateException("Database already created");
+    initialized = true;
+    return new AppDatabaseImpl(FastDatabase.createInMemoryReactiveDatabase(AppDatabaseImpl.class, databaseCreationCallback));
+  }
+
+  /**
+   * Creates database, that enables calling rx DML functions in the tables
+   * @Param name name of the database 
+   */
+  public static AppDatabaseImpl createReactiveDatabase(String name) {
+    if (initialized) throw new IllegalStateException("Database already created");
+     initialized = true;
+    return new AppDatabaseImpl(FastDatabase.createReactiveDatabase(AppDatabaseImpl.class, name, getMigration()));
+  }
+
+  /**
+   * Creates database, that enables calling rx DML functions in the tables
+   * Callback can be used to pre populate database with records or
+   * set flags like foreign keys
+   * @Param name name of the database 
+   * @Param databaseCreationCallback callback
+   */
+  public static AppDatabaseImpl createReactiveDatabase(String name,
+      DatabaseCreationCallback databaseCreationCallback) {
+    if (initialized) throw new IllegalStateException("Database already created");
+     initialized = true;
+    return new AppDatabaseImpl(FastDatabase.createReactiveDatabase(AppDatabaseImpl.class, name, getMigration(), databaseCreationCallback));
+  }
+```
+
+
+### Migrations
+
+#### Migrations For Entities
+Adding an entity to be persisted to the database from version 1 to version 2 of the database
+Annotate it with AddedEntity
+##### Sales Entity
+```java
+
+@Entity
+// register it for migration from version 1 of database to version 2
+@AddedEntity(fromVersion = 1, toVersion = 2)
+public class Sales extends ActiveRecord<Sales> {
+
+  private String salesId;
+  private double salePrice;
+
+  @Text(columnName = "descrip", nullable = false)
+  private String description;
+
+  @Index
+  private String pickupDate;
+  // other fields follow
+
+  public Sales() {
+  }
+}
+  // getters and setters and parcelable implementation
+```
+And then add the new entity to the database and upgrade database version to 2
+
+```kotlin
+
+@DatabaseEntity(
+   
+    persistableEntities = [
+      /// other entities
+      Sales::class
+    ],
+    version = 2
+)
+
+abstract class AppDatabase(fastDatabase: FastDatabase) : PromiseDatabase(fastDatabas) 
+```
+
+Adding columns to an existing entity, annotate the new field with Migrate, a migration will be generated by the compiler >
+
+#### Migrations For Columns
+Annotate the added field with @Migrate and include fromVersion and toVersion
+If a field is to pass multiple migrations, annotate it with @Migrations and add the migrate annotations in the 
+migrations annotation
+##### Sales Entity
+```java
+...
+  // added new field
+  @Migrate(fromVersion = 2, toVersion = 3, action = MigrationOptions.CREATE)
+  private String status;
+...
+```
+
+## Setup
+##### Project level build.gradle
+Add jitpack repository
+```
+allprojects {
+    repositories {
+        ...
+        maven { url 'https://jitpack.io' }
+    }
+}
+
+```
+##### Module level build.gradle
+Compile with java 8, add rxJava dependency of using rx DML functions in the tables
+```
+android {
+    ...
+    compileOptions {
+            sourceCompatibility JavaVersion.VERSION_1_8
+            targetCompatibility JavaVersion.VERSION_1_8
+        }
+}
+
+dependencies {
+     ...
+     implementation 'com.github.android-promise.database:database:1.0.3-alpha5'
+     kapt 'com.github.android-promise.database:compiler:1.0.3-alpha5'
+     implementation 'com.github.android-promise:commons:1.1-alpha03'
+}
+```
+##### Initialization
+Initialize Promise in your main application class
+
+##### App.java
+```java
+public class App extends Application {
+  @Override
+  public void onCreate() {
+    super.onCreate();
+    AndroidPromise.init(this, BuildConfig.DEBUG);
+  }
+
+  @Override
+  public void onTerminate() {
+    super.onTerminate();
+    AndroidPromise.instance().terminate();
+  }
+}
+```
+
+## New features on the way
+watch this repo to stay updated 
+
+# Developed By
+* Peter Vincent - [Portfolio](https://dev4vin.github.io/info)
+
+# Donations
+If you'd like to support this library development, you could buy me coffee here:
+* [![Become a Patreon]("https://c6.patreon.com/becomePatronButton.bundle.js")](https://www.patreon.com/bePatron?u=31932751)
+
+#### Pull requests / Issues / Improvement requests
+Feel free to contribute and ask!<br/>
+
+# License
+
+    Copyright 2018 Android Promise Database
+
+    Licensed under the Apache License, Version 2.0 Android Promise;
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
diff --git a/package-lock.json b/package-lock.json
new file mode 100644
index 0000000..e8ee5ed
--- /dev/null
+++ b/package-lock.json
@@ -0,0 +1,886 @@
+{
+  "requires": true,
+  "lockfileVersion": 1,
+  "dependencies": {
+    "@appnest/readme": {
+      "version": "1.2.7",
+      "resolved": "https://registry.npmjs.org/@appnest/readme/-/readme-1.2.7.tgz",
+      "integrity": "sha512-Gf60vp2sws3rIaz5SGUPmSBA49z/SC3qej0B83TvAttX5CXO26/QU49SfzKI8xNjU9HJCTgQ3mHm1vB2ZY5Mzg==",
+      "dev": true,
+      "requires": {
+        "@types/glob": "^7.1.1",
+        "check-links": "^1.1.8",
+        "colors": "^1.4.0",
+        "commander": "^5.0.0",
+        "fs-extra": "^9.0.0",
+        "glob": "^7.1.6",
+        "path": "^0.12.7",
+        "web-component-analyzer": "1.0.3"
+      }
+    },
+    "@nodelib/fs.scandir": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.3.tgz",
+      "integrity": "sha512-eGmwYQn3gxo4r7jdQnkrrN6bY478C3P+a/y72IJukF8LjB6ZHeB3c+Ehacj3sYeSmUXGlnA67/PmbM9CVwL7Dw==",
+      "dev": true,
+      "requires": {
+        "@nodelib/fs.stat": "2.0.3",
+        "run-parallel": "^1.1.9"
+      }
+    },
+    "@nodelib/fs.stat": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.3.tgz",
+      "integrity": "sha512-bQBFruR2TAwoevBEd/NWMoAAtNGzTRgdrqnYCc7dhzfoNvqPzLyqlEQnzZ3kVnNrSp25iyxE00/3h2fqGAGArA==",
+      "dev": true
+    },
+    "@nodelib/fs.walk": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.4.tgz",
+      "integrity": "sha512-1V9XOY4rDW0rehzbrcqAmHnz8e7SKvX27gh8Gt2WgB0+pdzdiLV83p72kZPU+jvMbS1qU5mauP2iOvO8rhmurQ==",
+      "dev": true,
+      "requires": {
+        "@nodelib/fs.scandir": "2.1.3",
+        "fastq": "^1.6.0"
+      }
+    },
+    "@sindresorhus/is": {
+      "version": "0.14.0",
+      "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-0.14.0.tgz",
+      "integrity": "sha512-9NET910DNaIPngYnLLPeg+Ogzqsi9uM4mSboU5y6p8S5DzMTVEsJZrawi+BoDNUVBa2DhJqQYUFvMDfgU062LQ==",
+      "dev": true
+    },
+    "@szmarczak/http-timer": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@szmarczak/http-timer/-/http-timer-1.1.2.tgz",
+      "integrity": "sha512-XIB2XbzHTN6ieIjfIMV9hlVcfPU26s2vafYWQcZHWXHOxiaRZYEDKEwdl129Zyg50+foYV2jCgtrqSA6qNuNSA==",
+      "dev": true,
+      "requires": {
+        "defer-to-connect": "^1.0.1"
+      }
+    },
+    "@types/color-name": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@types/color-name/-/color-name-1.1.1.tgz",
+      "integrity": "sha512-rr+OQyAjxze7GgWrSaJwydHStIhHq2lvY3BOC2Mj7KnzI7XK0Uw1TOOdI9lDoajEbSWLiYgoo4f1R51erQfhPQ==",
+      "dev": true
+    },
+    "@types/glob": {
+      "version": "7.1.3",
+      "resolved": "https://registry.npmjs.org/@types/glob/-/glob-7.1.3.tgz",
+      "integrity": "sha512-SEYeGAIQIQX8NN6LDKprLjbrd5dARM5EXsd8GI/A5l0apYI1fGMWgPHSe4ZKL4eozlAyI+doUE9XbYS4xCkQ1w==",
+      "dev": true,
+      "requires": {
+        "@types/minimatch": "*",
+        "@types/node": "*"
+      }
+    },
+    "@types/minimatch": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/@types/minimatch/-/minimatch-3.0.3.tgz",
+      "integrity": "sha512-tHq6qdbT9U1IRSGf14CL0pUlULksvY9OZ+5eEgl1N7t+OA3tGvNpxJCzuKQlsNgCVwbAs670L1vcVQi8j9HjnA==",
+      "dev": true
+    },
+    "@types/node": {
+      "version": "14.6.0",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-14.6.0.tgz",
+      "integrity": "sha512-mikldZQitV94akrc4sCcSjtJfsTKt4p+e/s0AGscVA6XArQ9kFclP+ZiYUMnq987rc6QlYxXv/EivqlfSLxpKA==",
+      "dev": true
+    },
+    "ansi-regex": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.0.tgz",
+      "integrity": "sha512-bY6fj56OUQ0hU1KjFNDQuJFezqKdrAyFdIevADiqrWHwSlbmBNMHp5ak2f40Pm8JTFyM2mqxkG6ngkHO11f/lg==",
+      "dev": true
+    },
+    "ansi-styles": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.2.1.tgz",
+      "integrity": "sha512-9VGjrMsG1vePxcSweQsN20KY/c4zN0h9fLjqAbwbPfahM3t+NL+M9HC8xeXG2I8pX5NoamTGNuomEUFI7fcUjA==",
+      "dev": true,
+      "requires": {
+        "@types/color-name": "^1.1.1",
+        "color-convert": "^2.0.1"
+      }
+    },
+    "at-least-node": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/at-least-node/-/at-least-node-1.0.0.tgz",
+      "integrity": "sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==",
+      "dev": true
+    },
+    "balanced-match": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz",
+      "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=",
+      "dev": true
+    },
+    "brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "dev": true,
+      "requires": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "braces": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz",
+      "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==",
+      "dev": true,
+      "requires": {
+        "fill-range": "^7.0.1"
+      }
+    },
+    "cacheable-request": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/cacheable-request/-/cacheable-request-6.1.0.tgz",
+      "integrity": "sha512-Oj3cAGPCqOZX7Rz64Uny2GYAZNliQSqfbePrgAQ1wKAihYmCUnraBtJtKcGR4xz7wF+LoJC+ssFZvv5BgF9Igg==",
+      "dev": true,
+      "requires": {
+        "clone-response": "^1.0.2",
+        "get-stream": "^5.1.0",
+        "http-cache-semantics": "^4.0.0",
+        "keyv": "^3.0.0",
+        "lowercase-keys": "^2.0.0",
+        "normalize-url": "^4.1.0",
+        "responselike": "^1.0.2"
+      },
+      "dependencies": {
+        "get-stream": {
+          "version": "5.2.0",
+          "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz",
+          "integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==",
+          "dev": true,
+          "requires": {
+            "pump": "^3.0.0"
+          }
+        },
+        "lowercase-keys": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-2.0.0.tgz",
+          "integrity": "sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA==",
+          "dev": true
+        }
+      }
+    },
+    "camelcase": {
+      "version": "5.3.1",
+      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz",
+      "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==",
+      "dev": true
+    },
+    "check-links": {
+      "version": "1.1.8",
+      "resolved": "https://registry.npmjs.org/check-links/-/check-links-1.1.8.tgz",
+      "integrity": "sha512-lxt1EeQ1CVkmiZzPfbPufperYK0t7MvhdLs3zlRH9areA6NVT1tcGymAdJONolNWQBdCFU/sek59RpeLmVHCnw==",
+      "dev": true,
+      "requires": {
+        "got": "^9.6.0",
+        "is-relative-url": "^2.0.0",
+        "p-map": "^2.0.0",
+        "p-memoize": "^2.1.0"
+      }
+    },
+    "cliui": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-6.0.0.tgz",
+      "integrity": "sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ==",
+      "dev": true,
+      "requires": {
+        "string-width": "^4.2.0",
+        "strip-ansi": "^6.0.0",
+        "wrap-ansi": "^6.2.0"
+      }
+    },
+    "clone-response": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/clone-response/-/clone-response-1.0.2.tgz",
+      "integrity": "sha1-0dyXOSAxTfZ/vrlCI7TuNQI56Ws=",
+      "dev": true,
+      "requires": {
+        "mimic-response": "^1.0.0"
+      }
+    },
+    "color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "dev": true,
+      "requires": {
+        "color-name": "~1.1.4"
+      }
+    },
+    "color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "dev": true
+    },
+    "colors": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/colors/-/colors-1.4.0.tgz",
+      "integrity": "sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA==",
+      "dev": true
+    },
+    "commander": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-5.1.0.tgz",
+      "integrity": "sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg==",
+      "dev": true
+    },
+    "concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=",
+      "dev": true
+    },
+    "decamelize": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz",
+      "integrity": "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=",
+      "dev": true
+    },
+    "decompress-response": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-3.3.0.tgz",
+      "integrity": "sha1-gKTdMjdIOEv6JICDYirt7Jgq3/M=",
+      "dev": true,
+      "requires": {
+        "mimic-response": "^1.0.0"
+      }
+    },
+    "defer-to-connect": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-1.1.3.tgz",
+      "integrity": "sha512-0ISdNousHvZT2EiFlZeZAHBUvSxmKswVCEf8hW7KWgG4a8MVEu/3Vb6uWYozkjylyCxe0JBIiRB1jV45S70WVQ==",
+      "dev": true
+    },
+    "duplexer3": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/duplexer3/-/duplexer3-0.1.4.tgz",
+      "integrity": "sha1-7gHdHKwO08vH/b6jfcCo8c4ALOI=",
+      "dev": true
+    },
+    "emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "dev": true
+    },
+    "end-of-stream": {
+      "version": "1.4.4",
+      "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.4.tgz",
+      "integrity": "sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==",
+      "dev": true,
+      "requires": {
+        "once": "^1.4.0"
+      }
+    },
+    "fast-glob": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.2.4.tgz",
+      "integrity": "sha512-kr/Oo6PX51265qeuCYsyGypiO5uJFgBS0jksyG7FUeCyQzNwYnzrNIMR1NXfkZXsMYXYLRAHgISHBz8gQcxKHQ==",
+      "dev": true,
+      "requires": {
+        "@nodelib/fs.stat": "^2.0.2",
+        "@nodelib/fs.walk": "^1.2.3",
+        "glob-parent": "^5.1.0",
+        "merge2": "^1.3.0",
+        "micromatch": "^4.0.2",
+        "picomatch": "^2.2.1"
+      }
+    },
+    "fastq": {
+      "version": "1.8.0",
+      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.8.0.tgz",
+      "integrity": "sha512-SMIZoZdLh/fgofivvIkmknUXyPnvxRE3DhtZ5Me3Mrsk5gyPL42F0xr51TdRXskBxHfMp+07bcYzfsYEsSQA9Q==",
+      "dev": true,
+      "requires": {
+        "reusify": "^1.0.4"
+      }
+    },
+    "fill-range": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
+      "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==",
+      "dev": true,
+      "requires": {
+        "to-regex-range": "^5.0.1"
+      }
+    },
+    "find-up": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz",
+      "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==",
+      "dev": true,
+      "requires": {
+        "locate-path": "^5.0.0",
+        "path-exists": "^4.0.0"
+      }
+    },
+    "fs-extra": {
+      "version": "9.0.1",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.0.1.tgz",
+      "integrity": "sha512-h2iAoN838FqAFJY2/qVpzFXy+EBxfVE220PalAqQLDVsFOHLJrZvut5puAbCdNv6WJk+B8ihI+k0c7JK5erwqQ==",
+      "dev": true,
+      "requires": {
+        "at-least-node": "^1.0.0",
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^1.0.0"
+      }
+    },
+    "fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=",
+      "dev": true
+    },
+    "get-caller-file": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+      "dev": true
+    },
+    "get-stream": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-4.1.0.tgz",
+      "integrity": "sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w==",
+      "dev": true,
+      "requires": {
+        "pump": "^3.0.0"
+      }
+    },
+    "glob": {
+      "version": "7.1.6",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz",
+      "integrity": "sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==",
+      "dev": true,
+      "requires": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.0.4",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      }
+    },
+    "glob-parent": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.1.tgz",
+      "integrity": "sha512-FnI+VGOpnlGHWZxthPGR+QhR78fuiK0sNLkHQv+bL9fQi57lNNdquIbna/WrfROrolq8GK5Ek6BiMwqL/voRYQ==",
+      "dev": true,
+      "requires": {
+        "is-glob": "^4.0.1"
+      }
+    },
+    "got": {
+      "version": "9.6.0",
+      "resolved": "https://registry.npmjs.org/got/-/got-9.6.0.tgz",
+      "integrity": "sha512-R7eWptXuGYxwijs0eV+v3o6+XH1IqVK8dJOEecQfTmkncw9AV4dcw/Dhxi8MdlqPthxxpZyizMzyg8RTmEsG+Q==",
+      "dev": true,
+      "requires": {
+        "@sindresorhus/is": "^0.14.0",
+        "@szmarczak/http-timer": "^1.1.2",
+        "cacheable-request": "^6.0.0",
+        "decompress-response": "^3.3.0",
+        "duplexer3": "^0.1.4",
+        "get-stream": "^4.1.0",
+        "lowercase-keys": "^1.0.1",
+        "mimic-response": "^1.0.1",
+        "p-cancelable": "^1.0.0",
+        "to-readable-stream": "^1.0.0",
+        "url-parse-lax": "^3.0.0"
+      }
+    },
+    "graceful-fs": {
+      "version": "4.2.4",
+      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.4.tgz",
+      "integrity": "sha512-WjKPNJF79dtJAVniUlGGWHYGz2jWxT6VhN/4m1NdkbZ2nOsEF+cI1Edgql5zCRhs/VsQYRvrXctxktVXZUkixw==",
+      "dev": true
+    },
+    "http-cache-semantics": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.1.0.tgz",
+      "integrity": "sha512-carPklcUh7ROWRK7Cv27RPtdhYhUsela/ue5/jKzjegVvXDqM2ILE9Q2BGn9JZJh1g87cp56su/FgQSzcWS8cQ==",
+      "dev": true
+    },
+    "inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
+      "dev": true,
+      "requires": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
+    "inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "dev": true
+    },
+    "is-absolute-url": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-absolute-url/-/is-absolute-url-2.1.0.tgz",
+      "integrity": "sha1-UFMN+4T8yap9vnhS6Do3uTufKqY=",
+      "dev": true
+    },
+    "is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=",
+      "dev": true
+    },
+    "is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+      "dev": true
+    },
+    "is-glob": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.1.tgz",
+      "integrity": "sha512-5G0tKtBTFImOqDnLB2hG6Bp2qcKEFduo4tZu9MT/H6NQv/ghhy30o55ufafxJ/LdH79LLs2Kfrn85TLKyA7BUg==",
+      "dev": true,
+      "requires": {
+        "is-extglob": "^2.1.1"
+      }
+    },
+    "is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+      "dev": true
+    },
+    "is-relative-url": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/is-relative-url/-/is-relative-url-2.0.0.tgz",
+      "integrity": "sha1-cpAtf+BLPUeS59sV+duEtyBMnO8=",
+      "dev": true,
+      "requires": {
+        "is-absolute-url": "^2.0.0"
+      }
+    },
+    "json-buffer": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.0.tgz",
+      "integrity": "sha1-Wx85evx11ne96Lz8Dkfh+aPZqJg=",
+      "dev": true
+    },
+    "jsonfile": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.0.1.tgz",
+      "integrity": "sha512-jR2b5v7d2vIOust+w3wtFKZIfpC2pnRmFAhAC/BuweZFQR8qZzxH1OyrQ10HmdVYiXWkYUqPVsz91cG7EL2FBg==",
+      "dev": true,
+      "requires": {
+        "graceful-fs": "^4.1.6",
+        "universalify": "^1.0.0"
+      }
+    },
+    "keyv": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/keyv/-/keyv-3.1.0.tgz",
+      "integrity": "sha512-9ykJ/46SN/9KPM/sichzQ7OvXyGDYKGTaDlKMGCAlg2UK8KRy4jb0d8sFc+0Tt0YYnThq8X2RZgCg74RPxgcVA==",
+      "dev": true,
+      "requires": {
+        "json-buffer": "3.0.0"
+      }
+    },
+    "locate-path": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz",
+      "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==",
+      "dev": true,
+      "requires": {
+        "p-locate": "^4.1.0"
+      }
+    },
+    "lowercase-keys": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-1.0.1.tgz",
+      "integrity": "sha512-G2Lj61tXDnVFFOi8VZds+SoQjtQC3dgokKdDG2mTm1tx4m50NUHBOZSBwQQHyy0V12A0JTG4icfZQH+xPyh8VA==",
+      "dev": true
+    },
+    "map-age-cleaner": {
+      "version": "0.1.3",
+      "resolved": "https://registry.npmjs.org/map-age-cleaner/-/map-age-cleaner-0.1.3.tgz",
+      "integrity": "sha512-bJzx6nMoP6PDLPBFmg7+xRKeFZvFboMrGlxmNj9ClvX53KrmvM5bXFXEWjbz4cz1AFn+jWJ9z/DJSz7hrs0w3w==",
+      "dev": true,
+      "requires": {
+        "p-defer": "^1.0.0"
+      }
+    },
+    "mem": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/mem/-/mem-4.3.0.tgz",
+      "integrity": "sha512-qX2bG48pTqYRVmDB37rn/6PT7LcR8T7oAX3bf99u1Tt1nzxYfxkgqDwUwolPlXweM0XzBOBFzSx4kfp7KP1s/w==",
+      "dev": true,
+      "requires": {
+        "map-age-cleaner": "^0.1.1",
+        "mimic-fn": "^2.0.0",
+        "p-is-promise": "^2.0.0"
+      },
+      "dependencies": {
+        "mimic-fn": {
+          "version": "2.1.0",
+          "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz",
+          "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==",
+          "dev": true
+        }
+      }
+    },
+    "merge2": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
+      "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
+      "dev": true
+    },
+    "micromatch": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.2.tgz",
+      "integrity": "sha512-y7FpHSbMUMoyPbYUSzO6PaZ6FyRnQOpHuKwbo1G+Knck95XVU4QAiKdGEnj5wwoS7PlOgthX/09u5iFJ+aYf5Q==",
+      "dev": true,
+      "requires": {
+        "braces": "^3.0.1",
+        "picomatch": "^2.0.5"
+      }
+    },
+    "mimic-fn": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-1.2.0.tgz",
+      "integrity": "sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ==",
+      "dev": true
+    },
+    "mimic-response": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-1.0.1.tgz",
+      "integrity": "sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==",
+      "dev": true
+    },
+    "minimatch": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
+      "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
+      "dev": true,
+      "requires": {
+        "brace-expansion": "^1.1.7"
+      }
+    },
+    "normalize-url": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-4.5.0.tgz",
+      "integrity": "sha512-2s47yzUxdexf1OhyRi4Em83iQk0aPvwTddtFz4hnSSw9dCEsLEGf6SwIO8ss/19S9iBb5sJaOuTvTGDeZI00BQ==",
+      "dev": true
+    },
+    "once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
+      "dev": true,
+      "requires": {
+        "wrappy": "1"
+      }
+    },
+    "p-cancelable": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-1.1.0.tgz",
+      "integrity": "sha512-s73XxOZ4zpt1edZYZzvhqFa6uvQc1vwUa0K0BdtIZgQMAJj9IbebH+JkgKZc9h+B05PKHLOTl4ajG1BmNrVZlw==",
+      "dev": true
+    },
+    "p-defer": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/p-defer/-/p-defer-1.0.0.tgz",
+      "integrity": "sha1-n26xgvbJqozXQwBKfU+WsZaw+ww=",
+      "dev": true
+    },
+    "p-is-promise": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/p-is-promise/-/p-is-promise-2.1.0.tgz",
+      "integrity": "sha512-Y3W0wlRPK8ZMRbNq97l4M5otioeA5lm1z7bkNkxCka8HSPjR0xRWmpCmc9utiaLP9Jb1eD8BgeIxTW4AIF45Pg==",
+      "dev": true
+    },
+    "p-limit": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz",
+      "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==",
+      "dev": true,
+      "requires": {
+        "p-try": "^2.0.0"
+      }
+    },
+    "p-locate": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz",
+      "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==",
+      "dev": true,
+      "requires": {
+        "p-limit": "^2.2.0"
+      }
+    },
+    "p-map": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/p-map/-/p-map-2.1.0.tgz",
+      "integrity": "sha512-y3b8Kpd8OAN444hxfBbFfj1FY/RjtTd8tzYwhUqNYXx0fXx2iX4maP4Qr6qhIKbQXI02wTLAda4fYUbDagTUFw==",
+      "dev": true
+    },
+    "p-memoize": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/p-memoize/-/p-memoize-2.1.0.tgz",
+      "integrity": "sha512-c6+a2iV4JyX0r4+i2IBJYO0r6LZAT2fg/tcB6GQbv1uzZsfsmKT7Ej5DRT1G6Wi7XUJSV2ZiP9+YEtluvhCmkg==",
+      "dev": true,
+      "requires": {
+        "mem": "^4.0.0",
+        "mimic-fn": "^1.0.0"
+      }
+    },
+    "p-try": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz",
+      "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==",
+      "dev": true
+    },
+    "path": {
+      "version": "0.12.7",
+      "resolved": "https://registry.npmjs.org/path/-/path-0.12.7.tgz",
+      "integrity": "sha1-1NwqUGxM4hl+tIHr/NWzbAFAsQ8=",
+      "dev": true,
+      "requires": {
+        "process": "^0.11.1",
+        "util": "^0.10.3"
+      }
+    },
+    "path-exists": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
+      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+      "dev": true
+    },
+    "path-is-absolute": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+      "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=",
+      "dev": true
+    },
+    "picomatch": {
+      "version": "2.2.2",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.2.2.tgz",
+      "integrity": "sha512-q0M/9eZHzmr0AulXyPwNfZjtwZ/RBZlbN3K3CErVrk50T2ASYI7Bye0EvekFY3IP1Nt2DHu0re+V2ZHIpMkuWg==",
+      "dev": true
+    },
+    "prepend-http": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/prepend-http/-/prepend-http-2.0.0.tgz",
+      "integrity": "sha1-6SQ0v6XqjBn0HN/UAddBo8gZ2Jc=",
+      "dev": true
+    },
+    "process": {
+      "version": "0.11.10",
+      "resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz",
+      "integrity": "sha1-czIwDoQBYb2j5podHZGn1LwW8YI=",
+      "dev": true
+    },
+    "pump": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.0.tgz",
+      "integrity": "sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==",
+      "dev": true,
+      "requires": {
+        "end-of-stream": "^1.1.0",
+        "once": "^1.3.1"
+      }
+    },
+    "require-directory": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+      "integrity": "sha1-jGStX9MNqxyXbiNE/+f3kqam30I=",
+      "dev": true
+    },
+    "require-main-filename": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/require-main-filename/-/require-main-filename-2.0.0.tgz",
+      "integrity": "sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==",
+      "dev": true
+    },
+    "responselike": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/responselike/-/responselike-1.0.2.tgz",
+      "integrity": "sha1-kYcg7ztjHFZCvgaPFa3lpG9Loec=",
+      "dev": true,
+      "requires": {
+        "lowercase-keys": "^1.0.0"
+      }
+    },
+    "reusify": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz",
+      "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==",
+      "dev": true
+    },
+    "run-parallel": {
+      "version": "1.1.9",
+      "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.1.9.tgz",
+      "integrity": "sha512-DEqnSRTDw/Tc3FXf49zedI638Z9onwUotBMiUFKmrO2sdFKIbXamXGQ3Axd4qgphxKB4kw/qP1w5kTxnfU1B9Q==",
+      "dev": true
+    },
+    "set-blocking": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz",
+      "integrity": "sha1-BF+XgtARrppoA93TgrJDkrPYkPc=",
+      "dev": true
+    },
+    "string-width": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.0.tgz",
+      "integrity": "sha512-zUz5JD+tgqtuDjMhwIg5uFVV3dtqZ9yQJlZVfq4I01/K5Paj5UHj7VyrQOJvzawSVlKpObApbfD0Ed6yJc+1eg==",
+      "dev": true,
+      "requires": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.0"
+      }
+    },
+    "strip-ansi": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.0.tgz",
+      "integrity": "sha512-AuvKTrTfQNYNIctbR1K/YGTR1756GycPsg7b9bdV9Duqur4gv6aKqHXah67Z8ImS7WEz5QVcOtlfW2rZEugt6w==",
+      "dev": true,
+      "requires": {
+        "ansi-regex": "^5.0.0"
+      }
+    },
+    "to-readable-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/to-readable-stream/-/to-readable-stream-1.0.0.tgz",
+      "integrity": "sha512-Iq25XBt6zD5npPhlLVXGFN3/gyR2/qODcKNNyTMd4vbm39HUaOiAM4PMq0eMVC/Tkxz+Zjdsc55g9yyz+Yq00Q==",
+      "dev": true
+    },
+    "to-regex-range": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "dev": true,
+      "requires": {
+        "is-number": "^7.0.0"
+      }
+    },
+    "ts-simple-type": {
+      "version": "0.3.7",
+      "resolved": "https://registry.npmjs.org/ts-simple-type/-/ts-simple-type-0.3.7.tgz",
+      "integrity": "sha512-bDXWURwpDpe1mA5E9eldmI0Mpt9zGprhtN/ZTLOJjsAMyeMy1UT7WvGRQghYewIYBYxDZurChhe4DrsPbcCVrA==",
+      "dev": true
+    },
+    "typescript": {
+      "version": "3.9.7",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.9.7.tgz",
+      "integrity": "sha512-BLbiRkiBzAwsjut4x/dsibSTB6yWpwT5qWmC2OfuCg3GgVQCSgMs4vEctYPhsaGtd0AeuuHMkjZ2h2WG8MSzRw==",
+      "dev": true
+    },
+    "universalify": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/universalify/-/universalify-1.0.0.tgz",
+      "integrity": "sha512-rb6X1W158d7pRQBg5gkR8uPaSfiids68LTJQYOtEUhoJUWBdaQHsuT/EUduxXYxcrt4r5PJ4fuHW1MHT6p0qug==",
+      "dev": true
+    },
+    "url-parse-lax": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/url-parse-lax/-/url-parse-lax-3.0.0.tgz",
+      "integrity": "sha1-FrXK/Afb42dsGxmZF3gj1lA6yww=",
+      "dev": true,
+      "requires": {
+        "prepend-http": "^2.0.0"
+      }
+    },
+    "util": {
+      "version": "0.10.4",
+      "resolved": "https://registry.npmjs.org/util/-/util-0.10.4.tgz",
+      "integrity": "sha512-0Pm9hTQ3se5ll1XihRic3FDIku70C+iHUdT/W926rSgHV5QgXsYbKZN8MSC3tJtSkhuROzvsQjAaFENRXr+19A==",
+      "dev": true,
+      "requires": {
+        "inherits": "2.0.3"
+      },
+      "dependencies": {
+        "inherits": {
+          "version": "2.0.3",
+          "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
+          "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=",
+          "dev": true
+        }
+      }
+    },
+    "web-component-analyzer": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/web-component-analyzer/-/web-component-analyzer-1.0.3.tgz",
+      "integrity": "sha512-QA6GVVJrKRPHLVqPv4evY0H+du1yY+E1q8c82bdY5e10+pWsRfeYA+Hsh2r8yl1EGQVC55SeV3tGvJ6+CxaH/Q==",
+      "dev": true,
+      "requires": {
+        "fast-glob": "^3.1.0",
+        "ts-simple-type": "~0.3.6",
+        "typescript": "^3.5.3",
+        "yargs": "^15.0.2"
+      }
+    },
+    "which-module": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/which-module/-/which-module-2.0.0.tgz",
+      "integrity": "sha1-2e8H3Od7mQK4o6j6SzHD4/fm6Ho=",
+      "dev": true
+    },
+    "wrap-ansi": {
+      "version": "6.2.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-6.2.0.tgz",
+      "integrity": "sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==",
+      "dev": true,
+      "requires": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      }
+    },
+    "wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=",
+      "dev": true
+    },
+    "y18n": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.0.tgz",
+      "integrity": "sha512-r9S/ZyXu/Xu9q1tYlpsLIsa3EeLXXk0VwlxqTcFRfg9EhMW+17kbt9G0NrgCmhGb5vT2hyhJZLfDGx+7+5Uj/w==",
+      "dev": true
+    },
+    "yargs": {
+      "version": "15.4.1",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-15.4.1.tgz",
+      "integrity": "sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A==",
+      "dev": true,
+      "requires": {
+        "cliui": "^6.0.0",
+        "decamelize": "^1.2.0",
+        "find-up": "^4.1.0",
+        "get-caller-file": "^2.0.1",
+        "require-directory": "^2.1.1",
+        "require-main-filename": "^2.0.0",
+        "set-blocking": "^2.0.0",
+        "string-width": "^4.2.0",
+        "which-module": "^2.0.0",
+        "y18n": "^4.0.0",
+        "yargs-parser": "^18.1.2"
+      }
+    },
+    "yargs-parser": {
+      "version": "18.1.3",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-18.1.3.tgz",
+      "integrity": "sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ==",
+      "dev": true,
+      "requires": {
+        "camelcase": "^5.0.0",
+        "decamelize": "^1.2.0"
+      }
+    }
+  }
+}

From ba75328ae118376a1cfb3e6fda44a89707f2bdff Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Thu, 20 Aug 2020 04:32:17 +0300
Subject: [PATCH 30/34] updated readme

---
 README.md | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/README.md b/README.md
index 48ca931..3ced0d9 100644
--- a/README.md
+++ b/README.md
@@ -279,6 +279,16 @@ Compile with java 8, add rxJava dependency of using rx DML functions in the tabl
 ```gradle
 android {
     ...
+    defaultConfig {
+        ...
+        javaCompileOptions {
+            annotationProcessorOptions {
+                arguments = [
+                        "promise.database.projectDir": "$projectDir".toString()
+                ]
+            }
+        }
+    }
     compileOptions {
             sourceCompatibility JavaVersion.VERSION_1_8
             targetCompatibility JavaVersion.VERSION_1_8
@@ -292,6 +302,9 @@ dependencies {
      implementation 'com.github.android-promise:commons:1.1-alpha03'
 }
 ```
+
+> The projectDir specifies where object tree file will be stored
+
 ##### Initialization
 Initialize Promise in your main application class
 ```java

From b978090f6edce908f58fa1dd95c8e745a44ce95d Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Tue, 25 Aug 2020 00:57:09 +0300
Subject: [PATCH 31/34] fixed migration issue including static fields in
 migration columns

---
 .idea/codeStyles/Project.xml                  |  18 ++
 app/schemas/promise.base.AppDatabase/1.yml    | 192 ++++++++-------
 app/schemas/promise.base.AppDatabase/2.yml    | 221 ++++++++++--------
 app/schemas/promise.base.AppDatabase/3.yml    | 101 --------
 app/schemas/promise.base.AppDatabase/4.yml    | 109 ---------
 app/schemas/promise.base.AppDatabase/5.yml    | 106 ---------
 app/src/main/java/promise/base/AppDatabase.kt |   6 +-
 .../java/promise/base/AppTypeConverter.kt     |   2 +-
 app/src/main/java/promise/base/ID.kt          |  29 ++-
 .../main/java/promise/base/comment/Like.java  |  79 ++++++-
 .../promise/base/comment/PostComment.java     |  43 +++-
 app/src/main/java/promise/base/photo/Photo.kt |  36 ++-
 app/src/main/java/promise/base/post/Post.java |  50 +++-
 .../java/promise/base/post/PostRepository.kt  |   8 +-
 .../main/java/promise/base/session/User.kt    |  32 +++
 .../compiler/EntityAnnotatedProcessor.kt      |   7 +
 .../database/compiler/TableMetaDataWriter.kt  |   9 +-
 .../promise/database/compiler/utils/List.java |   2 +-
 18 files changed, 528 insertions(+), 522 deletions(-)
 delete mode 100644 app/schemas/promise.base.AppDatabase/3.yml
 delete mode 100644 app/schemas/promise.base.AppDatabase/4.yml
 delete mode 100644 app/schemas/promise.base.AppDatabase/5.yml
 create mode 100644 app/src/main/java/promise/base/session/User.kt

diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index 681f41a..0d15693 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -1,5 +1,23 @@
 <component name="ProjectCodeStyleConfiguration">
   <code_scheme name="Project" version="173">
+    <JetCodeStyleSettings>
+      <option name="PACKAGES_TO_USE_STAR_IMPORTS">
+        <value>
+          <package name="java.util" alias="false" withSubpackages="false" />
+          <package name="kotlinx.android.synthetic" alias="false" withSubpackages="true" />
+          <package name="io.ktor" alias="false" withSubpackages="true" />
+        </value>
+      </option>
+      <option name="PACKAGES_IMPORT_LAYOUT">
+        <value>
+          <package name="" alias="false" withSubpackages="true" />
+          <package name="java" alias="false" withSubpackages="true" />
+          <package name="javax" alias="false" withSubpackages="true" />
+          <package name="kotlin" alias="false" withSubpackages="true" />
+          <package name="" alias="true" withSubpackages="true" />
+        </value>
+      </option>
+    </JetCodeStyleSettings>
     <codeStyleSettings language="XML">
       <indentOptions>
         <option name="CONTINUATION_INDENT_SIZE" value="4" />
diff --git a/app/schemas/promise.base.AppDatabase/1.yml b/app/schemas/promise.base.AppDatabase/1.yml
index 8fd04d8..d3b602c 100644
--- a/app/schemas/promise.base.AppDatabase/1.yml
+++ b/app/schemas/promise.base.AppDatabase/1.yml
@@ -1,90 +1,108 @@
 ---
 dbVersion: 1
 tableMetaData:
-  - tableName: "likes"
-    fields:
-      - fieldName: "uId"
-        columnName: "uId"
-        nullable: true
-      - fieldName: "post"
-        columnName: "post"
-        nullable: true
-    migrations: []
-  - tableName: "postComments"
-    fields:
-      - fieldName: "name"
-        columnName: "name"
-        nullable: true
-      - fieldName: "uId"
-        columnName: "uId"
-        nullable: true
-      - fieldName: "body"
-        columnName: "body"
-        nullable: true
-      - fieldName: "email"
-        columnName: "email"
-        nullable: true
-      - fieldName: "postCommentId"
-        columnName: "postCommentId"
-        nullable: true
-      - fieldName: "post"
-        columnName: "post"
-        nullable: true
-    migrations: []
-  - tableName: "posts"
-    fields:
-      - fieldName: "uId"
-        columnName: "uId"
-        nullable: true
-      - fieldName: "title"
-        columnName: "title"
-        nullable: true
-      - fieldName: "body"
-        columnName: "body"
-        nullable: true
-      - fieldName: "userId"
-        columnName: "userId"
-        nullable: true
-      - fieldName: "publishedDate"
-        columnName: "publishedDate"
-        nullable: true
-    migrations: []
-  - tableName: "todoes"
-    fields:
-      - fieldName: "uid"
-        columnName: "uid"
-        nullable: true
-      - fieldName: "completed"
-        columnName: "completed"
-        nullable: true
-      - fieldName: "title"
-        columnName: "title"
-        nullable: true
-      - fieldName: "timeStarted"
-        columnName: "timeStarted"
-        nullable: true
-      - fieldName: "description"
-        columnName: "description"
-        nullable: true
-      - fieldName: "photo"
-        columnName: "photo"
-        nullable: true
-    migrations: []
-  - tableName: "photos"
-    fields:
-      - fieldName: "albumId"
-        columnName: "albumId"
-        nullable: true
-      - fieldName: "title"
-        columnName: "title"
-        nullable: true
-      - fieldName: "url"
-        columnName: "url"
-        nullable: true
-      - fieldName: "thumbnailUrl"
-        columnName: "thumbnailUrl"
-        nullable: true
-      - fieldName: "post"
-        columnName: "post"
-        nullable: true
-    migrations: []
+- tableName: "likes"
+  fields:
+  - fieldName: "uId"
+    columnName: "uId"
+    nullable: true
+  - fieldName: "post"
+    columnName: "post"
+    nullable: true
+  - fieldName: "type"
+    columnName: "type"
+    nullable: true
+  migrations: []
+- tableName: "postComments"
+  fields:
+  - fieldName: "name"
+    columnName: "name"
+    nullable: true
+  - fieldName: "uId"
+    columnName: "uId"
+    nullable: true
+  - fieldName: "body"
+    columnName: "body"
+    nullable: true
+  - fieldName: "email"
+    columnName: "email"
+    nullable: true
+  - fieldName: "postCommentId"
+    columnName: "postCommentId"
+    nullable: true
+  - fieldName: "post"
+    columnName: "post"
+    nullable: true
+  migrations: []
+- tableName: "posts"
+  fields:
+  - fieldName: "uId"
+    columnName: "uId"
+    nullable: true
+  - fieldName: "title"
+    columnName: "title"
+    nullable: true
+  - fieldName: "body"
+    columnName: "body"
+    nullable: true
+  - fieldName: "userId"
+    columnName: "userId"
+    nullable: true
+  - fieldName: "numberOfViews"
+    columnName: "numberOfViews"
+    nullable: true
+  - fieldName: "publishedDate"
+    columnName: "publishedDate"
+    nullable: true
+  migrations: []
+- tableName: "todoes"
+  fields:
+  - fieldName: "uid"
+    columnName: "uid"
+    nullable: true
+  - fieldName: "completed"
+    columnName: "completed"
+    nullable: true
+  - fieldName: "title"
+    columnName: "title"
+    nullable: true
+  - fieldName: "timeStarted"
+    columnName: "timeStarted"
+    nullable: true
+  - fieldName: "timeFinished"
+    columnName: "timeFinished"
+    nullable: true
+  - fieldName: "description"
+    columnName: "description"
+    nullable: true
+  - fieldName: "photo"
+    columnName: "photo"
+    nullable: true
+  migrations: []
+- tableName: "photos"
+  fields:
+  - fieldName: "albumId"
+    columnName: "albumId"
+    nullable: true
+  - fieldName: "title"
+    columnName: "title"
+    nullable: true
+  - fieldName: "url"
+    columnName: "url"
+    nullable: true
+  - fieldName: "thumbnailUrl"
+    columnName: "thumbnailUrl"
+    nullable: true
+  - fieldName: "post"
+    columnName: "post"
+    nullable: true
+  migrations: []
+- tableName: "users"
+  fields:
+  - fieldName: "id"
+    columnName: "id"
+    nullable: true
+  - fieldName: "names"
+    columnName: "names"
+    nullable: true
+  migrations: []
diff --git a/app/schemas/promise.base.AppDatabase/2.yml b/app/schemas/promise.base.AppDatabase/2.yml
index 38b5012..23ffb26 100644
--- a/app/schemas/promise.base.AppDatabase/2.yml
+++ b/app/schemas/promise.base.AppDatabase/2.yml
@@ -1,98 +1,129 @@
 ---
 dbVersion: 2
 tableMetaData:
-  - tableName: "likes"
-    fields:
-      - fieldName: "uId"
-        columnName: "uId"
-        nullable: true
-      - fieldName: "post"
-        columnName: "post"
-        nullable: true
-    migrations: []
-  - tableName: "postComments"
-    fields:
-      - fieldName: "name"
-        columnName: "name"
-        nullable: true
-      - fieldName: "uId"
-        columnName: "uId"
-        nullable: true
-      - fieldName: "body"
-        columnName: "body"
-        nullable: true
-      - fieldName: "email"
-        columnName: "email"
-        nullable: true
-      - fieldName: "postCommentId"
-        columnName: "postCommentId"
-        nullable: true
-      - fieldName: "post"
-        columnName: "post"
-        nullable: true
-    migrations: []
-  - tableName: "posts"
-    fields:
-      - fieldName: "uId"
-        columnName: "uId"
-        nullable: true
-      - fieldName: "title"
-        columnName: "title"
-        nullable: true
-      - fieldName: "body"
-        columnName: "body"
-        nullable: true
-      - fieldName: "userId"
-        columnName: "userId"
-        nullable: true
-      - fieldName: "publishedDate"
-        columnName: "publishedDate"
-        nullable: true
-    migrations: []
-  - tableName: "todoes"
-    fields:
-      - fieldName: "uid"
-        columnName: "uid"
-        nullable: true
-      - fieldName: "completed"
-        columnName: "completed"
-        nullable: true
-      - fieldName: "title"
-        columnName: "title"
-        nullable: true
-      - fieldName: "timeStarted"
-        columnName: "timeStarted"
-        nullable: true
-      - fieldName: "timeFinished"
-        columnName: "timeFinished"
-        nullable: true
-      - fieldName: "description"
-        columnName: "description"
-        nullable: true
-      - fieldName: "photo"
-        columnName: "photo"
-        nullable: true
-    migrations:
-      - versionChange:
-          fromVersion: 1
-          toVersion: 2
-        field: "timeFinishedColumn"
-        action: "CREATE"
-  - tableName: "photos"
-    fields:
-      - fieldName: "albumId"
-        columnName: "albumId"
-        nullable: true
-      - fieldName: "title"
-        columnName: "title"
-        nullable: true
-      - fieldName: "url"
-        columnName: "url"
-        nullable: true
-      - fieldName: "thumbnailUrl"
-        columnName: "thumbnailUrl"
-        nullable: true
-      - fieldName: "post"
-        columnName: "post"
-        nullable: true
-    migrations: []
+- tableName: "likes"
+  fields:
+  - fieldName: "uId"
+    columnName: "uId"
+    nullable: true
+  - fieldName: "post"
+    columnName: "post"
+    nullable: true
+  - fieldName: "type"
+    columnName: "type"
+    nullable: true
+  migrations: []
+- tableName: "postComments"
+  fields:
+  - fieldName: "name"
+    columnName: "name"
+    nullable: true
+  - fieldName: "uId"
+    columnName: "uId"
+    nullable: true
+  - fieldName: "body"
+    columnName: "body"
+    nullable: true
+  - fieldName: "email"
+    columnName: "email"
+    nullable: true
+  - fieldName: "postCommentId"
+    columnName: "postCommentId"
+    nullable: true
+  - fieldName: "post"
+    columnName: "post"
+    nullable: true
+  migrations: []
+- tableName: "posts"
+  fields:
+  - fieldName: "uId"
+    columnName: "uId"
+    nullable: true
+  - fieldName: "title"
+    columnName: "title"
+    nullable: true
+  - fieldName: "body"
+    columnName: "body"
+    nullable: true
+  - fieldName: "userId"
+    columnName: "userId"
+    nullable: true
+  - fieldName: "numberOfViews"
+    columnName: "numberOfViews"
+    nullable: true
+  - fieldName: "publishedDate"
+    columnName: "publishedDate"
+    nullable: true
+  migrations: []
+- tableName: "todoes"
+  fields:
+  - fieldName: "uid"
+    columnName: "uid"
+    nullable: true
+  - fieldName: "completed"
+    columnName: "completed"
+    nullable: true
+  - fieldName: "title"
+    columnName: "title"
+    nullable: true
+  - fieldName: "timeStarted"
+    columnName: "timeStarted"
+    nullable: true
+  - fieldName: "timeFinished"
+    columnName: "timeFinished"
+    nullable: true
+  - fieldName: "description"
+    columnName: "description"
+    nullable: true
+  - fieldName: "photo"
+    columnName: "photo"
+    nullable: true
+  migrations: []
+- tableName: "photos"
+  fields:
+  - fieldName: "albumId"
+    columnName: "albumId"
+    nullable: true
+  - fieldName: "title"
+    columnName: "title"
+    nullable: true
+  - fieldName: "url"
+    columnName: "url"
+    nullable: true
+  - fieldName: "thumbnailUrl"
+    columnName: "thumbnailUrl"
+    nullable: true
+  - fieldName: "post"
+    columnName: "post"
+    nullable: true
+  migrations: []
+- tableName: "users"
+  fields:
+  - fieldName: "email"
+    columnName: "email"
+    nullable: true
+  - fieldName: "likedinProfileUrl"
+    columnName: "likedinProfileUrl"
+    nullable: true
+  - fieldName: "photoUrl"
+    columnName: "photoUrl"
+    nullable: true
+  - fieldName: "names"
+    columnName: "names"
+    nullable: true
+  migrations:
+  - versionChange:
+      fromVersion: 1
+      toVersion: 2
+    field: "emailColumn"
+    action: "CREATE"
+  - versionChange:
+      fromVersion: 1
+      toVersion: 2
+    field: "photoUrlColumn"
+    action: "CREATE"
+  - versionChange:
+      fromVersion: 1
+      toVersion: 2
+    field: "likedinProfileUrlColumn"
+    action: "CREATE"
diff --git a/app/schemas/promise.base.AppDatabase/3.yml b/app/schemas/promise.base.AppDatabase/3.yml
deleted file mode 100644
index 3fbfdf3..0000000
--- a/app/schemas/promise.base.AppDatabase/3.yml
+++ /dev/null
@@ -1,101 +0,0 @@
----
-dbVersion: 3
-tableMetaData:
-  - tableName: "likes"
-    fields:
-      - fieldName: "uId"
-        columnName: "uId"
-        nullable: true
-      - fieldName: "post"
-        columnName: "post"
-        nullable: true
-    migrations: []
-  - tableName: "postComments"
-    fields:
-      - fieldName: "name"
-        columnName: "name"
-        nullable: true
-      - fieldName: "uId"
-        columnName: "uId"
-        nullable: true
-      - fieldName: "body"
-        columnName: "body"
-        nullable: true
-      - fieldName: "email"
-        columnName: "email"
-        nullable: true
-      - fieldName: "postCommentId"
-        columnName: "postCommentId"
-        nullable: true
-      - fieldName: "post"
-        columnName: "post"
-        nullable: true
-    migrations: []
-  - tableName: "posts"
-    fields:
-      - fieldName: "uId"
-        columnName: "uId"
-        nullable: true
-      - fieldName: "title"
-        columnName: "title"
-        nullable: true
-      - fieldName: "body"
-        columnName: "body"
-        nullable: true
-      - fieldName: "userId"
-        columnName: "userId"
-        nullable: true
-      - fieldName: "numberOfViews"
-        columnName: "numberOfViews"
-        nullable: true
-      - fieldName: "publishedDate"
-        columnName: "publishedDate"
-        nullable: true
-    migrations:
-      - versionChange:
-          fromVersion: 2
-          toVersion: 3
-        field: "numberOfViewsColumn"
-        action: "CREATE"
-  - tableName: "todoes"
-    fields:
-      - fieldName: "uid"
-        columnName: "uid"
-        nullable: true
-      - fieldName: "completed"
-        columnName: "completed"
-        nullable: true
-      - fieldName: "title"
-        columnName: "title"
-        nullable: true
-      - fieldName: "timeStarted"
-        columnName: "timeStarted"
-        nullable: true
-      - fieldName: "timeFinished"
-        columnName: "timeFinished"
-        nullable: true
-      - fieldName: "description"
-        columnName: "description"
-        nullable: true
-      - fieldName: "photo"
-        columnName: "photo"
-        nullable: true
-    migrations: []
-  - tableName: "photos"
-    fields:
-      - fieldName: "albumId"
-        columnName: "albumId"
-        nullable: true
-      - fieldName: "title"
-        columnName: "title"
-        nullable: true
-      - fieldName: "url"
-        columnName: "url"
-        nullable: true
-      - fieldName: "thumbnailUrl"
-        columnName: "thumbnailUrl"
-        nullable: true
-      - fieldName: "post"
-        columnName: "post"
-        nullable: true
-    migrations: []
diff --git a/app/schemas/promise.base.AppDatabase/4.yml b/app/schemas/promise.base.AppDatabase/4.yml
deleted file mode 100644
index e53a677..0000000
--- a/app/schemas/promise.base.AppDatabase/4.yml
+++ /dev/null
@@ -1,109 +0,0 @@
----
-dbVersion: 4
-tableMetaData:
-  - tableName: "likes"
-    fields:
-      - fieldName: "uId"
-        columnName: "uId"
-        nullable: true
-      - fieldName: "post"
-        columnName: "post"
-        nullable: true
-    migrations: []
-  - tableName: "postComments"
-    fields:
-      - fieldName: "name"
-        columnName: "name"
-        nullable: true
-      - fieldName: "uId"
-        columnName: "uId"
-        nullable: true
-      - fieldName: "body"
-        columnName: "body"
-        nullable: true
-      - fieldName: "email"
-        columnName: "email"
-        nullable: true
-      - fieldName: "postCommentId"
-        columnName: "postCommentId"
-        nullable: true
-      - fieldName: "post"
-        columnName: "post"
-        nullable: true
-    migrations: []
-  - tableName: "posts"
-    fields:
-      - fieldName: "uId"
-        columnName: "uId"
-        nullable: true
-      - fieldName: "title"
-        columnName: "title"
-        nullable: true
-      - fieldName: "body"
-        columnName: "body"
-        nullable: true
-      - fieldName: "userId"
-        columnName: "userId"
-        nullable: true
-      - fieldName: "numberOfViews"
-        columnName: "numberOfViews"
-        nullable: true
-      - fieldName: "publishedDate"
-        columnName: "publishedDate"
-        nullable: true
-    migrations:
-      - versionChange:
-          fromVersion: 2
-          toVersion: 3
-        field: "numberOfViewsColumn"
-        action: "CREATE"
-  - tableName: "todoes"
-    fields:
-      - fieldName: "uid"
-        columnName: "uid"
-        nullable: true
-      - fieldName: "completed"
-        columnName: "completed"
-        nullable: true
-      - fieldName: "sentToServer"
-        columnName: "sentToServer"
-        nullable: true
-      - fieldName: "title"
-        columnName: "title"
-        nullable: true
-      - fieldName: "timeStarted"
-        columnName: "timeStarted"
-        nullable: true
-      - fieldName: "timeFinished"
-        columnName: "timeFinished"
-        nullable: true
-      - fieldName: "description"
-        columnName: "description"
-        nullable: true
-      - fieldName: "photo"
-        columnName: "photo"
-        nullable: true
-    migrations:
-      - versionChange:
-          fromVersion: 3
-          toVersion: 4
-        field: "sentToServerColumn"
-        action: "CREATE"
-  - tableName: "photos"
-    fields:
-      - fieldName: "albumId"
-        columnName: "albumId"
-        nullable: true
-      - fieldName: "title"
-        columnName: "title"
-        nullable: true
-      - fieldName: "url"
-        columnName: "url"
-        nullable: true
-      - fieldName: "thumbnailUrl"
-        columnName: "thumbnailUrl"
-        nullable: true
-      - fieldName: "post"
-        columnName: "post"
-        nullable: true
-    migrations: []
diff --git a/app/schemas/promise.base.AppDatabase/5.yml b/app/schemas/promise.base.AppDatabase/5.yml
deleted file mode 100644
index 9724130..0000000
--- a/app/schemas/promise.base.AppDatabase/5.yml
+++ /dev/null
@@ -1,106 +0,0 @@
----
-dbVersion: 5
-tableMetaData:
-- tableName: "likes"
-  fields:
-  - fieldName: "uId"
-    columnName: "uId"
-    nullable: true
-  - fieldName: "post"
-    columnName: "post"
-    nullable: true
-  migrations: []
-- tableName: "postComments"
-  fields:
-  - fieldName: "name"
-    columnName: "name"
-    nullable: true
-  - fieldName: "uId"
-    columnName: "uId"
-    nullable: true
-  - fieldName: "body"
-    columnName: "body"
-    nullable: true
-  - fieldName: "email"
-    columnName: "email"
-    nullable: true
-  - fieldName: "postCommentId"
-    columnName: "postCommentId"
-    nullable: true
-  - fieldName: "post"
-    columnName: "post"
-    nullable: true
-  migrations: []
-- tableName: "posts"
-  fields:
-  - fieldName: "uId"
-    columnName: "uId"
-    nullable: true
-  - fieldName: "title"
-    columnName: "title"
-    nullable: true
-  - fieldName: "body"
-    columnName: "body"
-    nullable: true
-  - fieldName: "userId"
-    columnName: "userId"
-    nullable: true
-  - fieldName: "numberOfViews"
-    columnName: "numberOfViews"
-    nullable: true
-  - fieldName: "publishedDate"
-    columnName: "publishedDate"
-    nullable: true
-  migrations:
-  - versionChange:
-      fromVersion: 2
-      toVersion: 3
-    field: "numberOfViewsColumn"
-    action: "CREATE"
-- tableName: "todoes"
-  fields:
-  - fieldName: "uid"
-    columnName: "uid"
-    nullable: true
-  - fieldName: "completed"
-    columnName: "completed"
-    nullable: true
-  - fieldName: "title"
-    columnName: "title"
-    nullable: true
-  - fieldName: "timeStarted"
-    columnName: "timeStarted"
-    nullable: true
-  - fieldName: "timeFinished"
-    columnName: "timeFinished"
-    nullable: true
-  - fieldName: "description"
-    columnName: "description"
-    nullable: true
-  - fieldName: "photo"
-    columnName: "photo"
-    nullable: true
-  migrations:
-  - versionChange:
-      fromVersion: 4
-      toVersion: 5
-    field: "\"sentToServer\""
-    action: "DROP"
-- tableName: "photos"
-  fields:
-  - fieldName: "albumId"
-    columnName: "albumId"
-    nullable: true
-  - fieldName: "title"
-    columnName: "title"
-    nullable: true
-  - fieldName: "url"
-    columnName: "url"
-    nullable: true
-  - fieldName: "thumbnailUrl"
-    columnName: "thumbnailUrl"
-    nullable: true
-  - fieldName: "post"
-    columnName: "post"
-    nullable: true
-  migrations: []
diff --git a/app/src/main/java/promise/base/AppDatabase.kt b/app/src/main/java/promise/base/AppDatabase.kt
index 73e8a57..7c28cde 100644
--- a/app/src/main/java/promise/base/AppDatabase.kt
+++ b/app/src/main/java/promise/base/AppDatabase.kt
@@ -18,6 +18,7 @@ import promise.base.comment.PostComment
 import promise.base.comment.PostCommentDao
 import promise.base.photo.Photo
 import promise.base.post.Post
+import promise.base.session.User
 import promise.base.todo.Todo
 import promise.commons.data.log.LogUtil
 import promise.database.DatabaseEntity
@@ -31,7 +32,8 @@ import promise.utils.Visitor
       Photo::class,
       Post::class,
       Todo::class,
-      Like::class
+      Like::class,
+      User::class
     ]
 )
 abstract class AppDatabase(fastDatabase: FastDatabase)
@@ -48,7 +50,7 @@ abstract class AppDatabase(fastDatabase: FastDatabase)
     })
   }
 
-  abstract fun getPostCommentsDao(): PostCommentDao
+  //abstract fun getPostCommentsDao(): PostCommentDao
 
   companion object {
     val TAG: String = LogUtil.makeTag(AppDatabase::class.java)
diff --git a/app/src/main/java/promise/base/AppTypeConverter.kt b/app/src/main/java/promise/base/AppTypeConverter.kt
index 3b5f5c7..174812a 100644
--- a/app/src/main/java/promise/base/AppTypeConverter.kt
+++ b/app/src/main/java/promise/base/AppTypeConverter.kt
@@ -23,7 +23,7 @@ class AppTypeConverter {
 
   fun stringToDate(data: String): Date = Date(data.toLong())
 
-  fun toUniqueId(data: String): ID = ID(data)
+  fun toUniqueId(data: String): ID = ID().apply { id = data }
 
   fun toString(data: ID?): String = data?.id ?: ""
 
diff --git a/app/src/main/java/promise/base/ID.kt b/app/src/main/java/promise/base/ID.kt
index 4a106d3..1b75dca 100644
--- a/app/src/main/java/promise/base/ID.kt
+++ b/app/src/main/java/promise/base/ID.kt
@@ -13,4 +13,31 @@
 
 package promise.base
 
-data class ID(val id: String)
+import android.os.Parcel
+import android.os.Parcelable
+
+class ID() : Parcelable {
+   var id: String? = ""
+
+  constructor(parcel: Parcel) : this() {
+    id = parcel.readString()
+  }
+
+  override fun writeToParcel(parcel: Parcel, flags: Int) {
+    parcel.writeString(id)
+  }
+
+  override fun describeContents(): Int {
+    return 0
+  }
+
+  companion object CREATOR : Parcelable.Creator<ID> {
+    override fun createFromParcel(parcel: Parcel): ID {
+      return ID(parcel)
+    }
+
+    override fun newArray(size: Int): Array<ID?> {
+      return arrayOfNulls(size)
+    }
+  }
+}
diff --git a/app/src/main/java/promise/base/comment/Like.java b/app/src/main/java/promise/base/comment/Like.java
index ab6b8a9..c2eb388 100644
--- a/app/src/main/java/promise/base/comment/Like.java
+++ b/app/src/main/java/promise/base/comment/Like.java
@@ -14,39 +14,49 @@
 package promise.base.comment;
 
 import android.annotation.SuppressLint;
+import android.os.Parcel;
+import android.os.Parcelable;
 
-import org.jetbrains.annotations.NotNull;
+import androidx.annotation.NonNull;
 
 import promise.base.ID;
 import promise.base.post.Post;
+import promise.commons.model.Identifiable;
 import promise.database.Entity;
 import promise.database.HasOne;
-import promise.db.ActiveRecord;
+import promise.database.PrimaryKeyAutoIncrement;
 
-@SuppressLint("ParcelCreator")
 @Entity
-//@AddedEntity(fromVersion = 1, toVersion = 2)
-public class Like extends ActiveRecord<Like> {
+
+public class Like implements Identifiable<Integer>, Parcelable {
   private ID uId;
 
   @HasOne
   private Post post;
 
+  @PrimaryKeyAutoIncrement
+  private int id;
+
+  private String type;
+
+  public String getType() {
+    return type;
+  }
+
+  public void setType(String type) {
+    this.type = type;
+  }
+
+  @NonNull
   @Override
   public String toString() {
     return
-        "Comment{" +
+        "Like{" +
             ",id = '" + uId + '\'' +
 
             "}";
   }
 
-  @NotNull
-  @Override
-  public Like getEntity() {
-    return this;
-  }
-
   public ID getUId() {
     return uId;
   }
@@ -62,4 +72,49 @@ public Post getPost() {
   public void setPost(Post post) {
     this.post = post;
   }
+
+  @Override
+  public Integer getId() {
+    return id;
+  }
+
+  @Override
+  public void setId(Integer integer) {
+    this.id = integer;
+  }
+
+  @Override
+  public int describeContents() {
+    return 0;
+  }
+
+  @Override
+  public void writeToParcel(Parcel dest, int flags) {
+    dest.writeParcelable(this.uId, flags);
+    dest.writeParcelable(this.post, flags);
+    dest.writeInt(this.id);
+    dest.writeString(this.type);
+  }
+
+  public Like() {
+  }
+
+  protected Like(Parcel in) {
+    this.uId = in.readParcelable(ID.class.getClassLoader());
+    this.post = in.readParcelable(Post.class.getClassLoader());
+    this.id = in.readInt();
+    this.type = in.readString();
+  }
+
+  public static final Parcelable.Creator<Like> CREATOR = new Parcelable.Creator<Like>() {
+    @Override
+    public Like createFromParcel(Parcel source) {
+      return new Like(source);
+    }
+
+    @Override
+    public Like[] newArray(int size) {
+      return new Like[size];
+    }
+  };
 }
diff --git a/app/src/main/java/promise/base/comment/PostComment.java b/app/src/main/java/promise/base/comment/PostComment.java
index 8c616dd..42791d6 100644
--- a/app/src/main/java/promise/base/comment/PostComment.java
+++ b/app/src/main/java/promise/base/comment/PostComment.java
@@ -1,6 +1,7 @@
 package promise.base.comment;
 
 import android.annotation.SuppressLint;
+import android.os.Parcel;
 
 import org.jetbrains.annotations.NotNull;
 
@@ -10,7 +11,6 @@
 import promise.database.HasOne;
 import promise.db.ActiveRecord;
 
-@SuppressLint("ParcelCreator")
 @Entity
 public class PostComment extends ActiveRecord<PostComment> {
   private String name;
@@ -87,4 +87,45 @@ public ID getUId() {
   public void setUId(ID uId) {
     this.uId = uId;
   }
+
+  @Override
+  public int describeContents() {
+    return 0;
+  }
+
+  @Override
+  public void writeToParcel(Parcel dest, int flags) {
+    super.writeToParcel(dest, flags);
+    dest.writeString(this.name);
+    dest.writeParcelable(this.uId, flags);
+    dest.writeString(this.body);
+    dest.writeString(this.email);
+    dest.writeString(this.postCommentId);
+    dest.writeParcelable(this.post, flags);
+  }
+
+  public PostComment() {
+  }
+
+  protected PostComment(Parcel in) {
+    super(in);
+    this.name = in.readString();
+    this.uId = in.readParcelable(ID.class.getClassLoader());
+    this.body = in.readString();
+    this.email = in.readString();
+    this.postCommentId = in.readString();
+    this.post = in.readParcelable(Post.class.getClassLoader());
+  }
+
+  public static final Creator<PostComment> CREATOR = new Creator<PostComment>() {
+    @Override
+    public PostComment createFromParcel(Parcel source) {
+      return new PostComment(source);
+    }
+
+    @Override
+    public PostComment[] newArray(int size) {
+      return new PostComment[size];
+    }
+  };
 }
diff --git a/app/src/main/java/promise/base/photo/Photo.kt b/app/src/main/java/promise/base/photo/Photo.kt
index 60b0703..963b4e5 100644
--- a/app/src/main/java/promise/base/photo/Photo.kt
+++ b/app/src/main/java/promise/base/photo/Photo.kt
@@ -1,14 +1,15 @@
 package promise.base.photo
 
 import android.annotation.SuppressLint
+import android.os.Parcel
+import android.os.Parcelable
 import promise.base.post.Post
 import promise.database.Entity
 import promise.database.HasOne
 import promise.db.ActiveRecord
 
-@SuppressLint("ParcelCreator")
 @Entity
-class Photo : ActiveRecord<Photo>() {
+class Photo() : ActiveRecord<Photo>() {
   var albumId: Int? = null
   var title: String? = null
   var url: String? = null
@@ -16,9 +17,40 @@ class Photo : ActiveRecord<Photo>() {
   @HasOne
   var post: Post? = null
 
+  constructor(parcel: Parcel) : this() {
+    albumId = parcel.readValue(Int::class.java.classLoader) as? Int
+    title = parcel.readString()
+    url = parcel.readString()
+    thumbnailUrl = parcel.readString()
+    post = parcel.readParcelable(Post::class.java.classLoader)
+  }
+
   override fun getEntity(): Photo {
     return this
   }
 
+  override fun writeToParcel(parcel: Parcel, flags: Int) {
+    super.writeToParcel(parcel, flags)
+    parcel.writeValue(albumId)
+    parcel.writeString(title)
+    parcel.writeString(url)
+    parcel.writeString(thumbnailUrl)
+    parcel.writeParcelable(post, flags)
+  }
+
+  override fun describeContents(): Int {
+    return 0
+  }
+
+  companion object CREATOR : Parcelable.Creator<Photo> {
+    override fun createFromParcel(parcel: Parcel): Photo {
+      return Photo(parcel)
+    }
+
+    override fun newArray(size: Int): Array<Photo?> {
+      return arrayOfNulls(size)
+    }
+  }
+
 }
 
diff --git a/app/src/main/java/promise/base/post/Post.java b/app/src/main/java/promise/base/post/Post.java
index dc81b28..e8c1a82 100644
--- a/app/src/main/java/promise/base/post/Post.java
+++ b/app/src/main/java/promise/base/post/Post.java
@@ -1,6 +1,7 @@
 package promise.base.post;
 
 import android.annotation.SuppressLint;
+import android.os.Parcel;
 
 import androidx.annotation.NonNull;
 
@@ -17,7 +18,6 @@
 import promise.database.HasMany;
 import promise.db.ActiveRecord;
 
-@SuppressLint("ParcelCreator")
 @Entity
 public class Post extends ActiveRecord<Post> {
   private ID uId;
@@ -132,4 +132,52 @@ public Date getPublishedDate() {
   public void setPublishedDate(Date publishedDate) {
     this.publishedDate = publishedDate;
   }
+
+  @Override
+  public int describeContents() {
+    return 0;
+  }
+
+  @Override
+  public void writeToParcel(Parcel dest, int flags) {
+    super.writeToParcel(dest, flags);
+    dest.writeParcelable(this.uId, flags);
+    dest.writeString(this.title);
+    dest.writeString(this.body);
+    dest.writeInt(this.userId);
+    dest.writeInt(this.numberOfViews);
+    dest.writeLong(this.publishedDate != null ? this.publishedDate.getTime() : -1);
+    dest.writeTypedList(this.comments);
+    dest.writeTypedList(this.photos);
+    dest.writeTypedList(this.likes);
+  }
+
+  public Post() {
+  }
+
+  protected Post(Parcel in) {
+    super(in);
+    this.uId = in.readParcelable(ID.class.getClassLoader());
+    this.title = in.readString();
+    this.body = in.readString();
+    this.userId = in.readInt();
+    this.numberOfViews = in.readInt();
+    long tmpPublishedDate = in.readLong();
+    this.publishedDate = tmpPublishedDate == -1 ? null : new Date(tmpPublishedDate);
+    this.comments = in.createTypedArrayList(PostComment.CREATOR);
+    this.photos = in.createTypedArrayList(Photo.CREATOR);
+    this.likes = in.createTypedArrayList(Like.CREATOR);
+  }
+
+  public static final Creator<Post> CREATOR = new Creator<Post>() {
+    @Override
+    public Post createFromParcel(Parcel source) {
+      return new Post(source);
+    }
+
+    @Override
+    public Post[] newArray(int size) {
+      return new Post[size];
+    }
+  };
 }
diff --git a/app/src/main/java/promise/base/post/PostRepository.kt b/app/src/main/java/promise/base/post/PostRepository.kt
index 594b9fe..7c0a3d1 100644
--- a/app/src/main/java/promise/base/post/PostRepository.kt
+++ b/app/src/main/java/promise/base/post/PostRepository.kt
@@ -35,14 +35,18 @@ class PostRepositoryImpl @Inject constructor(
   init {
     val posts = IdentifiableList(promise.commons.model.List.generate(5) {
       Post().apply {
-        uId = ID(it.toString())
+        uId = ID().apply {
+          id = it.toString()
+        }
         title = "post".plus(it)
         body = "body".plus(it)
         userId = it
         comments = promise.commons.model.List.generate(4) {
           PostComment().apply {
             name = "nm".repeat(it)
-            uId = ID((it + 1).toString())
+            uId = ID().apply {
+              id = (it + 1).toString()
+            }
             body = "hbytcvbcrxgfvbtrxt"
             email = "ejmail;jgfccghcfcvhbhcgvb"
           }
diff --git a/app/src/main/java/promise/base/session/User.kt b/app/src/main/java/promise/base/session/User.kt
new file mode 100644
index 0000000..3dad3b2
--- /dev/null
+++ b/app/src/main/java/promise/base/session/User.kt
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2017, Peter Vincent
+ * Licensed under the Apache License, Version 2.0, Android Promise.
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package promise.base.session
+
+import android.annotation.SuppressLint
+import promise.database.AddedEntity
+import promise.database.Entity
+import promise.db.ActiveRecord
+
+@SuppressLint("ParcelCreator")
+@Entity
+@AddedEntity(fromVersion = 1, toVersion = 2)
+class User: ActiveRecord<User>() {
+  var email: String = ""
+  var likedinProfileUrl = ""
+  var photoUrl = ""
+  var names = ""
+  override fun getEntity(): User {
+    return this
+  }
+}
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/database/compiler/EntityAnnotatedProcessor.kt b/compiler/src/main/java/promise/database/compiler/EntityAnnotatedProcessor.kt
index 3593166..ad8f113 100644
--- a/compiler/src/main/java/promise/database/compiler/EntityAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/database/compiler/EntityAnnotatedProcessor.kt
@@ -32,8 +32,10 @@ import promise.database.compiler.utils.getTableEntities
 import javax.annotation.processing.ProcessingEnvironment
 import javax.annotation.processing.RoundEnvironment
 import javax.lang.model.element.Element
+import javax.lang.model.element.ElementKind
 import javax.lang.model.element.Modifier
 import javax.lang.model.element.TypeElement
+import javax.lang.model.util.ElementFilter
 
 class EntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment,
                                private val database: TypeElement) : AnnotatedClassProcessor() {
@@ -56,6 +58,11 @@ class EntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment,
   private fun processAnnotation(element: Element): JavaFile.Builder {
     if (!entities.map { it.asType().toString() }.contains(element.asType().toString()))
       LogUtil.e(Exception("Entity class ${element.simpleName} is not registered in database"), database)
+
+    if (ElementFilter.methodsIn(element.enclosedElements).none {
+          it.kind == ElementKind.CONSTRUCTOR && it.parameters.isEmpty()
+        }) LogUtil.e(Exception("$element must have a no args constructor"), element)
+
     val className = element.simpleName.toString()
     val pack = processingEnv.elementUtils.getPackageOf(element).toString()
 
diff --git a/compiler/src/main/java/promise/database/compiler/TableMetaDataWriter.kt b/compiler/src/main/java/promise/database/compiler/TableMetaDataWriter.kt
index 0387723..4a8f1ab 100644
--- a/compiler/src/main/java/promise/database/compiler/TableMetaDataWriter.kt
+++ b/compiler/src/main/java/promise/database/compiler/TableMetaDataWriter.kt
@@ -18,6 +18,7 @@ import promise.database.Ignore
 import promise.database.Migrate
 import promise.database.MigrationOptions
 import promise.database.Migrations
+import promise.database.PrimaryKeyAutoIncrement
 import promise.database.compiler.migration.Field
 import promise.database.compiler.migration.TableMetaData
 import promise.database.compiler.migration.TableMigration
@@ -27,6 +28,7 @@ import promise.database.compiler.utils.getNameOfColumn
 import promise.database.compiler.utils.getTableName
 import promise.database.compiler.utils.isColumnNullable
 import javax.lang.model.element.Element
+import javax.lang.model.element.Modifier
 import javax.lang.model.util.ElementFilter
 
 class TableMetaDataWriter(
@@ -104,7 +106,10 @@ class TableMetaDataWriter(
           promise.database.compiler.utils.List(oldMetaData.fields),
           elements.filter {
             it.key.getAnnotation(Migrate::class.java) == null &&
-                it.key.getAnnotation(Migrations::class.java) == null
+                it.key.getAnnotation(Migrations::class.java) == null &&
+                it.key.getAnnotation(PrimaryKeyAutoIncrement::class.java) == null &&
+                it.key.getAnnotation(Ignore::class.java) == null &&
+                !(it.key.modifiers.contains(Modifier.STATIC))
           }))
       tableMigrations.addAll(promise.database.compiler.utils.List(oldMetaData.migrations))
       metaData.migrations = tableMigrations.uniques()
@@ -116,7 +121,9 @@ class TableMetaDataWriter(
      */
     ElementFilter.fieldsIn(entityElement.enclosedElements).filter {
       it.getAnnotation(Ignore::class.java) == null &&
+          it.getAnnotation(PrimaryKeyAutoIncrement::class.java) == null &&
           it.getAnnotation(HasMany::class.java) == null
+          && !(it.modifiers.contains(Modifier.STATIC))
     }
         .forEach {
           fields.add(Field().apply {
diff --git a/compiler/src/main/java/promise/database/compiler/utils/List.java b/compiler/src/main/java/promise/database/compiler/utils/List.java
index 2a7bc44..4dad631 100644
--- a/compiler/src/main/java/promise/database/compiler/utils/List.java
+++ b/compiler/src/main/java/promise/database/compiler/utils/List.java
@@ -206,7 +206,7 @@ public List<T> sorted(Comparator<? super T> comparator) {
    * arrange the list based on an atrribute that is not in blueprint of original items
    *
    * @param function   transformer for list to desired attribute that is sortable
-   * @param comparator compare fucntion that compares the result of the transformer
+   * @param comparator compare function that compares the result of the transformer
    * @param <K>        desired compare type
    * @return a sorted list
    */

From b69b4dcf7d0e5807b0b03f631bca20fca617e029 Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Wed, 2 Sep 2020 08:53:51 +0300
Subject: [PATCH 32/34] bump to 1.0.3

---
 README.md                                                   | 4 ++--
 .../promise/database/compiler/EntityAnnotatedProcessor.kt   | 6 ++++--
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 3ced0d9..cf98613 100644
--- a/README.md
+++ b/README.md
@@ -297,8 +297,8 @@ android {
 
 dependencies {
      ...
-     implementation 'com.github.android-promise.database:database:1.0.3-alpha8'
-     kapt 'com.github.android-promise.database:compiler:1.0.3-alpha8'
+     implementation 'com.github.android-promise.database:database:1.0.3'
+     kapt 'com.github.android-promise.database:compiler:1.0.3'
      implementation 'com.github.android-promise:commons:1.1-alpha03'
 }
 ```
diff --git a/compiler/src/main/java/promise/database/compiler/EntityAnnotatedProcessor.kt b/compiler/src/main/java/promise/database/compiler/EntityAnnotatedProcessor.kt
index ad8f113..89b0ac2 100644
--- a/compiler/src/main/java/promise/database/compiler/EntityAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/database/compiler/EntityAnnotatedProcessor.kt
@@ -59,10 +59,12 @@ class EntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment,
     if (!entities.map { it.asType().toString() }.contains(element.asType().toString()))
       LogUtil.e(Exception("Entity class ${element.simpleName} is not registered in database"), database)
 
-    if (ElementFilter.methodsIn(element.enclosedElements).none {
+/**
+ if (ElementFilter.methodsIn(element.enclosedElements).none {
           it.kind == ElementKind.CONSTRUCTOR && it.parameters.isEmpty()
         }) LogUtil.e(Exception("$element must have a no args constructor"), element)
-
+ */
+   
     val className = element.simpleName.toString()
     val pack = processingEnv.elementUtils.getPackageOf(element).toString()
 

From 4e41ed54ee6ee774116d4aecffd23d161436de6e Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Fri, 20 Nov 2020 13:28:25 +0300
Subject: [PATCH 33/34] updated dependencies

---
 app/build.gradle                              |  10 +-
 app/schemas/promise.base.AppDatabase/1.yml    | 108 ------------------
 app/schemas/promise.base.AppDatabase/2.yml    |  23 +---
 app/src/main/java/promise/base/AppDatabase.kt |  16 +--
 app/src/main/java/promise/base/ID.kt          |  13 +--
 .../main/java/promise/base/comment/Like.java  |  12 +-
 .../promise/base/comment/PostComment.java     |   7 +-
 app/src/main/java/promise/base/photo/Photo.kt |  25 ++--
 app/src/main/java/promise/base/post/Post.java |   7 ++
 .../java/promise/base/post/PostRepository.kt  |   4 +-
 .../main/java/promise/base/session/User.kt    |   5 +-
 .../main/java/promise/dbapp/AppComponent.kt   |  10 +-
 build.gradle                                  |   4 +-
 .../database/{Text.kt => ColumnInfo.kt}       |  11 +-
 .../src/main/java/promise/database/Entity.kt  |   3 +-
 .../src/main/java/promise/database/Number.kt  |  22 ----
 .../src/main/java/promise/database/VarChar.kt |  22 ----
 compiler/build.gradle                         |   6 +-
 .../DatabaseAbstractMethodsGenerator.kt       |  13 ---
 .../compiler/EntityAnnotatedProcessor.kt      |   9 --
 .../compiler/PromiseDatabaseCompiler.kt       |   5 +-
 .../compiler/RelationsDaoGenerator.java       |  51 ++++++---
 .../compiler/RelationsDaoProcessor.kt         |   1 +
 .../compiler/TableColumnFieldsGenerator.kt    |  78 ++++---------
 .../TableDeserializerMethodGenerator.kt       |   1 -
 .../TableRegisteredColumnsMethodGenerator.kt  |   3 -
 .../TableSerializerMethodGenerator.kt         |   2 -
 .../compiler/utils/PersistableEntityUtils.kt  |  35 +++---
 database/build.gradle                         |  12 +-
 .../src/main/java/promise/db/DMLVisitors.kt   |  12 +-
 .../main/java/promise/db/FastDatabaseImpl.kt  |   4 +
 .../src/main/java/promise/db/FetchVisitors.kt |   8 +-
 settings.gradle                               |   3 +-
 33 files changed, 168 insertions(+), 377 deletions(-)
 delete mode 100644 app/schemas/promise.base.AppDatabase/1.yml
 rename commons/src/main/java/promise/database/{Text.kt => ColumnInfo.kt} (77%)
 delete mode 100644 commons/src/main/java/promise/database/Number.kt
 delete mode 100644 commons/src/main/java/promise/database/VarChar.kt

diff --git a/app/build.gradle b/app/build.gradle
index 3b848c8..1010df4 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -61,12 +61,12 @@ dependencies {
     implementation "com.android.support:recyclerview-v7:$supportLibVersion"
     implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
-    implementation 'androidx.appcompat:appcompat:1.1.0'
-    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
-    implementation 'com.google.android.material:material:1.1.0'
+    implementation 'androidx.appcompat:appcompat:1.2.0'
+    implementation 'androidx.constraintlayout:constraintlayout:2.0.4'
+    implementation 'com.google.android.material:material:1.2.1'
     testImplementation 'junit:junit:4.13'
-    androidTestImplementation 'androidx.test:runner:1.2.0'
-    androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
+    androidTestImplementation 'androidx.test:runner:1.3.0'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'
 
     implementation 'com.github.android-promise:commons:1.1-beta02'
     implementation 'io.reactivex.rxjava2:rxjava:2.2.17'
diff --git a/app/schemas/promise.base.AppDatabase/1.yml b/app/schemas/promise.base.AppDatabase/1.yml
deleted file mode 100644
index d3b602c..0000000
--- a/app/schemas/promise.base.AppDatabase/1.yml
+++ /dev/null
@@ -1,108 +0,0 @@
----
-dbVersion: 1
-tableMetaData:
-- tableName: "likes"
-  fields:
-  - fieldName: "uId"
-    columnName: "uId"
-    nullable: true
-  - fieldName: "post"
-    columnName: "post"
-    nullable: true
-  - fieldName: "type"
-    columnName: "type"
-    nullable: true
-  migrations: []
-- tableName: "postComments"
-  fields:
-  - fieldName: "name"
-    columnName: "name"
-    nullable: true
-  - fieldName: "uId"
-    columnName: "uId"
-    nullable: true
-  - fieldName: "body"
-    columnName: "body"
-    nullable: true
-  - fieldName: "email"
-    columnName: "email"
-    nullable: true
-  - fieldName: "postCommentId"
-    columnName: "postCommentId"
-    nullable: true
-  - fieldName: "post"
-    columnName: "post"
-    nullable: true
-  migrations: []
-- tableName: "posts"
-  fields:
-  - fieldName: "uId"
-    columnName: "uId"
-    nullable: true
-  - fieldName: "title"
-    columnName: "title"
-    nullable: true
-  - fieldName: "body"
-    columnName: "body"
-    nullable: true
-  - fieldName: "userId"
-    columnName: "userId"
-    nullable: true
-  - fieldName: "numberOfViews"
-    columnName: "numberOfViews"
-    nullable: true
-  - fieldName: "publishedDate"
-    columnName: "publishedDate"
-    nullable: true
-  migrations: []
-- tableName: "todoes"
-  fields:
-  - fieldName: "uid"
-    columnName: "uid"
-    nullable: true
-  - fieldName: "completed"
-    columnName: "completed"
-    nullable: true
-  - fieldName: "title"
-    columnName: "title"
-    nullable: true
-  - fieldName: "timeStarted"
-    columnName: "timeStarted"
-    nullable: true
-  - fieldName: "timeFinished"
-    columnName: "timeFinished"
-    nullable: true
-  - fieldName: "description"
-    columnName: "description"
-    nullable: true
-  - fieldName: "photo"
-    columnName: "photo"
-    nullable: true
-  migrations: []
-- tableName: "photos"
-  fields:
-  - fieldName: "albumId"
-    columnName: "albumId"
-    nullable: true
-  - fieldName: "title"
-    columnName: "title"
-    nullable: true
-  - fieldName: "url"
-    columnName: "url"
-    nullable: true
-  - fieldName: "thumbnailUrl"
-    columnName: "thumbnailUrl"
-    nullable: true
-  - fieldName: "post"
-    columnName: "post"
-    nullable: true
-  migrations: []
-- tableName: "users"
-  fields:
-  - fieldName: "id"
-    columnName: "id"
-    nullable: true
-  - fieldName: "names"
-    columnName: "names"
-    nullable: true
-  migrations: []
diff --git a/app/schemas/promise.base.AppDatabase/2.yml b/app/schemas/promise.base.AppDatabase/2.yml
index 23ffb26..e5ed15b 100644
--- a/app/schemas/promise.base.AppDatabase/2.yml
+++ b/app/schemas/promise.base.AppDatabase/2.yml
@@ -40,7 +40,7 @@ tableMetaData:
     columnName: "uId"
     nullable: true
   - fieldName: "title"
-    columnName: "title"
+    columnName: "ttl"
     nullable: true
   - fieldName: "body"
     columnName: "body"
@@ -93,8 +93,8 @@ tableMetaData:
   - fieldName: "thumbnailUrl"
     columnName: "thumbnailUrl"
     nullable: true
-  - fieldName: "post"
-    columnName: "post"
+  - fieldName: "photoPost"
+    columnName: "photoPost"
     nullable: true
   migrations: []
 - tableName: "users"
@@ -111,19 +111,4 @@ tableMetaData:
   - fieldName: "names"
     columnName: "names"
     nullable: true
-  migrations:
-  - versionChange:
-      fromVersion: 1
-      toVersion: 2
-    field: "emailColumn"
-    action: "CREATE"
-  - versionChange:
-      fromVersion: 1
-      toVersion: 2
-    field: "photoUrlColumn"
-    action: "CREATE"
-  - versionChange:
-      fromVersion: 1
-      toVersion: 2
-    field: "likedinProfileUrlColumn"
-    action: "CREATE"
+  migrations: []
diff --git a/app/src/main/java/promise/base/AppDatabase.kt b/app/src/main/java/promise/base/AppDatabase.kt
index 7c28cde..cc7b808 100644
--- a/app/src/main/java/promise/base/AppDatabase.kt
+++ b/app/src/main/java/promise/base/AppDatabase.kt
@@ -15,7 +15,6 @@ package promise.base
 
 import promise.base.comment.Like
 import promise.base.comment.PostComment
-import promise.base.comment.PostCommentDao
 import promise.base.photo.Photo
 import promise.base.post.Post
 import promise.base.session.User
@@ -34,20 +33,17 @@ import promise.utils.Visitor
       Todo::class,
       Like::class,
       User::class
-    ]
+    ],
+    version = 2
 )
 abstract class AppDatabase(fastDatabase: FastDatabase)
   : PromiseDatabase(fastDatabase) {
 
   init {
-    fastDatabase.accept(object : Visitor<FastDatabase, Unit> {
-      override fun visit(t: FastDatabase) {
-        t.setErrorHandler {
-          LogUtil.e(TAG, "database error: ${it.path}")
-        }
-        t.fallBackToDestructiveMigration()
-      }
-    })
+    fastDatabase.setErrorHandler {
+      LogUtil.e(TAG, "database error: ${it.path}")
+    }
+    fastDatabase.fallBackToDestructiveMigration()
   }
 
   //abstract fun getPostCommentsDao(): PostCommentDao
diff --git a/app/src/main/java/promise/base/ID.kt b/app/src/main/java/promise/base/ID.kt
index 1b75dca..5ac2388 100644
--- a/app/src/main/java/promise/base/ID.kt
+++ b/app/src/main/java/promise/base/ID.kt
@@ -27,17 +27,10 @@ class ID() : Parcelable {
     parcel.writeString(id)
   }
 
-  override fun describeContents(): Int {
-    return 0
-  }
+  override fun describeContents(): Int = 0
 
   companion object CREATOR : Parcelable.Creator<ID> {
-    override fun createFromParcel(parcel: Parcel): ID {
-      return ID(parcel)
-    }
-
-    override fun newArray(size: Int): Array<ID?> {
-      return arrayOfNulls(size)
-    }
+    override fun createFromParcel(parcel: Parcel): ID = ID(parcel)
+    override fun newArray(size: Int): Array<ID?> = arrayOfNulls(size)
   }
 }
diff --git a/app/src/main/java/promise/base/comment/Like.java b/app/src/main/java/promise/base/comment/Like.java
index c2eb388..cf1ff9a 100644
--- a/app/src/main/java/promise/base/comment/Like.java
+++ b/app/src/main/java/promise/base/comment/Like.java
@@ -27,7 +27,6 @@
 import promise.database.PrimaryKeyAutoIncrement;
 
 @Entity
-
 public class Like implements Identifiable<Integer>, Parcelable {
   private ID uId;
 
@@ -50,11 +49,12 @@ public void setType(String type) {
   @NonNull
   @Override
   public String toString() {
-    return
-        "Like{" +
-            ",id = '" + uId + '\'' +
-
-            "}";
+    return "Like{" +
+        "uId=" + uId +
+        ", post=" + post +
+        ", id=" + id +
+        ", type='" + type + '\'' +
+        '}';
   }
 
   public ID getUId() {
diff --git a/app/src/main/java/promise/base/comment/PostComment.java b/app/src/main/java/promise/base/comment/PostComment.java
index 42791d6..e019ef2 100644
--- a/app/src/main/java/promise/base/comment/PostComment.java
+++ b/app/src/main/java/promise/base/comment/PostComment.java
@@ -3,6 +3,8 @@
 import android.annotation.SuppressLint;
 import android.os.Parcel;
 
+import androidx.annotation.NonNull;
+
 import org.jetbrains.annotations.NotNull;
 
 import promise.base.ID;
@@ -11,7 +13,9 @@
 import promise.database.HasOne;
 import promise.db.ActiveRecord;
 
-@Entity
+@Entity(
+    generateRelations = false
+)
 public class PostComment extends ActiveRecord<PostComment> {
   private String name;
   private ID uId;
@@ -63,6 +67,7 @@ public void setPostCommentId(String postCommentId) {
     this.postCommentId = postCommentId;
   }
 
+  @NonNull
   @Override
   public String toString() {
     return
diff --git a/app/src/main/java/promise/base/photo/Photo.kt b/app/src/main/java/promise/base/photo/Photo.kt
index 963b4e5..2bc0e13 100644
--- a/app/src/main/java/promise/base/photo/Photo.kt
+++ b/app/src/main/java/promise/base/photo/Photo.kt
@@ -1,6 +1,5 @@
 package promise.base.photo
 
-import android.annotation.SuppressLint
 import android.os.Parcel
 import android.os.Parcelable
 import promise.base.post.Post
@@ -14,20 +13,19 @@ class Photo() : ActiveRecord<Photo>() {
   var title: String? = null
   var url: String? = null
   var thumbnailUrl: String? = null
+
   @HasOne
-  var post: Post? = null
+  var photoPost: Post? = null
 
   constructor(parcel: Parcel) : this() {
     albumId = parcel.readValue(Int::class.java.classLoader) as? Int
     title = parcel.readString()
     url = parcel.readString()
     thumbnailUrl = parcel.readString()
-    post = parcel.readParcelable(Post::class.java.classLoader)
+    photoPost = parcel.readParcelable(Post::class.java.classLoader)
   }
 
-  override fun getEntity(): Photo {
-    return this
-  }
+  override fun getEntity(): Photo = this
 
   override fun writeToParcel(parcel: Parcel, flags: Int) {
     super.writeToParcel(parcel, flags)
@@ -35,21 +33,14 @@ class Photo() : ActiveRecord<Photo>() {
     parcel.writeString(title)
     parcel.writeString(url)
     parcel.writeString(thumbnailUrl)
-    parcel.writeParcelable(post, flags)
+    parcel.writeParcelable(photoPost, flags)
   }
 
-  override fun describeContents(): Int {
-    return 0
-  }
+  override fun describeContents(): Int = 0
 
   companion object CREATOR : Parcelable.Creator<Photo> {
-    override fun createFromParcel(parcel: Parcel): Photo {
-      return Photo(parcel)
-    }
-
-    override fun newArray(size: Int): Array<Photo?> {
-      return arrayOfNulls(size)
-    }
+    override fun createFromParcel(parcel: Parcel): Photo = Photo(parcel)
+    override fun newArray(size: Int): Array<Photo?> = arrayOfNulls(size)
   }
 
 }
diff --git a/app/src/main/java/promise/base/post/Post.java b/app/src/main/java/promise/base/post/Post.java
index e8c1a82..0ed763f 100644
--- a/app/src/main/java/promise/base/post/Post.java
+++ b/app/src/main/java/promise/base/post/Post.java
@@ -7,6 +7,7 @@
 
 import org.jetbrains.annotations.NotNull;
 
+import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
 
@@ -14,13 +15,18 @@
 import promise.base.comment.Like;
 import promise.base.comment.PostComment;
 import promise.base.photo.Photo;
+import promise.database.ColumnInfo;
 import promise.database.Entity;
 import promise.database.HasMany;
 import promise.db.ActiveRecord;
 
 @Entity
 public class Post extends ActiveRecord<Post> {
+
+  @ColumnInfo(unique = true)
   private ID uId;
+
+  @ColumnInfo(columnName = "ttl", length = 40, unique = true)
   private String title;
   private String body;
   private int userId;
@@ -29,6 +35,7 @@ public class Post extends ActiveRecord<Post> {
   private Date publishedDate;
   @HasMany
   private List<PostComment> comments;
+
   @HasMany
   private List<Photo> photos;
   @HasMany
diff --git a/app/src/main/java/promise/base/post/PostRepository.kt b/app/src/main/java/promise/base/post/PostRepository.kt
index 7c0a3d1..0bb2aef 100644
--- a/app/src/main/java/promise/base/post/PostRepository.kt
+++ b/app/src/main/java/promise/base/post/PostRepository.kt
@@ -29,7 +29,9 @@ interface PostRepository {
 }
 
 @Singleton
-class PostRepositoryImpl @Inject constructor(
+class PostRepositoryImpl
+@Inject
+constructor(
     private var postRelationsDao: PostRelationsDao,
     private var postsTable: PostsTable) : PostRepository {
   init {
diff --git a/app/src/main/java/promise/base/session/User.kt b/app/src/main/java/promise/base/session/User.kt
index 3dad3b2..85e97cc 100644
--- a/app/src/main/java/promise/base/session/User.kt
+++ b/app/src/main/java/promise/base/session/User.kt
@@ -22,11 +22,10 @@ import promise.db.ActiveRecord
 @Entity
 @AddedEntity(fromVersion = 1, toVersion = 2)
 class User: ActiveRecord<User>() {
+
   var email: String = ""
   var likedinProfileUrl = ""
   var photoUrl = ""
   var names = ""
-  override fun getEntity(): User {
-    return this
-  }
+  override fun getEntity(): User = this
 }
\ No newline at end of file
diff --git a/app/src/main/java/promise/dbapp/AppComponent.kt b/app/src/main/java/promise/dbapp/AppComponent.kt
index 4c8637c..181ff15 100644
--- a/app/src/main/java/promise/dbapp/AppComponent.kt
+++ b/app/src/main/java/promise/dbapp/AppComponent.kt
@@ -29,14 +29,8 @@ import javax.inject.Singleton
 @Singleton
 interface AppComponent : AndroidInjector<App> {
 
-  //  fun postsTable(): PostsTable
-//  fun postRelationsDao(): PostRelationsDao
-  @Component.Builder
+  @Component.Factory
   interface Builder {
-
-    @BindsInstance
-    fun app(app: App): Builder
-
-    fun build(): AppComponent
+    fun create(@BindsInstance app: App): AppComponent
   }
 }
\ No newline at end of file
diff --git a/build.gradle b/build.gradle
index ea4b265..28fc2b6 100644
--- a/build.gradle
+++ b/build.gradle
@@ -14,7 +14,7 @@
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 
 buildscript {
-    ext.kotlin_version = '1.3.72'
+    ext.kotlin_version = '1.4.10'
     ext.supportLibVersion = "28.0.0"
 
     repositories {
@@ -23,7 +23,7 @@ buildscript {
         mavenCentral()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:3.6.3'
+        classpath 'com.android.tools.build:gradle:3.6.4'
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
         classpath 'com.github.dcendents:android-maven-gradle-plugin:2.1'
 
diff --git a/commons/src/main/java/promise/database/Text.kt b/commons/src/main/java/promise/database/ColumnInfo.kt
similarity index 77%
rename from commons/src/main/java/promise/database/Text.kt
rename to commons/src/main/java/promise/database/ColumnInfo.kt
index c8a4c2d..e2cb79b 100644
--- a/commons/src/main/java/promise/database/Text.kt
+++ b/commons/src/main/java/promise/database/ColumnInfo.kt
@@ -15,7 +15,10 @@ package promise.database
 
 @Target(AnnotationTarget.FIELD)
 @Retention(AnnotationRetention.SOURCE)
-annotation class Text(val columnName: String = "",
-                      val nullable: Boolean = true,
-                      val unique: Boolean = false,
-                      val index: Boolean = false)
\ No newline at end of file
+annotation class ColumnInfo(
+    val columnName: String = "",
+    val nullable: Boolean = true,
+    val unique: Boolean = false,
+    val default: Int = 0,
+    val length: Int = 0
+)
\ No newline at end of file
diff --git a/commons/src/main/java/promise/database/Entity.kt b/commons/src/main/java/promise/database/Entity.kt
index b50ba4d..e59aa3a 100644
--- a/commons/src/main/java/promise/database/Entity.kt
+++ b/commons/src/main/java/promise/database/Entity.kt
@@ -16,7 +16,8 @@ package promise.database
 @Target(AnnotationTarget.CLASS)
 @Retention(AnnotationRetention.SOURCE)
 annotation class Entity(val tableName: String = "",
-                        val compoundIndices: Array<CompoundIndex> = []
+                        val compoundIndices: Array<CompoundIndex> = [],
+                        val generateRelations: Boolean = true
 ) {
   @Target(AnnotationTarget.FIELD)
   @Retention(AnnotationRetention.SOURCE)
diff --git a/commons/src/main/java/promise/database/Number.kt b/commons/src/main/java/promise/database/Number.kt
deleted file mode 100644
index c7f7960..0000000
--- a/commons/src/main/java/promise/database/Number.kt
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * Copyright 2017, Peter Vincent
- * Licensed under the Apache License, Version 2.0, Android Promise.
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package promise.database
-
-@Target(AnnotationTarget.FIELD)
-@Retention(AnnotationRetention.SOURCE)
-annotation class Number(val columnName: String = "",
-                        val default: Int = 0,
-                        val nullable: Boolean = true,
-                        val unique: Boolean = false,
-                        val index: Boolean = false)
\ No newline at end of file
diff --git a/commons/src/main/java/promise/database/VarChar.kt b/commons/src/main/java/promise/database/VarChar.kt
deleted file mode 100644
index 6ecf994..0000000
--- a/commons/src/main/java/promise/database/VarChar.kt
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * Copyright 2017, Peter Vincent
- * Licensed under the Apache License, Version 2.0, Android Promise.
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package promise.database
-
-@Target(AnnotationTarget.FIELD)
-@Retention(AnnotationRetention.SOURCE)
-annotation class VarChar(val columnName: String = "",
-                         val length: Int,
-                         val nullable: Boolean = true,
-                         val unique: Boolean = false,
-                         val index: Boolean = false)
\ No newline at end of file
diff --git a/compiler/build.gradle b/compiler/build.gradle
index f61dc69..364783a 100644
--- a/compiler/build.gradle
+++ b/compiler/build.gradle
@@ -19,8 +19,8 @@ apply plugin: 'kotlin-kapt'
 apply plugin: 'maven'
 
 dependencies {
-    compileOnly 'com.github.android-promise.database:commons:1.0.3-alpha7'
-    //compileOnly project(path: ':commons')
+    //compileOnly 'com.github.android-promise.database:commons:1.0.3-alpha7'
+    compileOnly project(path: ':commons')
     compileOnly files(Jvm.current().getToolsJar())
     implementation 'com.google.auto.value:auto-value-annotations:1.7.4'
     kapt 'com.google.auto.value:auto-value:1.7.4'
@@ -29,7 +29,7 @@ dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
     implementation 'org.atteo:evo-inflector:1.0.1'
     implementation 'com.squareup:javapoet:1.13.0'
-    implementation "org.jetbrains.kotlin:kotlin-reflect:1.3.72"
+    implementation "org.jetbrains.kotlin:kotlin-reflect:1.4.10"
     implementation 'com.google.auto:auto-common:0.10'
     compileOnly "com.google.auto.service:auto-service:1.0-rc4"
     kapt "com.google.auto.service:auto-service:1.0-rc4"
diff --git a/compiler/src/main/java/promise/database/compiler/DatabaseAbstractMethodsGenerator.kt b/compiler/src/main/java/promise/database/compiler/DatabaseAbstractMethodsGenerator.kt
index 91c0ea4..2826ef2 100644
--- a/compiler/src/main/java/promise/database/compiler/DatabaseAbstractMethodsGenerator.kt
+++ b/compiler/src/main/java/promise/database/compiler/DatabaseAbstractMethodsGenerator.kt
@@ -95,18 +95,5 @@ class DatabaseAbstractMethodsGenerator(
 
     return funSpecs
   }
-//
-//  private fun getPackage(element: TypeElement, returnTypeName: String): String {
-//    if (entities.isEmpty()) entities = element.getTableEntities(processingEnv)
-//    var pack = ""
-//    entities.forEach {
-//      if (returnTypeName == it.getTableClassNameString()) {
-//        pack = processingEnv.elementUtils.getPackageOf(it).toString()
-//      }
-//    }
-//    return pack
-//
-//  }
-
 
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/database/compiler/EntityAnnotatedProcessor.kt b/compiler/src/main/java/promise/database/compiler/EntityAnnotatedProcessor.kt
index 89b0ac2..4ff2616 100644
--- a/compiler/src/main/java/promise/database/compiler/EntityAnnotatedProcessor.kt
+++ b/compiler/src/main/java/promise/database/compiler/EntityAnnotatedProcessor.kt
@@ -74,9 +74,6 @@ class EntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment,
 
     val classBuilder = TypeSpec.classBuilder(fileName)
         .addModifiers(Modifier.PUBLIC)
-        .addJavadoc("""
-          Table for ${element.simpleName}
-        """.trimIndent())
         .superclass(ParameterizedTypeName.get(
             ClassName.get("promise.db", "FastTable"),
             ClassName.get(pack, className))
@@ -111,9 +108,6 @@ class EntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment,
       classBuilder.addField(FieldSpec.builder(TypeName.get(TypeConverterAnnotatedProcessor
           .typeConverter!!.asType()), "typeConverter")
           .addModifiers(Modifier.PRIVATE)
-          .addJavadoc("""
-            TypeConverter for fields not directly persistable
-          """.trimIndent())
           .build())
       classBuilder.addMethod(MethodSpec.methodBuilder("setTypeConverter")
           .addModifiers(Modifier.PUBLIC)
@@ -129,9 +123,6 @@ class EntityAnnotatedProcessor(private val processingEnv: ProcessingEnvironment,
             ClassName.get(Integer::class.java)
         ), "idColumn")
         .addModifiers(Modifier.STATIC, Modifier.PUBLIC, Modifier.FINAL)
-        .addJavadoc("""
-          Column for primary key
-        """.trimIndent())
         .initializer(CodeBlock.of("FastTable.getId()")).build()
 
     classBuilder.addField(idColumnSpec)
diff --git a/compiler/src/main/java/promise/database/compiler/PromiseDatabaseCompiler.kt b/compiler/src/main/java/promise/database/compiler/PromiseDatabaseCompiler.kt
index 44d80dc..b718fd5 100644
--- a/compiler/src/main/java/promise/database/compiler/PromiseDatabaseCompiler.kt
+++ b/compiler/src/main/java/promise/database/compiler/PromiseDatabaseCompiler.kt
@@ -105,11 +105,10 @@ class PromiseDatabaseCompiler : AbstractProcessor() {
                 See the License for the specific language governing permissions and
                 limitations under the License
                 
-                Resource https://github.com/android-promise/database
+                https://github.com/android-promise/database
                 
                 Generated by Android Promise Database Compiler, do not modify
-              
-            """.trimIndent()
+            """.trimMargin(" ").trim()
             )
             .build()
             .writeTo(processingEnv.filer)
diff --git a/compiler/src/main/java/promise/database/compiler/RelationsDaoGenerator.java b/compiler/src/main/java/promise/database/compiler/RelationsDaoGenerator.java
index 6d851fa..52d3b85 100644
--- a/compiler/src/main/java/promise/database/compiler/RelationsDaoGenerator.java
+++ b/compiler/src/main/java/promise/database/compiler/RelationsDaoGenerator.java
@@ -13,6 +13,11 @@
 
 package promise.database.compiler;
 
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
+import com.google.common.base.MoreObjects;
+import com.google.common.collect.MoreCollectors;
+import com.google.common.util.concurrent.MoreExecutors;
 import com.squareup.javapoet.ArrayTypeName;
 import com.squareup.javapoet.ClassName;
 import com.squareup.javapoet.CodeBlock;
@@ -28,6 +33,8 @@
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
 import javax.annotation.processing.ProcessingEnvironment;
@@ -37,6 +44,8 @@
 import javax.lang.model.element.VariableElement;
 import javax.lang.model.type.TypeMirror;
 import javax.lang.model.util.ElementFilter;
+import javax.lang.model.util.ElementKindVisitor7;
+import javax.lang.model.util.SimpleElementVisitor7;
 
 import kotlin.Pair;
 import promise.database.Entity;
@@ -102,13 +111,13 @@ public List<JavaFile.Builder> generate() throws Exception {
     tableAndRelationElements.put(parentRelationTableClassName, element);
     relationElements.forEach(relationElement -> {
       if (relationElement.getAnnotation(HasMany.class) != null) try {
-        Pair<ClassName, Element> pair = generateForHasManyRelation(relationElement, constructorParameters);
+        Pair<ClassName, Element> pair = generateForHasManyRelation(relationElement, constructorParameters, tableAndRelationElements);
         if (pair != null) tableAndRelationElements.put(pair.getFirst(), pair.getSecond());
       } catch (Exception e) {
         LogUtil.e(e, relationElement);
       }
       else if (relationElement.getAnnotation(HasOne.class) != null) try {
-        Pair<ClassName, Element> pair = generateForHasOneRelation(relationElement, constructorParameters);
+        Pair<ClassName, Element> pair = generateForHasOneRelation(relationElement, constructorParameters, tableAndRelationElements);
         if (pair != null) tableAndRelationElements.put(pair.getFirst(), pair.getSecond());
       } catch (Exception e) {
         LogUtil.e(e, relationElement);
@@ -129,7 +138,9 @@ else if (relationElement.getAnnotation(HasOne.class) != null) try {
     return javaFiles;
   }
 
-  private Pair<ClassName, Element> generateForHasManyRelation(Element hasManyRelationFieldElement, ArrayList<ParameterSpec> constructorParameters) throws Exception {
+  private Pair<ClassName, Element> generateForHasManyRelation(Element hasManyRelationFieldElement,
+                                                              ArrayList<ParameterSpec> constructorParameters,
+                                                              HashMap<ClassName, Element> tableAndRelationElements) throws Exception {
     if (JavaUtils.isCollectionType(processingEnvironment, (VariableElement) hasManyRelationFieldElement)) {
       List<? extends TypeMirror> typeMirrors = JavaUtils.getParameterizedTypeMirrors((VariableElement) hasManyRelationFieldElement);
       if (typeMirrors != null) {
@@ -143,6 +154,11 @@ private Pair<ClassName, Element> generateForHasManyRelation(Element hasManyRelat
         TypeElement relationElement = UtilsKt.asTypeElement(typeMirrors.get(0), processingEnvironment);
         if (relationElement.getAnnotation(Entity.class) == null)
           throw new Exception("Element related to " + element.getSimpleName() + " as HasMany in " + hasManyRelationFieldElement.getSimpleName() + " field is not marked as an Entity");
+        if (tableAndRelationElements.entrySet().stream().anyMatch(classNameElementEntry -> PersistableEntityUtilsKt.getTableName(classNameElementEntry.getValue())
+            .equals(PersistableEntityUtilsKt.getTableName(UtilsKt.asTypeElement(relationElement.asType(), processingEnvironment))))) {
+          LogUtil.e(new IllegalStateException("Relation has been repeated in "+element),  hasManyRelationFieldElement);
+          return null;
+        }
 
         VariableElement relationHasOneRelatedElement = null;
         for (VariableElement elem : ElementFilter.fieldsIn(relationElement.getEnclosedElements()))
@@ -328,7 +344,15 @@ private Pair<ClassName, Element> generateForHasManyRelation(Element hasManyRelat
     return null;
   }
 
-  private Pair<ClassName, Element> generateForHasOneRelation(Element hasOneRelationFieldElement, ArrayList<ParameterSpec> constructorParameters) throws Exception {
+  private Pair<ClassName, Element> generateForHasOneRelation(Element hasOneRelationFieldElement,
+                                                             ArrayList<ParameterSpec> constructorParameters,
+                                                             HashMap<ClassName, Element> tableAndRelationElements) throws Exception {
+    if (tableAndRelationElements.entrySet().stream().anyMatch(classNameElementEntry -> PersistableEntityUtilsKt.getTableName(classNameElementEntry.getValue())
+        .equals(PersistableEntityUtilsKt.getTableName(
+            UtilsKt.asTypeElement(hasOneRelationFieldElement.asType(), processingEnvironment))))) {
+        LogUtil.e(new IllegalStateException("Relation has been repeated in "+element),  hasOneRelationFieldElement);
+        return null;
+    }
     if (!JavaUtils.isCollectionType(processingEnvironment, (VariableElement) hasOneRelationFieldElement)) {
       TypeMirror typeMirror = JavaUtils.getTypeMirror((VariableElement) hasOneRelationFieldElement);
       if (typeMirror != null) {
@@ -370,7 +394,7 @@ private Pair<ClassName, Element> generateForHasOneRelation(Element hasOneRelatio
             .build());
 
 
-        classBuilder.addMethod(MethodSpec.methodBuilder("paginateWith" + relationElementVarNames)
+        classBuilder.addMethod(MethodSpec.methodBuilder("paginateWith" + pluralize(capitalizeFirst(hasOneRelationFieldName)))
             .addModifiers(Modifier.PUBLIC)
             .addParameter(int.class, "skip")
             .addParameter(int.class, "limit")
@@ -386,12 +410,12 @@ private Pair<ClassName, Element> generateForHasOneRelation(Element hasOneRelatio
                             ClassName.get(element.asType())
                         )
                     ))
-                .addStatement("return populateWith" + capitalizeFirst(relationElementVarNames) + "(" + parentElementVarNames + ")")
+                .addStatement("return populateWith" + pluralize(capitalizeFirst(hasOneRelationFieldName)) + "(" + parentElementVarNames + ")")
                 .build())
             .build());
 
 
-        classBuilder.addMethod(MethodSpec.methodBuilder("listWith" + relationElementVarNames)
+        classBuilder.addMethod(MethodSpec.methodBuilder("listWith" + pluralize(capitalizeFirst(hasOneRelationFieldName)))
             .addModifiers(Modifier.PUBLIC)
             .returns(ParameterizedTypeName.get(ClassName.get("promise.model", "IdentifiableList"),
                 WildcardTypeName.subtypeOf(
@@ -405,11 +429,11 @@ private Pair<ClassName, Element> generateForHasOneRelation(Element hasOneRelatio
                             ClassName.get(element.asType())
                         )
                     ))
-                .addStatement("return populateWith" + capitalizeFirst(relationElementVarNames) + "(" + parentElementVarNames + ")")
+                .addStatement("return populateWith" + pluralize(capitalizeFirst(hasOneRelationFieldName)) + "(" + parentElementVarNames + ")")
                 .build())
             .build());
 
-        classBuilder.addMethod(MethodSpec.methodBuilder("listWith" + relationElementVarNames)
+        classBuilder.addMethod(MethodSpec.methodBuilder("listWith" + pluralize(capitalizeFirst(hasOneRelationFieldName)))
             .addModifiers(Modifier.PUBLIC)
             .addParameter(ArrayTypeName.of(
                 ParameterizedTypeName.get(ClassName.get("promise.db", "Column"),
@@ -427,11 +451,11 @@ private Pair<ClassName, Element> generateForHasOneRelation(Element hasOneRelatio
                             ClassName.get(element.asType())
                         )
                     ))
-                .addStatement("return populateWith" + capitalizeFirst(relationElementVarNames) + "(" + parentElementVarNames + ")")
+                .addStatement("return populateWith" + pluralize(capitalizeFirst(hasOneRelationFieldName)) + "(" + parentElementVarNames + ")")
                 .build())
             .build());
 
-        classBuilder.addMethod(MethodSpec.methodBuilder("populateWith" + relationElementVarNames)
+        classBuilder.addMethod(MethodSpec.methodBuilder("populateWith" + pluralize(capitalizeFirst(hasOneRelationFieldName)))
             .addModifiers(Modifier.PUBLIC)
             .addParameter(ParameterizedTypeName.get(ClassName.get("promise.model", "IdentifiableList"),
                 WildcardTypeName.subtypeOf(
@@ -471,7 +495,7 @@ private Pair<ClassName, Element> generateForHasOneRelation(Element hasOneRelatio
             .build());
 
 
-        classBuilder.addMethod(MethodSpec.methodBuilder("get" + relationElementVarName)
+        classBuilder.addMethod(MethodSpec.methodBuilder("get" + capitalizeFirst(hasOneRelationFieldName))
             .addParameter(TypeName.get(element.asType()), parentElementVarName)
             .addModifiers(Modifier.PUBLIC)
             .returns(TypeName.get(relationElement.asType()))
@@ -480,8 +504,7 @@ private Pair<ClassName, Element> generateForHasOneRelation(Element hasOneRelatio
                 .build())
             .build());
 
-
-        classBuilder.addMethod(MethodSpec.methodBuilder("saveWith" + relationElementVarNames)
+        classBuilder.addMethod(MethodSpec.methodBuilder("saveWith" + pluralize(capitalizeFirst(hasOneRelationFieldName)))
             .addModifiers(Modifier.PUBLIC)
             .returns(boolean.class)
             .addParameter(ParameterizedTypeName.get(ClassName.get("promise.model", "IdentifiableList"),
diff --git a/compiler/src/main/java/promise/database/compiler/RelationsDaoProcessor.kt b/compiler/src/main/java/promise/database/compiler/RelationsDaoProcessor.kt
index 6de5007..29ec5ff 100644
--- a/compiler/src/main/java/promise/database/compiler/RelationsDaoProcessor.kt
+++ b/compiler/src/main/java/promise/database/compiler/RelationsDaoProcessor.kt
@@ -27,6 +27,7 @@ class RelationsDaoProcessor(private val processingEnv: ProcessingEnvironment) :
     val javaFiles = ArrayList<JavaFile.Builder?>()
     environment?.getElementsAnnotatedWith(Entity::class.java)
         ?.forEach { element ->
+          if (element.getAnnotation(Entity::class.java).generateRelations)
           javaFiles.addAll(processElementDaos(element))
         }
     return javaFiles
diff --git a/compiler/src/main/java/promise/database/compiler/TableColumnFieldsGenerator.kt b/compiler/src/main/java/promise/database/compiler/TableColumnFieldsGenerator.kt
index c764eea..649273c 100644
--- a/compiler/src/main/java/promise/database/compiler/TableColumnFieldsGenerator.kt
+++ b/compiler/src/main/java/promise/database/compiler/TableColumnFieldsGenerator.kt
@@ -18,6 +18,7 @@ import com.squareup.javapoet.CodeBlock
 import com.squareup.javapoet.FieldSpec
 import com.squareup.javapoet.ParameterizedTypeName
 import com.squareup.javapoet.TypeName
+import promise.database.ColumnInfo
 import promise.database.HasOne
 import promise.database.Ignore
 import promise.database.PrimaryKey
@@ -37,7 +38,6 @@ class TableColumnFieldsGenerator(
     private val processingEnvironment: ProcessingEnvironment,
     private val setElements: List<Element>) : CodeGenerator<Map<Pair<Element, String>, FieldSpec>> {
 
-
   var genColValues: ArrayList<Pair<Pair<String, Element>, String>> = ArrayList()
 
   override fun generate(): Map<Pair<Element, String>, FieldSpec> {
@@ -59,10 +59,7 @@ class TableColumnFieldsGenerator(
               TypeName.get(String::class.java))
           val columnInitializer = getColumnInitializer(element, ClassName.get(String::class.java))
           val spec = FieldSpec.builder(parameterizedColumnTypeName, colVariableName)
-              .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
-              .addJavadoc("""
-                Column field for ${element.simpleName}
-              """.trimIndent())
+              .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)
               .initializer(CodeBlock.of("""
               new Column<String>("$nameOfColumn", $columnInitializer, ${i + 1})
             """.trimIndent())
@@ -81,10 +78,7 @@ class TableColumnFieldsGenerator(
               TypeName.get(Integer::class.java))
           val columnInitializer = getColumnInitializer(element, ClassName.get(Integer::class.java))
           val spec = FieldSpec.builder(parameterizedColumnTypeName, colVariableName)
-              .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
-              .addJavadoc("""
-                Column field for ${element.simpleName}
-              """.trimIndent())
+              .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)
               .initializer(CodeBlock.of("""
               new Column<Integer>("$nameOfColumn", $columnInitializer, ${i + 1})
             """.trimIndent())
@@ -113,10 +107,7 @@ class TableColumnFieldsGenerator(
         variableClassType)
     val columnInitializer = getColumnInitializer(element, variableClassType)
     return FieldSpec.builder(parameterizedColumnTypeName, colVariableName)
-        .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
-        .addJavadoc("""
-                Column field for ${element.simpleName}
-              """.trimIndent())
+        .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)
         .initializer(CodeBlock.of("""
               new Column<${variableClassType}>("$nameOfColumn", $columnInitializer, ${i + 1})
             """.trimIndent())
@@ -133,8 +124,8 @@ class TableColumnFieldsGenerator(
         classTypeName.isSameAs(Boolean::class.java)) {
       str += ".INTEGER"
       if (element.getAnnotation(PrimaryKey::class.java) != null) str += ".PRIMARY_KEY()"
-      else if (element.getAnnotation(promise.database.Number::class.java) != null) {
-        val annotation = element.getAnnotation(promise.database.Number::class.java)
+      else if (element.getAnnotation(ColumnInfo::class.java) != null) {
+        val annotation = element.getAnnotation(ColumnInfo::class.java)
         if (annotation.default != 0) {
           str += ".DEFAULT(${annotation.default})"
         } else {
@@ -143,51 +134,32 @@ class TableColumnFieldsGenerator(
         }
       } else str += ".NULLABLE()"
     } else if (classTypeName.isSameAs(String::class.java)) {
-      if (element.getAnnotation(promise.database.VarChar::class.java) != null) {
-        str += ".VARCHAR"
-        val annotation = element.getAnnotation(promise.database.VarChar::class.java)
-        str += if (annotation.unique && annotation.length != 0)
-          ".UNIQUE(${annotation.length})"
-        else if (annotation.nullable && annotation.length != 0)
-          ".NULLABLE(${annotation.length})"
-        else if (!annotation.nullable && annotation.length != 0)
-          ".NOT_NULL(${annotation.length})"
-        else LogUtil.e(IllegalStateException("element ${element.simpleName} is annotated as varchar without length"), element)
-      } else {
-        if (element.getAnnotation(promise.database.Text::class.java) != null) {
+      if (element.getAnnotation(ColumnInfo::class.java) != null) {
+        val annotation = element.getAnnotation(ColumnInfo::class.java)
+        if (annotation.length != 0) {
+          str += ".VARCHAR"
+          str += if (annotation.unique)
+            ".UNIQUE(${annotation.length})"
+          else if (annotation.nullable)
+            ".NULLABLE(${annotation.length})"
+          else if (!annotation.nullable)
+            ".NOT_NULL(${annotation.length})"
+          else LogUtil.e(IllegalStateException("element ${element.simpleName} is annotated as varchar without length"), element)
+        } else {
           str += ".TEXT"
-          val annotation = element.getAnnotation(promise.database.Text::class.java)
           str += if (annotation.nullable)
             ".NULLABLE()"
           else if (!annotation.nullable)
             ".NOT_NULL()"
           else
             LogUtil.e(IllegalStateException("unknown error in  ${element.simpleName}"), element)
-        } else str += ".TEXT.NULLABLE()"
-      }
-    } else {
-      if (element.getAnnotation(promise.database.VarChar::class.java) != null) {
-        str += ".VARCHAR"
-        val annotation = element.getAnnotation(promise.database.VarChar::class.java)
-        str += if (annotation.unique && annotation.length != 0)
-          ".UNIQUE(${annotation.length})"
-        else if (annotation.nullable && annotation.length != 0)
-          ".NULLABLE(${annotation.length})"
-        else if (!annotation.nullable && annotation.length != 0)
-          ".NOT_NULL(${annotation.length})"
-        else LogUtil.e(IllegalStateException("element ${element.simpleName} is annotated as varchar without length"), element)
-      } else {
-        if (element.getAnnotation(promise.database.Text::class.java) != null) {
-          str += ".TEXT"
-          val annotation = element.getAnnotation(promise.database.Text::class.java)
-          str += if (annotation.nullable)
-            ".NULLABLE()"
-          else if (!annotation.nullable)
-            ".NOT_NULL()"
-          else LogUtil.e(IllegalStateException("unknown error in  ${element.simpleName} "), element)
-        } else
-          str += ".TEXT.NULLABLE()"
-      }
+        }
+      } else str += ".TEXT.NULLABLE()"
+    }
+    else {
+      // TODO implement this block
+      // for type converter columns
+
     }
     return str
   }
diff --git a/compiler/src/main/java/promise/database/compiler/TableDeserializerMethodGenerator.kt b/compiler/src/main/java/promise/database/compiler/TableDeserializerMethodGenerator.kt
index 2c3c180..6cc08a7 100644
--- a/compiler/src/main/java/promise/database/compiler/TableDeserializerMethodGenerator.kt
+++ b/compiler/src/main/java/promise/database/compiler/TableDeserializerMethodGenerator.kt
@@ -54,7 +54,6 @@ class TableDeserializerMethodGenerator(
         .addParameter(ClassName.get("android.database", "Cursor"), "e")
         .addAnnotation(Override::class.java)
         .addModifiers(Modifier.PUBLIC)
-        .addJavadoc("Deserializer converts from cursor to the entity")
         .returns(ClassName.get(typeDataTypePack, typeDataType))
         .addCode(codeBlock.build())
         .build()
diff --git a/compiler/src/main/java/promise/database/compiler/TableRegisteredColumnsMethodGenerator.kt b/compiler/src/main/java/promise/database/compiler/TableRegisteredColumnsMethodGenerator.kt
index 5fe5536..ddf1f97 100644
--- a/compiler/src/main/java/promise/database/compiler/TableRegisteredColumnsMethodGenerator.kt
+++ b/compiler/src/main/java/promise/database/compiler/TableRegisteredColumnsMethodGenerator.kt
@@ -44,9 +44,6 @@ class TableRegisteredColumnsMethodGenerator(
         .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
         .addAnnotation(Override::class.java)
         .addAnnotation(NotNull::class.java)
-        .addJavadoc("""
-          Registered columns for this table
-        """.trimIndent())
         .addCode(CodeBlock.of(stmt))
         .build()
   }
diff --git a/compiler/src/main/java/promise/database/compiler/TableSerializerMethodGenerator.kt b/compiler/src/main/java/promise/database/compiler/TableSerializerMethodGenerator.kt
index 339d6cf..3d5d9e8 100644
--- a/compiler/src/main/java/promise/database/compiler/TableSerializerMethodGenerator.kt
+++ b/compiler/src/main/java/promise/database/compiler/TableSerializerMethodGenerator.kt
@@ -42,12 +42,10 @@ class TableSerializerMethodGenerator(
       generatePutStatement(codeBlock, it.first.first, it.second, it.first.second)
     }
     codeBlock.addStatement("return values")
-
     return MethodSpec.methodBuilder("serialize")
         .addModifiers(Modifier.PUBLIC)
         .addParameter(ClassName.get(typeDataTypePack, typeDataType), "t")
         .addAnnotation(Override::class.java)
-        .addJavadoc("Serializer converts from the entity to ContentValues")
         .returns(ClassName.get("android.content", "ContentValues"))
         .addCode(codeBlock.build())
         .build()
diff --git a/compiler/src/main/java/promise/database/compiler/utils/PersistableEntityUtils.kt b/compiler/src/main/java/promise/database/compiler/utils/PersistableEntityUtils.kt
index 18c0666..9fd20fd 100644
--- a/compiler/src/main/java/promise/database/compiler/utils/PersistableEntityUtils.kt
+++ b/compiler/src/main/java/promise/database/compiler/utils/PersistableEntityUtils.kt
@@ -17,14 +17,13 @@ import com.squareup.javapoet.ClassName
 import com.squareup.javapoet.TypeName
 import com.sun.tools.javac.code.Attribute
 import org.atteo.evo.inflector.English
+import promise.database.ColumnInfo
 import promise.database.DatabaseEntity
 import promise.database.Entity
 import promise.database.ForeignKey
 import promise.database.HasMany
 import promise.database.HasOne
 import promise.database.Index
-import promise.database.Text
-import promise.database.VarChar
 import promise.database.compiler.TypeConverterAnnotatedProcessor
 import java.io.IOException
 import javax.annotation.processing.ProcessingEnvironment
@@ -139,15 +138,15 @@ fun Element.getNameOfColumn(): String {
           this.toTypeName().isSameAs(Long::class.java) ||
           this.toTypeName().isSameAs(Double::class.java) ||
           this.toTypeName().isSameAs(Boolean::class.java)) &&
-      this.getAnnotation(promise.database.Number::class.java) != null) {
-    name = this.getAnnotation(promise.database.Number::class.java).columnName
+      this.getAnnotation(ColumnInfo::class.java) != null) {
+    name = this.getAnnotation(ColumnInfo::class.java).columnName
   } else if (this.toTypeName().isSameAs(String::class.java) &&
-      this.getAnnotation(VarChar::class.java) != null) {
-    name = this.getAnnotation(VarChar::class.java).columnName
-  } else if (this.getAnnotation(Text::class.java) != null) {
-    name = this.getAnnotation(Text::class.java).columnName
-  } else if (this.getAnnotation(VarChar::class.java) != null) {
-    name = this.getAnnotation(VarChar::class.java).columnName
+      this.getAnnotation(ColumnInfo::class.java) != null) {
+    name = this.getAnnotation(ColumnInfo::class.java).columnName
+  } else if (this.getAnnotation(ColumnInfo::class.java) != null) {
+    name = this.getAnnotation(ColumnInfo::class.java).columnName
+  } else if (this.getAnnotation(ColumnInfo::class.java) != null) {
+    name = this.getAnnotation(ColumnInfo::class.java).columnName
   }
   if (name != null && name.isNotEmpty()) return name
   return this.simpleName.toString()
@@ -160,15 +159,15 @@ fun Element.isColumnNullable(): Boolean {
           this.toTypeName().isSameAs(Long::class.java) ||
           this.toTypeName().isSameAs(Double::class.java) ||
           this.toTypeName().isSameAs(Boolean::class.java)) &&
-      this.getAnnotation(promise.database.Number::class.java) != null) {
-    nullable = this.getAnnotation(promise.database.Number::class.java).nullable
+      this.getAnnotation(promise.database.ColumnInfo::class.java) != null) {
+    nullable = this.getAnnotation(promise.database.ColumnInfo::class.java).nullable
   } else if (this.toTypeName().isSameAs(String::class.java) &&
-      this.getAnnotation(VarChar::class.java) != null) {
-    nullable = this.getAnnotation(VarChar::class.java).nullable
-  } else if (this.getAnnotation(Text::class.java) != null) {
-    nullable = this.getAnnotation(Text::class.java).nullable
-  } else if (this.getAnnotation(VarChar::class.java) != null) {
-    nullable = this.getAnnotation(VarChar::class.java).nullable
+      this.getAnnotation(ColumnInfo::class.java) != null) {
+    nullable = this.getAnnotation(ColumnInfo::class.java).nullable
+  } else if (this.getAnnotation(ColumnInfo::class.java) != null) {
+    nullable = this.getAnnotation(ColumnInfo::class.java).nullable
+  } else if (this.getAnnotation(ColumnInfo::class.java) != null) {
+    nullable = this.getAnnotation(ColumnInfo::class.java).nullable
   }
   return nullable
 }
diff --git a/database/build.gradle b/database/build.gradle
index d7134b0..6b766f2 100644
--- a/database/build.gradle
+++ b/database/build.gradle
@@ -24,11 +24,9 @@ android {
         versionCode 1
         versionName "1.0"
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
-
     }
 
     buildTypes {
-
         release {
             minifyEnabled false
             proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
@@ -42,16 +40,16 @@ android {
 }
 
 dependencies {
-    api 'com.github.android-promise.database:commons:1.0.3-alpha7'
-    //api project(path: ':commons')
+    //api 'com.github.android-promise.database:commons:1.0.3-alpha7'
+    api project(path: ':commons')
     api 'androidx.sqlite:sqlite:2.1.0'
     implementation 'androidx.sqlite:sqlite-framework:2.1.0'
     compileOnly 'io.reactivex.rxjava2:rxjava:2.2.17'
-    implementation 'androidx.core:core-ktx:1.3.1'
+    implementation 'androidx.core:core-ktx:1.3.2'
     compileOnly 'com.github.android-promise:commons:1.1-beta02'
     testImplementation 'junit:junit:4.13'
-    androidTestImplementation 'androidx.test:runner:1.2.0'
-    androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
+    androidTestImplementation 'androidx.test:runner:1.3.0'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
 }
 repositories {
diff --git a/database/src/main/java/promise/db/DMLVisitors.kt b/database/src/main/java/promise/db/DMLVisitors.kt
index a97ab38..e3436b2 100644
--- a/database/src/main/java/promise/db/DMLVisitors.kt
+++ b/database/src/main/java/promise/db/DMLVisitors.kt
@@ -21,7 +21,7 @@ import promise.commons.model.List
 import promise.model.IdentifiableList
 import promise.utils.Visitor
 
-class UpdateVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteDatabase,
+internal class UpdateVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteDatabase,
                                            private val instance: T,
                                            private val column: Column<*>? = null) : Visitor<TableCrud<T, in SupportSQLiteDatabase>, Boolean> {
 
@@ -44,7 +44,7 @@ class UpdateVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteDatabase,
   }
 }
 
-class DeleteVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteDatabase,
+internal class DeleteVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteDatabase,
                                            private val instance: T) : Visitor<TableCrud<T, in SupportSQLiteDatabase>, Boolean> {
   override fun visit(t: TableCrud<T, in SupportSQLiteDatabase>): Boolean {
     fun onDelete(x: SupportSQLiteDatabase, column: Column<*>): Boolean {
@@ -55,7 +55,7 @@ class DeleteVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteDatabase,
   }
 }
 
-class DeleteErasureVisitor(private val x: SupportSQLiteDatabase,
+internal class DeleteErasureVisitor(private val x: SupportSQLiteDatabase,
                            private val column: Column<*>? = null) : Visitor<TableCrud<*, in SupportSQLiteDatabase>, Boolean> {
   override fun visit(t: TableCrud<*, in SupportSQLiteDatabase>): Boolean {
     fun onDelete(x: SupportSQLiteDatabase): Boolean =
@@ -70,7 +70,7 @@ class DeleteErasureVisitor(private val x: SupportSQLiteDatabase,
   }
 }
 
-class DeleteListErasureVisitor<C>(private val x: SupportSQLiteDatabase,
+internal class DeleteListErasureVisitor<C>(private val x: SupportSQLiteDatabase,
                                   private val column: Column<C>,
                                   private val list: List<out C>) : Visitor<TableCrud<*, in SupportSQLiteDatabase>, Boolean> {
   override fun visit(t: TableCrud<*, in SupportSQLiteDatabase>): Boolean {
@@ -93,7 +93,7 @@ class DeleteListErasureVisitor<C>(private val x: SupportSQLiteDatabase,
   }
 }
 
-class SaveVisitor<T : Identifiable<Int>>(
+internal class SaveVisitor<T : Identifiable<Int>>(
     private val updateVisitor: Visitor<TableCrud<T, in SupportSQLiteDatabase>, Boolean>,
     private val x: SupportSQLiteDatabase,
     private val instance: T
@@ -110,7 +110,7 @@ class SaveVisitor<T : Identifiable<Int>>(
   }
 }
 
-class SaveListVisitor<T : Identifiable<Int>>(
+internal class SaveListVisitor<T : Identifiable<Int>>(
     private val x: SupportSQLiteDatabase,
     private val list: IdentifiableList<out T>
 ) : Visitor<TableCrud<T, in SupportSQLiteDatabase>, Boolean> {
diff --git a/database/src/main/java/promise/db/FastDatabaseImpl.kt b/database/src/main/java/promise/db/FastDatabaseImpl.kt
index 1459824..382fe35 100644
--- a/database/src/main/java/promise/db/FastDatabaseImpl.kt
+++ b/database/src/main/java/promise/db/FastDatabaseImpl.kt
@@ -273,6 +273,10 @@ open class FastDatabaseImpl constructor(
 
   override fun <R : Any> accept(visitor: Visitor<FastDatabase, R>): R = visitor.visit(this)
 
+/**
+incomplete function body
+TODO to be revisited
+ */
   private fun <T : Identifiable<Int>> checkTableExist(tableCrud: TableCrud<T, in SupportSQLiteDatabase>): TableCrud<T, in SupportSQLiteDatabase> =
       Conditions.checkNotNull(tableCrud)
 
diff --git a/database/src/main/java/promise/db/FetchVisitors.kt b/database/src/main/java/promise/db/FetchVisitors.kt
index 9e117b2..323a24c 100644
--- a/database/src/main/java/promise/db/FetchVisitors.kt
+++ b/database/src/main/java/promise/db/FetchVisitors.kt
@@ -27,7 +27,7 @@ import promise.model.ITimeStamped
 import promise.model.IdentifiableList
 import promise.utils.Visitor
 
-class FetchLastIdVisitor(private val x: SupportSQLiteDatabase) : Visitor<TableCrud<*, in SupportSQLiteDatabase>, Int> {
+internal class FetchLastIdVisitor(private val x: SupportSQLiteDatabase) : Visitor<TableCrud<*, in SupportSQLiteDatabase>, Int> {
   override fun visit(t: TableCrud<*, in SupportSQLiteDatabase>): Int {
     val builder: QueryBuilder = t.queryBuilder().select(Projection.count(FastTable.id).`as`("num"))
     @SuppressLint("Recycle") val cursor = x.query(builder.build(), builder.buildParameters())
@@ -35,7 +35,7 @@ class FetchLastIdVisitor(private val x: SupportSQLiteDatabase) : Visitor<TableCr
   }
 }
 
-class FetchAllVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteDatabase,
+internal class FetchAllVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteDatabase,
                                              private val columns: Array<out Column<*>>? = null) : Visitor<TableCrud<T, in SupportSQLiteDatabase>, IdentifiableList<out T>> {
 
   override fun visit(t: TableCrud<T, in SupportSQLiteDatabase>): IdentifiableList<out T> {
@@ -59,7 +59,7 @@ class FetchAllVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteDatabas
 }
 
 @Suppress("KDocUnresolvedReference")
-class FetchExtrasVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteDatabase) : Visitor<TableCrud<T, in SupportSQLiteDatabase>, TableCrud.Extras<T>> {
+internal class FetchExtrasVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteDatabase) : Visitor<TableCrud<T, in SupportSQLiteDatabase>, TableCrud.Extras<T>> {
 
   override fun visit(t: TableCrud<T, in SupportSQLiteDatabase>): TableCrud.Extras<T> =
       object : QueryExtras<T>(x, t) {
@@ -75,7 +75,7 @@ class FetchExtrasVisitor<T : Identifiable<Int>>(private val x: SupportSQLiteData
    * @param <Q> The type of the items in the table
   </Q> */
   @Suppress("UNCHECKED_CAST")
-  private abstract inner class QueryExtras<Q : Identifiable<Int>> internal constructor(
+  private abstract inner class QueryExtras<Q : Identifiable<Int>> constructor(
       /**
        * the database instance to readAsync fromm
        */
diff --git a/settings.gradle b/settings.gradle
index 39294d0..1455dc2 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -11,8 +11,7 @@
  * limitations under the License.
  */
 
-
-include  ':app'
+include ':app'
 include ':database'
 include ':compiler'
 include ':commons'

From 65208fab30e3ef2f1c71617e4403a2153b687084 Mon Sep 17 00:00:00 2001
From: Peter Vincent <39063789+dev4vin@users.noreply.github.com>
Date: Fri, 20 Nov 2020 13:59:43 +0300
Subject: [PATCH 34/34] updated dependencies

---
 app/src/main/java/promise/dbapp/App.kt                          | 2 +-
 .../java/promise/database/compiler/PromiseDatabaseCompiler.kt   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/app/src/main/java/promise/dbapp/App.kt b/app/src/main/java/promise/dbapp/App.kt
index 73b32bc..1ec7fb2 100644
--- a/app/src/main/java/promise/dbapp/App.kt
+++ b/app/src/main/java/promise/dbapp/App.kt
@@ -24,6 +24,6 @@ class App : DaggerApplication() {
   }
 
   override fun applicationInjector(): AndroidInjector<out DaggerApplication> =
-      DaggerAppComponent.builder().app(this).build()
+      DaggerAppComponent.factory().create(this)
 
 }
\ No newline at end of file
diff --git a/compiler/src/main/java/promise/database/compiler/PromiseDatabaseCompiler.kt b/compiler/src/main/java/promise/database/compiler/PromiseDatabaseCompiler.kt
index b718fd5..8a1ef02 100644
--- a/compiler/src/main/java/promise/database/compiler/PromiseDatabaseCompiler.kt
+++ b/compiler/src/main/java/promise/database/compiler/PromiseDatabaseCompiler.kt
@@ -108,7 +108,7 @@ class PromiseDatabaseCompiler : AbstractProcessor() {
                 https://github.com/android-promise/database
                 
                 Generated by Android Promise Database Compiler, do not modify
-            """.trimMargin(" ").trim()
+            """.trim()
             )
             .build()
             .writeTo(processingEnv.filer)