@mastra/clickhouse 1.15.2 → 1.16.0-alpha.1

package/dist/index.js

@@ -3519,7 +3519,7 @@ function unionDistinctFromSignals(kind, key1Expr, valueExpr, extraJoin = "", ext
 }
 const DISCOVERY_VALUES_MV_DDL = `
 CREATE MATERIALIZED VIEW IF NOT EXISTS ${MV_DISCOVERY_VALUES}
-REFRESH EVERY 1 MINUTE
+REFRESH EVERY 1 MINUTE APPEND
 TO ${TABLE_DISCOVERY_VALUES}
 AS
 SELECT DISTINCT kind, key1, value FROM (
@@ -3544,7 +3544,7 @@ SELECT DISTINCT kind, key1, value FROM (
 `;
 const DISCOVERY_PAIRS_MV_DDL = `
 CREATE MATERIALIZED VIEW IF NOT EXISTS ${MV_DISCOVERY_PAIRS}
-REFRESH EVERY 5 MINUTE
+REFRESH EVERY 5 MINUTE APPEND
 TO ${TABLE_DISCOVERY_PAIRS}
 AS
 SELECT DISTINCT kind, key1, key2, value FROM (
@@ -4380,6 +4380,64 @@ function addStringMapFilters(column, values, keyPrefix, valuePrefix, out) {
 	}
 }
 /**
+* Adds conditions asserting the JSON value at `pathRefs` inside `src` deep-equals `value`.
+*
+* Scalars (string/number/boolean/null) use type-checked typed extraction. Objects and
+* arrays are decomposed recursively into per-leaf comparisons plus length checks, so
+* nested values match structurally regardless of key serialization order while still
+* requiring complete (exact, not partial) equality — mirroring the in-memory
+* deep-equality semantics.
+*/
+function addJsonValueConditions(src, pathRefs, value, valuePrefix, nextId, out) {
+	const path = pathRefs.join(", ");
+	if (value === null || value === void 0) out.conditions.push(`JSONHas(${src}, ${path}) AND JSONType(${src}, ${path}) = 'Null'`);
+	else if (typeof value === "string") {
+		const p = `${valuePrefix}_${nextId()}`;
+		out.conditions.push(`JSONType(${src}, ${path}) = 'String' AND JSONExtractString(${src}, ${path}) = {${p}:String}`);
+		out.params[p] = value;
+	} else if (typeof value === "number") {
+		const p = `${valuePrefix}_${nextId()}`;
+		out.conditions.push(`JSONType(${src}, ${path}) IN ('Int64', 'UInt64', 'Double') AND JSONExtractFloat(${src}, ${path}) = {${p}:Float64}`);
+		out.params[p] = value;
+	} else if (typeof value === "boolean") {
+		const p = `${valuePrefix}_${nextId()}`;
+		out.conditions.push(`JSONType(${src}, ${path}) = 'Bool' AND JSONExtractBool(${src}, ${path}) = {${p}:UInt8}`);
+		out.params[p] = value ? 1 : 0;
+	} else if (Array.isArray(value)) {
+		out.conditions.push(`JSONType(${src}, ${path}) = 'Array' AND JSONLength(${src}, ${path}) = ${value.length}`);
+		value.forEach((item, idx) => {
+			addJsonValueConditions(src, [...pathRefs, String(idx + 1)], item, valuePrefix, nextId, out);
+		});
+	} else {
+		const entries = Object.entries(value).filter(([, v]) => v !== void 0);
+		out.conditions.push(`JSONType(${src}, ${path}) = 'Object' AND JSONLength(${src}, ${path}) = ${entries.length}`);
+		for (const [subKey, subValue] of entries) {
+			const p = `${valuePrefix}_k_${nextId()}`;
+			out.params[p] = subKey;
+			addJsonValueConditions(src, [...pathRefs, `{${p}:String}`], subValue, valuePrefix, nextId, out);
+		}
+	}
+}
+/**
+* Adds key/value filters against a JSON-encoded string column (e.g. scores.metadata).
+* Emits predicates per requested key with exact-value deep equality for any JSON value,
+* mirroring the in-memory deep-equality semantics (structural, key-order independent).
+*/
+function addJsonStringFilters(column, values, keyPrefix, valuePrefix, out) {
+	if (values == null || typeof values !== "object") return;
+	let id = 0;
+	const nextId = () => id++;
+	let i = 0;
+	for (const [rawKey, rawValue] of Object.entries(values)) {
+		if (rawValue === void 0) continue;
+		const keyParam = `${keyPrefix}_${i}`;
+		const src = `ifNull(${column}, '{}')`;
+		out.params[keyParam] = rawKey;
+		addJsonValueConditions(src, [`{${keyParam}:String}`], rawValue, valuePrefix, nextId, out);
+		i++;
+	}
+}
+/**
 * Adds shared context filter conditions (commonFilterFields) to the output.
 * Used by logs, metrics, scores, and feedback filter builders.
 */
@@ -4492,6 +4550,7 @@ function buildScoresFilterConditions(filters, tableAlias) {
 	addEq(col("scoreSource"), filters.scoreSource, "scoreSource", "String", out);
 	if (typeof filters.scorerId === "string") addEq(col("scorerId"), filters.scorerId, "scorerId", "String", out);
 	else if (Array.isArray(filters.scorerId)) addIn(col("scorerId"), filters.scorerId, "scorerIds", out);
+	addJsonStringFilters(col("metadata"), filters.metadata, "score_meta_k", "score_meta_v", out);
 	return out;
 }
 function buildFeedbackFilterConditions(filters, tableAlias) {
@@ -7023,6 +7082,12 @@ async function filterAppliedRetention(client, entries) {
 * Init's subsequent `CREATE TABLE IF NOT EXISTS` and discovery MV bootstrap
 * recreate both with the current definitions.
 *
+* Separately, a refreshable MV whose stored definition lacks the `APPEND`
+* modifier (created by older releases) is dropped — keeping its target
+* table — so the MV bootstrap recreates it with the current APPEND
+* definition. Non-APPEND refreshes swap the target table atomically, which
+* fails when the target is Replicated inside a non-Replicated database.
+*
 * Silently returns if `system.tables` can't be queried — the rest of init
 * will still run and leave any existing tables untouched.
 */
@@ -7037,13 +7102,20 @@ async function assertExistingTablesCompatibleWithReplication(client, replication
 }
 async function reconcileDiscoveryTables(client, replication) {
 	let engines;
+	let mvCreateQueries;
 	try {
 		const rows = await (await client.query({
-			query: `SELECT name, engine FROM system.tables WHERE database = currentDatabase() AND name IN ({tables:Array(String)})`,
-			query_params: { tables: [TABLE_DISCOVERY_VALUES, TABLE_DISCOVERY_PAIRS] },
+			query: `SELECT name, engine, create_table_query FROM system.tables WHERE database = currentDatabase() AND name IN ({tables:Array(String)})`,
+			query_params: { tables: [
+				TABLE_DISCOVERY_VALUES,
+				TABLE_DISCOVERY_PAIRS,
+				MV_DISCOVERY_VALUES,
+				MV_DISCOVERY_PAIRS
+			] },
 			format: "JSONEachRow"
 		})).json();
 		engines = new Map(rows.map((r) => [r.name, r.engine]));
+		mvCreateQueries = new Map(rows.map((r) => [r.name, r.create_table_query]));
 	} catch {
 		return;
 	}
@@ -7056,9 +7128,13 @@ async function reconcileDiscoveryTables(client, replication) {
 	}];
 	for (const { table, mv } of targets) {
 		const engine = engines.get(table);
-		if (!engine || isReplacingMergeTreeEngine(engine)) continue;
-		await client.command({ query: addOnClusterToDDL(`DROP VIEW IF EXISTS ${mv}`, replication) });
-		await client.command({ query: addOnClusterToDDL(`DROP TABLE IF EXISTS ${table}`, replication) });
+		if (engine && !isReplacingMergeTreeEngine(engine)) {
+			await client.command({ query: addOnClusterToDDL(`DROP VIEW IF EXISTS ${mv}`, replication) });
+			await client.command({ query: addOnClusterToDDL(`DROP TABLE IF EXISTS ${table}`, replication) });
+			continue;
+		}
+		const createQuery = mvCreateQueries.get(mv);
+		if (createQuery && /REFRESH EVERY/i.test(createQuery) && !/\bAPPEND\b/i.test(createQuery)) await client.command({ query: addOnClusterToDDL(`DROP VIEW IF EXISTS ${mv}`, replication) });
 	}
 }
 async function queryNamesByTable(client, query, tables) {