fix(core): plugin storage where-filters fail on Postgres with boolean = integer (#920) (#1898)

* fix(core): plugin storage where-filters fail on Postgres (#920)

query() and count() wrapped the JSON-extraction predicate in
`(...) = 1` to fit eb(lhs, "=", rhs). SQLite coerces booleans to
integers so it worked there, but Postgres has a strict boolean type
and rejected every filtered call with "operator does not exist:
boolean = integer". Use the predicate directly as a boolean WHERE
expression instead; dialect-parity regression tests included.

* fix: cast text JSON column to jsonb for Postgres extraction

CI's PG job surfaced the layer below the `= 1` wrapper:
_plugin_storage.data is a text column, so `data->>'field'` fails with
"operator does not exist: text ->> unknown". Cast via `(data)::jsonb`
in jsonExtractExpr — shared by queries and expression indexes, so the
planner keeps matching them. Also switch test .sort() to .toSorted()
for the type-aware lint.

* fix: coerce count() to a number for the pg driver

pg returns COUNT(*) (bigint) as a string; Number() it like every
other repository count in the codebase.

* chore: retrigger CI (labeler job hit a GitHub API 5xx)

Author: swissky

.changeset/fix-plugin-storage-postgres-filters.md

@@ -0,0 +1,5 @@
+---
+"emdash": patch
+---
+
+Fixes plugin storage `query()` and `count()` failing on PostgreSQL with "operator does not exist: boolean = integer" whenever a `where` filter was supplied.

packages/core/src/database/dialect-helpers.ts

@@ -215,17 +215,23 @@ export function binaryType(db: Kysely<any>): ColumnDataType {
 }
 
 /**
- * SQL expression for extracting a field from a JSON/JSONB column.
+ * SQL expression for extracting a field from a JSON column stored as text.
  *
  * sqlite:   json_extract(column, '$.path')
- * postgres: column->>'path'
+ * postgres: (column)::jsonb->>'path'
+ *
+ * The Postgres cast is required because JSON columns (e.g.
+ * `_plugin_storage.data`) are `text`, and `text ->> unknown` is not an
+ * operator. The cast is immutable, so the same expression works in
+ * expression indexes — queries and indexes must build it through this
+ * helper so the planner can match them.
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any Kysely instance
 export function jsonExtractExpr(db: Kysely<any>, column: string, path: string): string {
 	validateIdentifier(column, "JSON column name");
 	validateJsonFieldName(path, "JSON path");
 	if (isPostgres(db)) {
-		return `${column}->>'${path}'`;
+		return `(${column})::jsonb->>'${path}'`;
 	}
 	return `json_extract(${column}, '$.${path}')`;
 }

packages/core/src/database/repositories/plugin-storage.ts

@@ -7,7 +7,7 @@
  * @see PLUGIN-SYSTEM.md § Plugin Storage > Full API Reference
  */
 
-import type { Kysely } from "kysely";
+import type { Kysely, RawBuilder } from "kysely";
 import { sql } from "kysely";
 
 import {
@@ -27,6 +27,26 @@ import { withTransaction } from "../transaction.js";
 import type { Database } from "../types.js";
 import { encodeCursor, decodeCursor } from "./types.js";
 
+/**
+ * Interleave a `?`-placeholder SQL string with its params into a single
+ * boolean raw expression. Used as a WHERE predicate directly — wrapping it
+ * in `(...) = 1` breaks on Postgres, which has a strict boolean type (#920).
+ */
+function rawWhereExpr(sqlText: string, params: unknown[]): RawBuilder<boolean> {
+	const parts: ReturnType<typeof sql>[] = [];
+	let paramIndex = 0;
+	const sqlParts = sqlText.split("?");
+	for (let i = 0; i < sqlParts.length; i++) {
+		if (i > 0) {
+			parts.push(sql`${params[paramIndex++]}`);
+		}
+		if (sqlParts[i]) {
+			parts.push(sql.raw(sqlParts[i]));
+		}
+	}
+	return sql<boolean>`(${sql.join(parts, sql.raw(""))})`;
+}
+
 /**
  * Plugin Storage Repository
  *
@@ -211,19 +231,7 @@ export class PluginStorageRepository<T = unknown> implements StorageCollection<T
 		// Add JSON extraction WHERE conditions
 		const whereResult = buildWhereClause(this.db, where);
 		if (whereResult.sql) {
-			// Use sql template to add the raw WHERE conditions with params
-			const whereSqlParts: ReturnType<typeof sql>[] = [];
-			let paramIndex = 0;
-			const sqlParts = whereResult.sql.split("?");
-			for (let i = 0; i < sqlParts.length; i++) {
-				if (i > 0) {
-					whereSqlParts.push(sql`${whereResult.params[paramIndex++]}`);
-				}
-				if (sqlParts[i]) {
-					whereSqlParts.push(sql.raw(sqlParts[i]));
-				}
-			}
-			query = query.where(({ eb }) => eb(sql.join(whereSqlParts, sql.raw("")), "=", sql.raw("1")));
+			query = query.where(rawWhereExpr(whereResult.sql, whereResult.params));
 		}
 
 		// Handle cursor-based pagination — throws on invalid cursor.
@@ -289,26 +297,13 @@ export class PluginStorageRepository<T = unknown> implements StorageCollection<T
 		if (where && Object.keys(where).length > 0) {
 			const whereResult = buildWhereClause(this.db, where);
 			if (whereResult.sql) {
-				// Use sql template to add the raw WHERE conditions with params
-				const whereSqlParts: ReturnType<typeof sql>[] = [];
-				let paramIndex = 0;
-				const sqlParts = whereResult.sql.split("?");
-				for (let i = 0; i < sqlParts.length; i++) {
-					if (i > 0) {
-						whereSqlParts.push(sql`${whereResult.params[paramIndex++]}`);
-					}
-					if (sqlParts[i]) {
-						whereSqlParts.push(sql.raw(sqlParts[i]));
-					}
-				}
-				query = query.where(({ eb }) =>
-					eb(sql.join(whereSqlParts, sql.raw("")), "=", sql.raw("1")),
-				);
+				query = query.where(rawWhereExpr(whereResult.sql, whereResult.params));
 			}
 		}
 
 		const result = await query.executeTakeFirst();
-		return result?.count ?? 0;
+		// Number() because the pg driver returns COUNT(*) (bigint) as a string.
+		return Number(result?.count ?? 0);
 	}
 }
 

packages/core/tests/integration/plugins/storage-dialect.test.ts

@@ -0,0 +1,89 @@
+/**
+ * Plugin storage query/count with `where` filters, on both dialects (#920).
+ *
+ * The filtered paths wrapped the JSON-extraction predicate in `(...) = 1`.
+ * SQLite coerces booleans to integers so that worked, but Postgres has a
+ * strict boolean type and rejected every filtered list()/count() with
+ * "operator does not exist: boolean = integer". This runs the filtered
+ * paths end-to-end on both dialects to guard the predicate shape.
+ */
+
+import type { Kysely } from "kysely";
+import { afterEach, beforeEach, expect, it } from "vitest";
+
+import { PluginStorageRepository } from "../../../src/database/repositories/plugin-storage.js";
+import type { Database } from "../../../src/database/types.js";
+import {
+	type DialectTestContext,
+	describeEachDialect,
+	setupForDialect,
+	teardownForDialect,
+} from "../../utils/test-db.js";
+
+interface ProviderDoc {
+	provider: string;
+	active: boolean;
+	priority: number;
+}
+
+describeEachDialect("plugin storage filtered query/count (#920)", (dialect) => {
+	let ctx: DialectTestContext;
+
+	beforeEach(async () => {
+		ctx = await setupForDialect(dialect);
+	});
+	afterEach(async () => {
+		await teardownForDialect(ctx);
+	});
+
+	function makeRepo() {
+		// eslint-disable-next-line typescript/no-unsafe-type-assertion -- dialect context db vs Database type
+		const db = ctx.db as unknown as Kysely<Database>;
+		return new PluginStorageRepository<ProviderDoc>(db, "emdash-smtp", "providers", [
+			"provider",
+			"priority",
+		]);
+	}
+
+	async function seed(repo: PluginStorageRepository<ProviderDoc>) {
+		await repo.put("p1", { provider: "resend", active: true, priority: 1 });
+		await repo.put("p2", { provider: "sendgrid", active: false, priority: 2 });
+		await repo.put("p3", { provider: "resend", active: false, priority: 3 });
+	}
+
+	it("query() with a where filter returns matching documents", async () => {
+		const repo = makeRepo();
+		await seed(repo);
+
+		const result = await repo.query({ where: { provider: "resend" } });
+		expect(result.items.map((i) => i.id).toSorted()).toEqual(["p1", "p3"]);
+	});
+
+	it("query() combines where with orderBy", async () => {
+		const repo = makeRepo();
+		await seed(repo);
+
+		const result = await repo.query({
+			where: { provider: "resend" },
+			orderBy: { priority: "desc" },
+		});
+		expect(result.items.map((i) => i.id)).toEqual(["p3", "p1"]);
+	});
+
+	it("query() supports operator objects in where", async () => {
+		const repo = makeRepo();
+		await seed(repo);
+
+		const result = await repo.query({ where: { priority: { gt: 1 } } });
+		expect(result.items.map((i) => i.id).toSorted()).toEqual(["p2", "p3"]);
+	});
+
+	it("count() with a where filter counts matching documents", async () => {
+		const repo = makeRepo();
+		await seed(repo);
+
+		expect(await repo.count({ provider: "resend" })).toBe(2);
+		expect(await repo.count({ provider: "sendgrid" })).toBe(1);
+		expect(await repo.count({ provider: "nope" })).toBe(0);
+	});
+});