@voltro/plugin-search 0.83.1 → 0.85.0

package/dist/{rpc-CpryHBcM.js → rpc-CggQ77CG.js}

@@ -3,25 +3,36 @@ import { defineAction as t } from "@voltro/protocol";
 //#region src/errors.ts
 var n = class extends e.TaggedError()("SearchIndexNotFound", { index: e.String }) {}, r = class extends e.TaggedError()("SearchFieldRejected", {
 	field: e.String,
-	where: e.Literal("filter", "facet", "highlight"),
-	reason: e.Literal("not-an-identifier", "not-queryable")
-}) {}, i = "@voltro/plugin-search", a = e.Union(e.String, e.Number, e.Boolean), o = e.Struct({
+	where: e.Literals([
+		"filter",
+		"facet",
+		"highlight"
+	]),
+	reason: e.Literals(["not-an-identifier", "not-queryable"])
+}) {}, i = "@voltro/plugin-search", a = e.Union([
+	e.String,
+	e.Number,
+	e.Boolean
+]), o = e.Struct({
 	field: e.String,
-	op: e.Literal("eq", "neq", "gt", "gte", "lt", "lte", "in", "nin"),
-	value: e.Union(a, e.Array(a))
+	op: e.Literals([
+		"eq",
+		"neq",
+		"gt",
+		"gte",
+		"lt",
+		"lte",
+		"in",
+		"nin"
+	]),
+	value: e.Union([a, e.Array(a)])
 }), s = e.Struct({
 	fields: e.optional(e.Array(e.String)),
 	preTag: e.optional(e.String),
 	postTag: e.optional(e.String)
 }), c = e.Struct({
-	doc: e.Record({
-		key: e.String,
-		value: e.Unknown
-	}),
-	highlights: e.optional(e.Record({
-		key: e.String,
-		value: e.String
-	}))
+	doc: e.Record(e.String, e.Unknown),
+	highlights: e.optional(e.Record(e.String, e.String))
 }), l = t({
 	name: "search.query",
 	openAccess: "tenant scoping, index registration and field validation are enforced server-side per call; a non-tenant index exposes only what the app's map(row) deliberately indexed",
@@ -33,23 +44,14 @@ var n = class extends e.TaggedError()("SearchIndexNotFound", { index: e.String }
 		filters: e.optional(e.Array(o)),
 		facets: e.optional(e.Array(e.String)),
 		highlight: e.optional(s),
-		fuzziness: e.optional(e.Union(e.Number, e.Literal("auto"))),
-		engineParams: e.optional(e.Record({
-			key: e.String,
-			value: e.Unknown
-		}))
+		fuzziness: e.optional(e.Union([e.Number, e.Literal("auto")])),
+		engineParams: e.optional(e.Record(e.String, e.Unknown))
 	}),
 	output: e.Struct({
 		hits: e.Array(c),
-		facets: e.Record({
-			key: e.String,
-			value: e.Record({
-				key: e.String,
-				value: e.Number
-			})
-		})
+		facets: e.Record(e.String, e.Record(e.String, e.Number))
 	}),
-	error: e.Union(n, r)
+	error: e.Union([n, r])
 }), u = [{
 	tag: "search.query",
 	kind: "action",

package/dist/rpc.d.ts

@@ -1,6 +1,7 @@
 import { ActionProcedureDescriptor } from '@voltro/protocol';
 import { PluginRpcClientDescriptor } from '@voltro/protocol';
 import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
 
 /**
  * The plugin's canonical package name — the key an app's `alias` is recorded
@@ -18,43 +19,43 @@ export declare const queryDescriptor: ActionProcedureDescriptor<"search.query",
     /** One of the indexes the app declared. An unregistered name is refused
      *  (`SearchIndexNotFound`) — it has no spec, so it has no tenant field to
      *  scope by, and answering it would query an unscoped collection. */
-    index: typeof Schema.String;
-    q: typeof Schema.String;
-    limit: Schema.optional<typeof Schema.Number>;
-    offset: Schema.optional<typeof Schema.Number>;
+    readonly index: Schema.String;
+    readonly q: Schema.String;
+    readonly limit: Schema.optional<Schema.Number>;
+    readonly offset: Schema.optional<Schema.Number>;
     /** Clauses ANDed together — equality, range, negation, set membership. */
-    filters: Schema.optional<Schema.Array$<Schema.Struct<{
+    readonly filters: Schema.optional<Schema.$Array<Schema.Struct<{
         /** A doc field path. Validated server-side against the index's declared
          *  `queryableFields` (or a plain-identifier pattern) before it is spliced
          *  into the engine's filter DSL — a mismatch is a typed
          *  `SearchFieldRejected`, not a query. */
-        field: typeof Schema.String;
-        op: Schema.Literal<["eq", "neq", "gt", "gte", "lt", "lte", "in", "nin"]>;
-        value: Schema.Union<[Schema.Union<[typeof Schema.String, typeof Schema.Number, typeof Schema.Boolean]>, Schema.Array$<Schema.Union<[typeof Schema.String, typeof Schema.Number, typeof Schema.Boolean]>>]>;
+        readonly field: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq", "gt", "gte", "lt", "lte", "in", "nin"]>;
+        readonly value: Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>>]>;
     }>>>;
     /** Facet-count fields. */
-    facets: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    readonly facets: Schema.optional<Schema.$Array<Schema.String>>;
     /** Matched-term highlighting. */
-    highlight: Schema.optional<Schema.Struct<{
-        fields: Schema.optional<Schema.Array$<typeof Schema.String>>;
-        preTag: Schema.optional<typeof Schema.String>;
-        postTag: Schema.optional<typeof Schema.String>;
+    readonly highlight: Schema.optional<Schema.Struct<{
+        readonly fields: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly preTag: Schema.optional<Schema.String>;
+        readonly postTag: Schema.optional<Schema.String>;
     }>>;
     /** Typo tolerance — a max edit distance (0 = exact) or `'auto'`. */
-    fuzziness: Schema.optional<Schema.Union<[typeof Schema.Number, Schema.Literal<["auto"]>]>>;
+    readonly fuzziness: Schema.optional<Schema.Union<readonly [Schema.Number, Schema.Literal<"auto">]>>;
     /** Escape hatch — the engine's presentation-only params (paging, ordering,
      *  typo tolerance, highlight shaping). Anything that could select a
      *  different document set is dropped server-side and logged; express a
      *  filter as a `filters[]` clause instead. */
-    engineParams: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    readonly engineParams: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
 }>, Schema.Struct<{
-    hits: Schema.Array$<Schema.Struct<{
-        doc: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
-        highlights: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+    readonly hits: Schema.$Array<Schema.Struct<{
+        readonly doc: Schema.$Record<Schema.String, Schema.Unknown>;
+        readonly highlights: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
     }>>;
     /** field → (value → count) for the requested facets. */
-    facets: Schema.Record$<typeof Schema.String, Schema.Record$<typeof Schema.String, typeof Schema.Number>>;
-}>, Schema.Union<[typeof SearchIndexNotFound, typeof SearchFieldRejected]>>;
+    readonly facets: Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Number>>;
+}>, Schema.Union<readonly [typeof SearchIndexNotFound, typeof SearchFieldRejected]>>;
 
 /**
  * A field name the caller supplied — in `filters[].field`, `facets[]` or
@@ -72,22 +73,20 @@ export declare const queryDescriptor: ActionProcedureDescriptor<"search.query",
 declare class SearchFieldRejected extends SearchFieldRejected_base {
 }
 
-declare const SearchFieldRejected_base: Schema.TaggedErrorClass<SearchFieldRejected, "SearchFieldRejected", {
-    readonly _tag: Schema.tag<"SearchFieldRejected">;
-} & {
-    field: typeof Schema.String;
-    where: Schema.Literal<["filter", "facet", "highlight"]>;
-    reason: Schema.Literal<["not-an-identifier", "not-queryable"]>;
-}>;
+declare const SearchFieldRejected_base: Schema.Class<SearchFieldRejected, Schema.TaggedStruct<"SearchFieldRejected", {
+    readonly field: Schema.String;
+    readonly where: Schema.Literals<readonly ["filter", "facet", "highlight"]>;
+    readonly reason: Schema.Literals<readonly ["not-an-identifier", "not-queryable"]>;
+}>, YieldableError>;
 
 export declare const SearchFilterSchema: Schema.Struct<{
     /** A doc field path. Validated server-side against the index's declared
      *  `queryableFields` (or a plain-identifier pattern) before it is spliced
      *  into the engine's filter DSL — a mismatch is a typed
      *  `SearchFieldRejected`, not a query. */
-    field: typeof Schema.String;
-    op: Schema.Literal<["eq", "neq", "gt", "gte", "lt", "lte", "in", "nin"]>;
-    value: Schema.Union<[Schema.Union<[typeof Schema.String, typeof Schema.Number, typeof Schema.Boolean]>, Schema.Array$<Schema.Union<[typeof Schema.String, typeof Schema.Number, typeof Schema.Boolean]>>]>;
+    readonly field: Schema.String;
+    readonly op: Schema.Literals<readonly ["eq", "neq", "gt", "gte", "lt", "lte", "in", "nin"]>;
+    readonly value: Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>>]>;
 }>;
 
 /**
@@ -102,11 +101,9 @@ export declare const SearchFilterSchema: Schema.Struct<{
 declare class SearchIndexNotFound extends SearchIndexNotFound_base {
 }
 
-declare const SearchIndexNotFound_base: Schema.TaggedErrorClass<SearchIndexNotFound, "SearchIndexNotFound", {
-    readonly _tag: Schema.tag<"SearchIndexNotFound">;
-} & {
-    index: typeof Schema.String;
-}>;
+declare const SearchIndexNotFound_base: Schema.Class<SearchIndexNotFound, Schema.TaggedStruct<"SearchIndexNotFound", {
+    readonly index: Schema.String;
+}>, YieldableError>;
 
 /** Declared for the codegen (`VoltroPlugin.rpcClientDescriptors`) so each tag is
  *  emitted into the generated client group. Kept in lockstep with the exports. */

package/dist/rpc.js

@@ -1,2 +1,2 @@
-import { i as e, n as t, r as n, t as r } from "./rpc-CpryHBcM.js";
+import { i as e, n as t, r as n, t as r } from "./rpc-CggQ77CG.js";
 export { r as BASE_NAME, t as SearchFilterSchema, n as queryDescriptor, e as searchRpcClientImports };

package/dist/web.js

@@ -1,4 +1,4 @@
-import { t as e } from "./rpc-CpryHBcM.js";
+import { t as e } from "./rpc-CggQ77CG.js";
 import { pluginTag as t } from "@voltro/protocol";
 import { useAction as n } from "@voltro/client";
 //#region src/web.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/plugin-search",
-  "version": "0.83.1",
+  "version": "0.85.0",
   "description": "Keep an external search index (Typesense / Meilisearch / Algolia) in sync with framework tables via the post-commit ChangeEvent tap, then query it — tenant-scoped, with a backfill path and a useSearch() hook.",
   "keywords": [
     "voltro",
@@ -43,9 +43,9 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@voltro/client": "0.83.1",
-    "@voltro/database": "0.83.1",
-    "@voltro/protocol": "0.83.1"
+    "@voltro/client": "0.85.0",
+    "@voltro/database": "0.85.0",
+    "@voltro/protocol": "0.85.0"
   },
   "optionalDependencies": {
     "algoliasearch": "^5.59.0",
@@ -53,7 +53,7 @@
     "typesense": "^3.0.6"
   },
   "peerDependencies": {
-    "effect": "^3.22.2"
+    "effect": "4.0.1"
   },
   "publishConfig": {
     "access": "public"