build.gradle

import java.nio.file.Paths
import groovy.json.JsonSlurper

buildscript {
  ext.getExtOrDefault = {name ->
    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['OPSQLite_' + name]
  }

  repositories {
    google()
    mavenCentral()
  }

  dependencies {
    classpath("com.android.tools.build:gradle:8.7.2")
    // noinspection DifferentKotlinGradleVersion
    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
  }
}

apply plugin: "com.android.library"
apply plugin: "kotlin-android"

apply plugin: "com.facebook.react"

def getExtOrIntegerDefault(name) {
  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["OPSQLite_" + name]).toInteger()
}

def useSQLCipher = false
def useLibsql = false
def useCRSQLite = false
def performanceMode = false
def sqliteFlags = ""
def enableFTS5 = false
def useSqliteVec = false
def enableRtree = false
def tokenizers = []

// On the example app, the package.json is located at the root of the project
// On the user app, the package.json is located at the root of the node_modules directory
def isUserApp = rootDir.absolutePath.contains("node_modules")
def packageJsonFile

if (isUserApp) {
  // Start from the root + 1 level up (to avoid detecting the op-sqlite/package.json) and traverse upwards to find the first package.json
  File currentDir = new File("$rootDir/../")
  packageJsonFile = null

  // Try to find package.json by traversing upwards
  while (currentDir != null) {
    File potential = new File(currentDir, "package.json")
    if (potential.exists()) {
      packageJsonFile = potential
      break
    }
    currentDir = currentDir.parentFile
  }
} else {
  packageJsonFile = new File("$rootDir/../package.json")
}


def packageJson = new JsonSlurper().parseText(packageJsonFile.text)

def opsqliteConfig = packageJson["op-sqlite"]

if(opsqliteConfig) {
  println "[OP-SQLITE] Detected op-sqlite config from package.json at: " + packageJsonFile.absolutePath
  useSQLCipher = opsqliteConfig["sqlcipher"]
  useCRSQLite = opsqliteConfig["crsqlite"]
  useSqliteVec = opsqliteConfig["sqliteVec"]

  performanceMode = opsqliteConfig["performanceMode"]
  sqliteFlags = opsqliteConfig["sqliteFlags"] ? opsqliteConfig["sqliteFlags"] : ""
  enableFTS5 = opsqliteConfig["fts5"]
  useLibsql = opsqliteConfig["libsql"]
  enableRtree = opsqliteConfig["rtree"]
  tokenizers = opsqliteConfig["tokenizers"] ? opsqliteConfig["tokenizers"] : []
}

if(useSQLCipher) {
  println "[OP-SQLITE] using sqlcipher."
} else if(useLibsql) {
  println "[OP-SQLITE] using libsql. Report any issues to Turso"
}

if(useCRSQLite) {
  println "[OP-SQLITE] using CR-SQLite"
}

if(performanceMode) {
  println "[OP-SQLITE] Performance mode enabled"
}

if(enableFTS5) {
  println "[OP-SQLITE] FTS5 enabled"
}

if(enableRtree) {
  println "[OP-SQLITE] RTree enabled"
}

if(useSqliteVec) {
  println "[OP-SQLITE] Sqlite-vec enabled"
}

if(!tokenizers.isEmpty()) {
  if(useLibsql) {
    throw new GradleException("[OP-SQLITE] Error: libsql does not support tokenizers. Please disable tokenizers or do not enable libsql.")
  }

  println "[OP-SQLITE] Tokenizers enabled. Detected tokenizers: " + tokenizers
}

android {
  namespace "com.op.sqlite"

  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")

  defaultConfig {
    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")

    buildConfigField "boolean", "USE_LIBSQL", "${useLibsql}"

    externalNativeBuild {
      cmake {
        if(useSQLCipher) {
          cFlags += "-DOP_SQLITE_USE_SQLCIPHER=1"
          cppFlags += "-DOP_SQLITE_USE_SQLCIPHER=1"
        }
        if(useLibsql) {
          cFlags += "-DOP_SQLITE_USE_LIBSQL=1"
          cppFlags += "-DOP_SQLITE_USE_LIBSQL=1"
        }
        if(useCRSQLite) {
          cFlags += "-DOP_SQLITE_USE_CRSQLITE=1"
          cppFlags += "-DOP_SQLITE_USE_CRSQLITE=1"
        }
        if(performanceMode) {
          cFlags += ["-DSQLITE_DQS=0", "-DSQLITE_DEFAULT_MEMSTATUS=0", "-DSQLITE_DEFAULT_WAL_SYNCHRONOUS=1", "-DSQLITE_LIKE_DOESNT_MATCH_BLOBS=1", "-DSQLITE_MAX_EXPR_DEPTH=0", "-DSQLITE_OMIT_DEPRECATED=1", "-DSQLITE_OMIT_PROGRESS_CALLBACK=1", "-DSQLITE_OMIT_SHARED_CACHE=1", "-DSQLITE_USE_ALLOCA=1", "-DSQLITE_THREADSAFE=1"]
        }
        if(enableFTS5) {
          cFlags += ["-DSQLITE_ENABLE_FTS5=1"]
        }
        if(enableRtree) {
          cFlags += ["-DSQLITE_ENABLE_RTREE=1"]
        }
        if(useSqliteVec) {
          cFlags += "-DOP_SQLITE_USE_SQLITE_VEC=1"
          cppFlags += "-DOP_SQLITE_USE_SQLITE_VEC=1"
        }

        // This are zeroes because they will be passed as C flags, so they become falsy
        def sourceFiles = 0
        // def tokenizerInitStrings = 0
        def tokenizersHeaderPath = 0
        if (!tokenizers.isEmpty()) {
          def sourceDir = isUserApp ? file("$rootDir/../../../c_sources") : file("$rootDir/../c_sources")
          def destDir = file("$buildscript.sourceFile.parentFile/c_sources")
          copy {
            from sourceDir
            into destDir
            include "**/*.cpp", "**/*.h"
          }
          sourceFiles = fileTree(dir: destDir, include: ["**/*.cpp", "**/*.h"]).files.join(";")
          tokenizersHeaderPath = "../c_sources/tokenizers.h"
        }

        cppFlags "-O3 -frtti -fexceptions -Wall -fstack-protector-all"

        arguments "-DANDROID_STL=c++_shared",
          "-DSQLITE_FLAGS='$sqliteFlags'",
          "-DUSE_SQLCIPHER=${useSQLCipher ? 1 : 0}",
          "-DUSE_CRSQLITE=${useCRSQLite ? 1 : 0}",
          "-DUSE_LIBSQL=${useLibsql ? 1 : 0}",
          "-DUSE_SQLITE_VEC=${useSqliteVec ? 1 : 0}",
          "-DUSER_DEFINED_SOURCE_FILES=${sourceFiles}",
          "-DUSER_DEFINED_TOKENIZERS_HEADER_PATH='${tokenizersHeaderPath}'",
          "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
      }
    }
  }

  buildFeatures {
    buildConfig true
    prefab true
    prefabPublishing true
  }

  buildTypes {
    release {
      minifyEnabled false
    }
  }

  prefab {
    "op-sqlite" {
      headers "${project.buildDir}/headers/op-sqlite/"
    }
  }

  lintOptions {
    disable "GradleCompatible"
  }

  compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
  }

  externalNativeBuild {
    cmake {
      path "CMakeLists.txt"
    }
  }

  sourceSets {
    main {
      java.srcDirs += [
        "generated/java",
        "generated/jni"
      ]
      jniLibs {
        srcDirs = []
        if (useLibsql) {
          srcDirs += 'src/main/jniLibs'
        }
        if (useCRSQLite) {
          srcDirs += 'src/main/libcrsqlite'
        }
        if (useSqliteVec) {
          srcDirs += 'src/main/libsqlitevec'
        }
      }
    }
  }
}

repositories {
  mavenCentral()
  google()
}

def kotlin_version = getExtOrDefault("kotlinVersion")

dependencies {
  implementation "com.facebook.react:react-android"
  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
  if (useSQLCipher) {
    implementation('io.github.ronickg:openssl:3.3.2-1')
  }
}

tasks.register('prepareHeaders', Copy) {
  from('../cpp')
  include "**/*.h", "**/*.hpp"
  into "${project.buildDir}/headers/op-sqlite/op-engineering_op-sqlite/"
  includeEmptyDirs = false
}

preBuild.dependsOn(prepareHeaders)