@rebasepro/server-postgres 0.21.2-canary.g1ea48be → 0.22.0

package/dist/schema/doctor-cli.js

@@ -4,8 +4,8 @@ __createRequire(import.meta.url);
 import { i as diagnoseDbError } from "../cli-errors-Dka89exj.js";
 import { o as validatePolicyPgRoles, s as warnOnAnonymousGrants } from "../rls-enforcement-C6Xk0lA6.js";
 import { t as chalk } from "../source-Br7L7GOI.js";
-import { n as loadCollections, r as runDoctor } from "../doctor-Gzzd8wTq.js";
-import { n as formatPolicyDrift, r as hasDrift, t as checkPolicyDrift } from "../policy-drift-B0GDRh7_.js";
+import { n as loadCollections, r as runDoctor } from "../doctor-CU9IogdL.js";
+import { n as formatPolicyDrift, r as hasDrift, t as checkPolicyDrift } from "../policy-drift-xJfy9xG7.js";
 import path from "path";
 //#region src/schema/doctor-policy-checks.ts
 /**

package/dist/schema/generate-drizzle-schema.js

@@ -1,6 +1,6 @@
 import { createRequire as __createRequire } from "module";
 __createRequire(import.meta.url);
-import { t as main } from "../generate-drizzle-schema-D2MDdJt-.js";
+import { t as main } from "../generate-drizzle-schema-B537GIvz.js";
 //#region src/schema/bin/generate-drizzle-schema.ts
 /**
 * The built entry point for `generate-drizzle-schema`.

package/dist/schema/generate-postgres-ddl.js

@@ -1,6 +1,6 @@
 import { createRequire as __createRequire } from "module";
 __createRequire(import.meta.url);
-import { a as generatePostgresVectorDdl, i as generatePostgresTriggersDdl, n as generatePostgresPoliciesDdl, r as generatePostgresSearchDdl, t as generatePostgresDdl } from "../generate-postgres-ddl-logic-CR2xcS7e.js";
+import { a as generatePostgresVectorDdl, i as generatePostgresTriggersDdl, n as generatePostgresPoliciesDdl, r as generatePostgresSearchDdl, t as generatePostgresDdl } from "../generate-postgres-ddl-logic-D7imhYV8.js";
 import { n as outError, t as out } from "../cli-output-CNdMql-L.js";
 import { loadCollectionsFromDirectory } from "@rebasepro/server";
 import { declaredDatabaseExtensions } from "@rebasepro/types";

package/dist/schema/search-column.d.ts

@@ -43,7 +43,7 @@
  * `auditor` and `auditoria` to `auditori` — *different lexemes* — so a query
  * typed without accents misses every row that carries them.
  */
-import { CollectionConfig, SearchConfig, SearchWeight } from "@rebasepro/types";
+import { CollectionConfig, SearchConfig, SearchMode, SearchWeight } from "@rebasepro/types";
 /**
  * Names of the helper functions. Frozen: they are recorded in the stored
  * generation expression of every search column ever created, so renaming one
@@ -67,6 +67,20 @@ export interface ResolvedSearchField {
     sql: string;
     /** The plain-text term this field contributes, for the fuzzy column. */
     textSql: string;
+    /**
+     * The same text with accents folded **unconditionally**, for the substring
+     * half of {@link SearchMode} `"hybrid"`.
+     *
+     * Separate from {@link textSql} rather than replacing it, and that
+     * separation is the whole migration story for `mode`. `textSql` feeds the
+     * *stored* generated columns, so changing it changes their generation
+     * expression, which changes the fingerprint, which makes the next boot
+     * refuse (see `searchStampGuards`). This one is only ever interpolated into
+     * a WHERE clause, so a collection can switch to `"hybrid"` — and gain
+     * accent folding on the substring half — without rebuilding a column or
+     * taking an ACCESS EXCLUSIVE lock.
+     */
+    foldedTextSql: string;
 }
 /** Everything the generators need to render one collection's search column. */
 export interface SearchColumnSpec {
@@ -76,6 +90,12 @@ export interface SearchColumnSpec {
     column: string;
     language: string;
     unaccent: boolean;
+    /**
+     * How the query side matches. Deliberately absent from
+     * {@link SearchColumnSpec.expression} and from every fingerprint: it
+     * describes the WHERE clause, not the column.
+     */
+    mode: SearchMode;
     fields: ResolvedSearchField[];
     /** Body of `GENERATED ALWAYS AS ( … ) STORED` for the tsvector column. */
     expression: string;

package/dist/services/FetchService.d.ts

@@ -7,6 +7,7 @@ import { DrizzleClient } from "../interfaces.js";
 import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry.js";
 import { type NestedPathHop } from "./nested-path.js";
 import { type WithDeleted } from "./soft-delete.js";
+import { type ReadCallContextProvider } from "./read-scope.js";
 /**
  * Service for handling all row read operations.
  * Handles fetching, searching, counting, and filtering rows.
@@ -39,8 +40,22 @@ export declare function numericAggregateAliases(aggregates: {
 export declare class FetchService {
     private db;
     private registry;
+    /**
+     * How this service's reads reach the identity their `beforeQuery` hooks
+     * run as. Passed by the driver that constructed it; absent only in a
+     * test, where a collection declaring the hook is refused rather than
+     * read unnarrowed. See `read-scope.ts`.
+     */
+    private callContext?;
     private relationService;
-    constructor(db: DrizzleClient, registry: PostgresCollectionRegistry);
+    constructor(db: DrizzleClient, registry: PostgresCollectionRegistry, 
+    /**
+     * How this service's reads reach the identity their `beforeQuery` hooks
+     * run as. Passed by the driver that constructed it; absent only in a
+     * test, where a collection declaring the hook is refused rather than
+     * read unnarrowed. See `read-scope.ts`.
+     */
+    callContext?: ReadCallContextProvider | undefined);
     /**
      * Get the relational query builder for a given table name.
      * Safely narrows the DrizzleClient union type to access db.query[tableName].
@@ -63,6 +78,31 @@ export declare class FetchService {
      * compile stays unresolvable and so fails closed.
      */
     private filterContext;
+    /**
+     * The conditions this collection's `beforeQuery` hooks ask to add, for a
+     * read that is about to be compiled.
+     *
+     * Resolved here, from the registry this service already holds, rather than
+     * handed in by a caller — so a read path that builds a WHERE cannot serve
+     * one of these collections without the hook. `[]` when nothing is declared,
+     * which leaves the compiled SQL byte-identical.
+     *
+     * Every caller pushes the result onto the same `allConditions` array its
+     * own filter goes into, and every one of those arrays is AND-ed. That is
+     * what keeps a hook additive: it is not trusted to narrow, it is only ever
+     * given a way to.
+     */
+    private narrowRead;
+    /** {@link narrowRead}, pre-combined, for the reads that hold one `SQL`. */
+    private narrowReadCondition;
+    /**
+     * The read the hooks are shown, from the options a read path was given.
+     *
+     * Transport is left out on purpose — a `databaseId`, an `include` tree, a
+     * `withDeleted` flag are not part of "which rows". What is in is what a
+     * scope might reasonably branch on.
+     */
+    private static describeRead;
     /**
      * The table column this collection's rows are keyed by, or `undefined`.
      *
@@ -457,7 +497,15 @@ export declare class FetchService {
         withDeleted?: WithDeleted;
     }): Promise<Record<string, unknown>[]>;
     /**
-     * Check if a field value is unique
+     * Check if a field value is unique.
+     *
+     * Deliberately **not** narrowed by `beforeQuery`, and it is the only read
+     * here that is not. The question is whether the value exists anywhere in
+     * the table, not whether it exists among the rows this caller can see:
+     * narrowed, it would answer "unique" for a value a hidden row already
+     * holds, and the insert would then be rejected by the unique constraint
+     * with a message about a row the caller has no way to find. Uniqueness is a
+     * property of the table.
      */
     checkUniqueField(collectionPath: string, fieldName: string, value: unknown, excludeEntityId?: string, _databaseId?: string): Promise<boolean>;
     /**

package/dist/services/PersistService.d.ts

@@ -1,4 +1,5 @@
 import { RelationService } from "./RelationService.js";
+import type { ReadCallContextProvider } from "./read-scope.js";
 import { RelationWriteService } from "./RelationWriteService.js";
 import { FetchService } from "./FetchService.js";
 import { DrizzleClient } from "../interfaces.js";
@@ -10,12 +11,26 @@ import { PostgresCollectionRegistry } from "../collections/PostgresCollectionReg
 export declare class PersistService {
     private db;
     private registry;
+    /**
+     * How this service's reads reach the identity their `beforeQuery` hooks
+     * run as. Passed by the driver that constructed it; absent only in a
+     * test, where a collection declaring the hook is refused rather than
+     * read unnarrowed. See `read-scope.ts`.
+     */
+    private callContext?;
     /** Reads: whether a row is under a parent, the key a link joins on. */
     private relationService;
     /** Writes: junction membership, foreign-key stamping, links. */
     private relationWrites;
     private fetchService;
-    constructor(db: DrizzleClient, registry: PostgresCollectionRegistry);
+    constructor(db: DrizzleClient, registry: PostgresCollectionRegistry, 
+    /**
+     * How this service's reads reach the identity their `beforeQuery` hooks
+     * run as. Passed by the driver that constructed it; absent only in a
+     * test, where a collection declaring the hook is refused rather than
+     * read unnarrowed. See `read-scope.ts`.
+     */
+    callContext?: ReadCallContextProvider | undefined);
     /**
      * Set the columns of one many-to-many link, without touching the membership.
      *

package/dist/services/RelationService.d.ts

@@ -4,6 +4,7 @@ import { DrizzleClient } from "../interfaces.js";
 import { CollectionConfig, FilterValues, OrderByTuple, ResolvedRelation, ResolvedHasMany, ResolvedHasOne } from "@rebasepro/types";
 import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry.js";
 import type { NestedPathHop } from "./nested-path.js";
+import { type ReadCallContextProvider } from "./read-scope.js";
 /**
  * Typed wrapper for Drizzle dynamic query innerJoin.
  * Drizzle's `$dynamic()` queries lose the `innerJoin` method from
@@ -44,7 +45,36 @@ export interface RelatedRow<M extends Record<string, unknown> = Record<string, u
 export declare class RelationService {
     private db;
     private registry;
-    constructor(db: DrizzleClient, registry: PostgresCollectionRegistry);
+    /**
+     * How this service's reads reach the identity their `beforeQuery` hooks
+     * run as. Passed by the driver that constructed it; absent only in a
+     * test, where a collection declaring the hook is refused rather than
+     * read unnarrowed. See `read-scope.ts`.
+     */
+    private callContext?;
+    constructor(db: DrizzleClient, registry: PostgresCollectionRegistry, 
+    /**
+     * How this service's reads reach the identity their `beforeQuery` hooks
+     * run as. Passed by the driver that constructed it; absent only in a
+     * test, where a collection declaring the hook is refused rather than
+     * read unnarrowed. See `read-scope.ts`.
+     */
+    callContext?: ReadCallContextProvider | undefined);
+    /**
+     * The **target** collection's `beforeQuery` narrowing, for rows reached
+     * through a relation.
+     *
+     * The target's, not the parent's, because these are the target's rows: a
+     * scope on `comments` has to hold whether they are listed at
+     * `/comments` or loaded as `post.comments`. Without this an `include` is a
+     * way around every row filter a collection declares — the exact hole
+     * `stripUnreadable` was once missing from the relation-ref branch.
+     *
+     * Folded into the `narrow` condition the loaders already thread through
+     * every relation kind, so a `via` join, a junction, a foreign key and the
+     * dynamic relation builder all apply it or none of them do.
+     */
+    private narrowTargetRead;
     /**
      * One target row, as the {@link RelatedRow} everything here returns.
      *

package/dist/services/RelationWriteService.d.ts

@@ -2,6 +2,7 @@ import { CollectionConfig, Properties, ResolvedManyToMany, ResolvedRelation, Res
 import { DrizzleClient } from "../interfaces.js";
 import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry.js";
 import type { NestedPathHop } from "./nested-path.js";
+import type { ReadCallContextProvider } from "./read-scope.js";
 /**
  * A `_pivot` as the junction table's columns.
  *
@@ -28,8 +29,22 @@ export declare function serializePivot(pivot: Record<string, unknown>, payload:
 export declare class RelationWriteService {
     private db;
     private registry;
+    /**
+     * How this service's reads reach the identity their `beforeQuery` hooks
+     * run as. Passed by the driver that constructed it; absent only in a
+     * test, where a collection declaring the hook is refused rather than
+     * read unnarrowed. See `read-scope.ts`.
+     */
+    private callContext?;
     private reads;
-    constructor(db: DrizzleClient, registry: PostgresCollectionRegistry);
+    constructor(db: DrizzleClient, registry: PostgresCollectionRegistry, 
+    /**
+     * How this service's reads reach the identity their `beforeQuery` hooks
+     * run as. Passed by the driver that constructed it; absent only in a
+     * test, where a collection declaring the hook is refused rather than
+     * read unnarrowed. See `read-scope.ts`.
+     */
+    callContext?: ReadCallContextProvider | undefined);
     /**
      * Remove the junction row linking a parent to `targetId`, leaving the target
      * row itself alone.

package/dist/services/dataService.d.ts

@@ -1,6 +1,7 @@
 import { FilterValues, IncludeSpec, LogicalCondition, OrderByTuple } from "@rebasepro/types";
 import type { VectorSearchParams } from "@rebasepro/types";
 import { FetchService } from "./FetchService.js";
+import type { ReadCallContextProvider } from "./read-scope.js";
 import type { WithDeleted } from "./soft-delete.js";
 import { PersistService } from "./PersistService.js";
 import { RelationService } from "./RelationService.js";
@@ -25,9 +26,23 @@ export * from "../interfaces.js";
 export declare class DataService implements DataRepository {
     private db;
     private registry;
+    /**
+     * How this service's reads reach the identity their `beforeQuery` hooks
+     * run as. Passed by the driver that constructed it; absent only in a
+     * test, where a collection declaring the hook is refused rather than
+     * read unnarrowed. See `read-scope.ts`.
+     */
+    private callContext?;
     private fetchService;
     private persistService;
-    constructor(db: DrizzleClient, registry: PostgresCollectionRegistry);
+    constructor(db: DrizzleClient, registry: PostgresCollectionRegistry, 
+    /**
+     * How this service's reads reach the identity their `beforeQuery` hooks
+     * run as. Passed by the driver that constructed it; absent only in a
+     * test, where a collection declaring the hook is refused rather than
+     * read unnarrowed. See `read-scope.ts`.
+     */
+    callContext?: ReadCallContextProvider | undefined);
     /**
      * Fetch a single row by ID
      */

package/dist/services/read-scope.d.ts

@@ -0,0 +1,100 @@
+/**
+ * `beforeQuery`: the one place a collection callback can change *which* rows a
+ * read asks for.
+ *
+ * `afterRead` runs over rows that have already been fetched, so until this
+ * existed an application developer who needed the read itself narrowed — a
+ * tenant scope, a visibility window, a per-role row filter — had two options:
+ * patch this driver, or `rebase eject`.
+ *
+ * Two properties are load-bearing, and both belong to the *shape* of the thing
+ * rather than to how carefully each call site was written.
+ *
+ * ## It can only narrow
+ *
+ * A hook returns a {@link QueryNarrowing} — a declarative filter, optionally a
+ * logical group — which is AND-ed into the query the caller sent. `AND(q, c)`
+ * is a subset of `q` for every `c`, so there is no `c` a hook can return that
+ * widens a read. The obvious alternative shape, `(query) => query`, can: a
+ * hook that drops a condition on the way through runs the query without it,
+ * and on an RLS data plane a dropped condition returns everything the policies
+ * happen to allow. That is the same reasoning behind
+ * `UnknownFilterFieldsMode` defaulting to `"error"`, and it is why that mode is
+ * **forced** to `"error"` for a hook's own filter here whatever the
+ * process-wide setting is: a scope condition naming a renamed column has to
+ * refuse the request, never be dropped from it.
+ *
+ * ## It cannot be skipped
+ *
+ * The hooks are resolved *by the read path itself*, out of the registry that
+ * read already holds — not handed to it by a caller who might forget. So a
+ * read that compiles a WHERE compiles this one too, or it throws.
+ *
+ * The one thing a read path cannot derive is the identity the hook runs as:
+ * `FetchService`, `RelationService` and `DataService` carry no user. That
+ * arrives as a {@link ReadCallContextProvider}, threaded from the driver that
+ * constructed them — the driver is the only object that knows both the caller
+ * and the connection, and it constructs a service per transaction anyway, so
+ * there is exactly one place per instance to pass it.
+ *
+ * Absence is the interesting case, and it fails closed: a service built with no
+ * provider refuses any read of a collection that declares `beforeQuery`, with
+ * a message naming the collection. So a future construction site that forgets
+ * the provider breaks loudly on the first scoped collection instead of quietly
+ * serving every row — which is the failure mode this whole module exists to
+ * rule out. A deployment with no `beforeQuery` anywhere never reaches any of
+ * this: the check is one map lookup and the compiled SQL is byte-identical.
+ *
+ * @module
+ */
+import { SQL } from "drizzle-orm";
+import { PgTable } from "drizzle-orm/pg-core";
+import type { CollectionConfig, ReadOperation, ReadQuery, RebaseCallContext } from "@rebasepro/types";
+import type { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry.js";
+import { type FilterCompilationOptions } from "../utils/drizzle-conditions.js";
+/**
+ * How a read path reaches the context its `beforeQuery` hooks run with.
+ *
+ * A function rather than the context itself, because the driver's transaction
+ * handle and its `data` plane are established *after* it constructs the
+ * services that read through them — and because building a context costs an
+ * object that a collection with no hooks should never pay for.
+ */
+export type ReadCallContextProvider = () => RebaseCallContext;
+/** Whether anything at all would run for this collection. */
+export declare function hasBeforeQuery(registry: PostgresCollectionRegistry | undefined, collection: CollectionConfig | undefined): boolean;
+/**
+ * What a read path is about to compile, in the form a hook is shown it.
+ *
+ * Built by the caller rather than derived here, because only the caller knows
+ * which of its options are part of the query and which are transport — a
+ * `databaseId`, an `include` tree, a `withDeleted` flag are not "which rows".
+ */
+export interface ReadQueryDescription {
+    operation: ReadOperation;
+    query: ReadQuery;
+}
+/** Everything `beforeQueryConditions` needs that is not about this one read. */
+export interface BeforeQueryEnv {
+    registry: PostgresCollectionRegistry | undefined;
+    /**
+     * The context provider the driver handed down. `undefined` means no driver
+     * built this service, which is a refusal rather than a bypass — see the
+     * module comment.
+     */
+    callContext: ReadCallContextProvider | undefined;
+}
+/**
+ * The conditions every `beforeQuery` hook for this collection asks to add.
+ *
+ * Returned as a list rather than pre-combined so a caller pushes them onto the
+ * same `allConditions` array its own filter goes into. Every caller AND-es
+ * that array, which is what makes these additive — the hook is not trusted to
+ * narrow, it is only ever given a way to.
+ */
+export declare function beforeQueryConditions(env: BeforeQueryEnv, collection: CollectionConfig | undefined, path: string, table: PgTable<never>, description: ReadQueryDescription, filterContext: Omit<FilterCompilationOptions, "unknownFields">): Promise<SQL[]>;
+/**
+ * {@link beforeQueryConditions}, pre-combined, for the read paths that hold a
+ * single `SQL` rather than a list of them — a single get, a relation loader.
+ */
+export declare function beforeQueryCondition(env: BeforeQueryEnv, collection: CollectionConfig | undefined, path: string, table: PgTable<never>, description: ReadQueryDescription, filterContext: Omit<FilterCompilationOptions, "unknownFields">): Promise<SQL | undefined>;

package/dist/utils/drizzle-conditions.d.ts

@@ -516,13 +516,20 @@ export declare class DrizzleConditionBuilder {
      * - **Declared** — one `@@ websearch_to_tsquery` against the generated
      *   `tsvector` column. Stems, drops stopwords, AND-es the terms, reaches
      *   inside JSONB and arrays, and uses the GIN index.
-     * - **Not declared** — the original `ILIKE '%term%'` OR-ed across top-level
-     *   string properties, with the term escaped (see {@link escapeLikePattern})
-     *   so it is matched as the literal text the user typed.
+     * - **Not declared** — `ILIKE '%term%'` per term, OR-ed across top-level
+     *   string properties and AND-ed across the terms, with each term escaped
+     *   (see {@link escapeLikePattern}) so it is matched as the literal text
+     *   the user typed.
      *
-     * The second is the default and stays the default. A collection that has
-     * not opted in compiles to exactly the SQL it compiled to before this
-     * branch existed, which is the only reason it is safe to have added it.
+     * The second is the default and stays the default, and it AND-es terms for
+     * the same reason `websearch_to_tsquery` does: a person typing two words
+     * into a search box means both, and a name lives in two columns. Matching
+     * the whole string per column instead — which is what this did — cannot
+     * find `sebastian melendez` on a row with `first_name`/`last_name`, and
+     * could not find `sebastian ` at all.
+     *
+     * Returns at most one condition. Every caller ORs what it gets back, which
+     * is right across columns and wrong across terms, so the AND is built here.
      *
      * `collection` is optional so that the callers which genuinely have no
      * collection in hand — nested paths, derived views — keep working; without
@@ -544,6 +551,49 @@ export declare class DrizzleConditionBuilder {
      * on user input, which `to_tsquery` does on so much as a stray parenthesis.
      */
     static buildFullTextCondition(searchString: string, table: PgTable<any>, collection: CollectionConfig): SQL | undefined;
+    /**
+     * The substring half of {@link SearchMode} `"hybrid"`: every term found
+     * somewhere in the declared fields, with accents folded on both sides.
+     *
+     * Terms are AND-ed and fields OR-ed, exactly as the ILIKE default does and
+     * for the same reason — a person typing two words means both, and a name
+     * lives in two columns (`splitSearchTerms`). What it does *not* share with
+     * the default is its reach: these are the declared `search.fields`, so it
+     * folds accents, joins `text[]` and walks into JSONB through the same
+     * IMMUTABLE helpers the generated column uses.
+     *
+     * The needle is folded with the same function as the document, so
+     * `munoz` and `Muñoz` meet in the middle rather than one side being
+     * normalized and the other not — the subtle way to build a search that
+     * matches nothing.
+     *
+     * Interpolated as raw SQL because the field expressions are generated (they
+     * name columns and helper functions, which are identifiers, not values);
+     * the *term* is a bind parameter, escaped for LIKE first — see
+     * {@link escapeLikePattern} for what that escape is for.
+     */
+    static buildFoldedSubstringCondition(searchString: string, spec: SearchColumnSpec): SQL | undefined;
+    /**
+     * Whether one text expression holds **any** term of the search string.
+     *
+     * The per-field question, where {@link buildFoldedSubstringCondition} asks
+     * the per-row one: `OR` across terms rather than `AND`, because a two-word
+     * query satisfied across two fields has each field carrying one term. Used
+     * by `_matches` to name the fields that caused a substring hit.
+     */
+    static foldedSubstringOf(searchString: string, text: SQL): SQL;
+    /**
+     * One accent-folded `%term%` bind parameter per search term.
+     *
+     * The needle is folded with the same function as the document, so `munoz`
+     * and `Muñoz` meet in the middle instead of one side being normalized and
+     * the other not — the subtle way to build a search that matches nothing.
+     *
+     * A string with no terms at all is only whitespace, and stays the single
+     * literal pattern it is on the ILIKE path rather than becoming "no rows",
+     * so both paths answer a stray space the same way.
+     */
+    private static foldedNeedles;
     /**
      * `websearch_to_tsquery(<config>, <normalized search string>)`.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rebasepro/server-postgres",
-  "version": "0.21.2-canary.g1ea48be",
+  "version": "0.22.0",
   "description": "PostgreSQL data source backend implementation for Rebase with Drizzle ORM",
   "keywords": [
     "cms",
@@ -50,11 +50,11 @@
     "execa": "^9.6.1",
     "pg": "^8.22.0",
     "ws": "^8.21.1",
-    "@rebasepro/codegen": "0.21.2-canary.g1ea48be",
-    "@rebasepro/common": "0.21.2-canary.g1ea48be",
-    "@rebasepro/server": "0.21.2-canary.g1ea48be",
-    "@rebasepro/types": "0.21.2-canary.g1ea48be",
-    "@rebasepro/utils": "0.21.2-canary.g1ea48be"
+    "@rebasepro/codegen": "0.22.0",
+    "@rebasepro/common": "0.22.0",
+    "@rebasepro/server": "0.22.0",
+    "@rebasepro/types": "0.22.0",
+    "@rebasepro/utils": "0.22.0"
   },
   "devDependencies": {
     "@electric-sql/pglite": "0.5.6",
@@ -70,7 +70,7 @@
     "typescript": "^6.0.3",
     "vite": "^8.1.5",
     "vitest": "^4.1.10",
-    "@rebasepro/client": "0.21.2-canary.g1ea48be"
+    "@rebasepro/client": "0.22.0"
   },
   "gitHead": "d935eefa5aa8d1009a2398cfac2c1e4ee9aeb6b6",
   "publishConfig": {