@tinkerlandai/indiana-react-native 0.9.2 → 0.9.5

package/native-sdk/android/java/ai/tinkerland/indiana/WireSchema.kt

@@ -0,0 +1,76 @@
+package ai.tinkerland.indiana
+import org.json.JSONObject
+import org.json.JSONArray
+import java.net.URI
+import java.util.UUID
+/** Generated contract interpreter for the native wire boundary; no business policy is evaluated here. */
+internal object IndianaSchema {
+    private val schemas: JSONObject by lazy { IndianaSchema::class.java.getResourceAsStream("/funnel-wire-schemas.json")?.bufferedReader(Charsets.UTF_8)?.use { JSONObject(it.readText()) } ?: throw IndianaClientException("invalid_response") }
+    fun validate(name: String, value: JSONObject) { val root = schemas.getJSONObject(name);if (!valid(value, root, root, 0)) throw IndianaClientException("invalid_response") }
+    fun customerResponse(name: String, value: JSONObject): JSONObject { val root = schemas.getJSONObject(name); return adapt(value, root, root, listOf(name), 0) as JSONObject }
+    private fun adapt(original: Any?, schema: JSONObject, root: JSONObject, path: List<String>, depth: Int): Any? {
+        if (depth > 100) throw IndianaClientException("invalid_response")
+        if (schema.has("\$ref")) { var target: Any = root; for (part in schema.getString("\$ref").substring(2).split('/')) target = (target as JSONObject).get(part.replace("~1", "/").replace("~0", "~")); return adapt(original, target as JSONObject, root, path, depth + 1) }
+        (schema.optJSONArray("anyOf") ?: schema.optJSONArray("oneOf"))?.let { branches -> val branch = (0 until branches.length()).map { branches.getJSONObject(it) }.firstOrNull { valid(original, it, root, 0) } ?: throw IndianaClientException("invalid_response"); return adapt(original, branch, root, path, depth + 1) }
+        var value = IndianaCustomerResponseSemantics.rules(original, schema)
+        schema.optJSONArray("allOf")?.let { branches -> for (n in 0 until branches.length()) value = adapt(value, branches.getJSONObject(n), root, path, depth + 1) }
+        if (value is JSONObject) {
+            val objectValue = value as JSONObject; val properties = schema.optJSONObject("properties") ?: JSONObject()
+            for (key in properties.keys()) if (objectValue.has(key)) objectValue.put(key, adapt(objectValue.get(key), properties.getJSONObject(key), root, path + key, depth + 1))
+            schema.optJSONObject("additionalProperties")?.let { additional -> for (key in objectValue.keys()) if (!properties.has(key)) objectValue.put(key, adapt(objectValue.get(key), additional, root, path + "{}", depth + 1)) }
+            IndianaCustomerResponseSemantics.objectValue(objectValue, properties.keys().asSequence().toSet(), path); return objectValue
+        }
+        if (value is JSONArray) { val array = value as JSONArray; schema.optJSONObject("items")?.let { child -> for (n in 0 until array.length()) array.put(n, adapt(array.opt(n), child, root, path + "[]", depth + 1)) }; return array }
+        if (value is String && schema.optString("pattern") in listOf("^(0|[1-9]\\d{0,11})(\\.\\d{1,6})?$", "^-?(0|[1-9]\\d{0,11})(\\.\\d{1,6})?$")) return (value as String).toBigDecimal().stripTrailingZeros().toPlainString()
+        return value
+    }
+    internal fun equal(a: Any?, b: Any?): Boolean = when {
+        a is JSONObject && b is JSONObject -> a.keys().asSequence().toSet() == b.keys().asSequence().toSet() && a.keys().asSequence().all { equal(a.opt(it), b.opt(it)) }
+        a is JSONArray && b is JSONArray -> a.length() == b.length() && (0 until a.length()).all { equal(a.opt(it), b.opt(it)) }
+        a is Number && b is Number -> a.toDouble() == b.toDouble()
+        else -> a == b
+    }
+    private fun valid(value: Any?, schema: JSONObject, root: JSONObject, depth: Int): Boolean {
+        if (depth > 100) return false
+        val value = try { IndianaCustomerResponseSemantics.rules(value, schema) } catch (_: Exception) { return false }
+        if (schema.has("\$ref")) { val ref = schema.getString("\$ref");if (!ref.startsWith("#/")) return false;var target: Any = root;for (part in ref.substring(2).split('/')) target = (target as? JSONObject)?.opt(part.replace("~1", "/").replace("~0", "~")) ?: return false;return target is JSONObject && valid(value, target, root, depth + 1) }
+        for (name in listOf("allOf", "anyOf", "oneOf")) schema.optJSONArray(name)?.let { choices -> val matches = (0 until choices.length()).count { valid(value, choices.getJSONObject(it), root, depth + 1) };if (name == "allOf" && matches != choices.length() || name == "anyOf" && matches == 0 || name == "oneOf" && matches != 1) return false }
+        if (schema.has("const") && !equal(value, schema.opt("const"))) return false
+        schema.optJSONArray("enum")?.let { choices -> if ((0 until choices.length()).none { equal(value, choices.opt(it)) }) return false }
+        when (schema.optString("type")) {
+            "null" -> if (value != null && value != JSONObject.NULL) return false
+            "boolean" -> if (value !is Boolean) return false
+            "string" -> if (value !is String) return false
+            "number", "integer" -> if (value !is Number || !value.toDouble().isFinite() || schema.getString("type") == "integer" && value.toDouble() != kotlin.math.floor(value.toDouble())) return false
+            "object" -> if (value !is JSONObject) return false
+            "array" -> if (value !is JSONArray) return false
+        }
+        if (value is String) {
+            if (schema.has("minLength") && value.length < schema.getInt("minLength") || schema.has("maxLength") && value.length > schema.getInt("maxLength")) return false
+            if (schema.has("pattern") && !Regex(schema.getString("pattern")).containsMatchIn(value)) return false
+            try { when (schema.optString("format")) { "uuid" -> UUID.fromString(value);"date-time" -> utcMillis(value);"uri" -> if (URI(value).scheme == null) return false } } catch (_: Exception) { return false }
+        }
+        if (value is Number) {
+            val n = value.toDouble()
+            if (schema.has("minimum") && n < schema.getDouble("minimum") || schema.has("maximum") && n > schema.getDouble("maximum") || schema.has("exclusiveMinimum") && n <= schema.getDouble("exclusiveMinimum") || schema.has("exclusiveMaximum") && n >= schema.getDouble("exclusiveMaximum")) return false
+        }
+        if (value is JSONArray) {
+            if (schema.has("minItems") && value.length() < schema.getInt("minItems") || schema.has("maxItems") && value.length() > schema.getInt("maxItems")) return false
+            if (schema.optBoolean("uniqueItems")) for (index in 0 until value.length()) if ((0 until index).any { equal(value.opt(it), value.opt(index)) }) return false
+            schema.optJSONObject("items")?.let { items -> if ((0 until value.length()).any { !valid(value.opt(it), items, root, depth + 1) }) return false }
+            schema.optJSONArray("items")?.let { tuple -> for (index in 0 until value.length()) if (index < tuple.length() && !valid(value.opt(index), tuple.getJSONObject(index), root, depth + 1)) return false;if (schema.opt("additionalItems") == false && value.length() > tuple.length()) return false }
+        }
+        if (value is JSONObject) {
+            if (schema.has("maxProperties") && value.length() > schema.getInt("maxProperties") || schema.has("minProperties") && value.length() < schema.getInt("minProperties")) return false
+            val properties = schema.optJSONObject("properties") ?: JSONObject()
+            schema.optJSONArray("required")?.let { required -> if ((0 until required.length()).any { !value.has(required.getString(it)) }) return false }
+            for (key in value.keys()) {
+                if (properties.has(key)) { if (!valid(value.opt(key), properties.getJSONObject(key), root, depth + 1)) return false }
+                else if (schema.opt("additionalProperties") == false) return false
+                else schema.optJSONObject("additionalProperties")?.let { if (!valid(value.opt(key), it, root, depth + 1)) return false }
+                schema.optJSONObject("propertyNames")?.let { if (!valid(key, it, root, depth + 1)) return false }
+            }
+        }
+        return true
+    }
+}