@atscript/db-postgres 0.1.149 → 0.1.151

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { AggregateFn, BaseDbAdapter, BucketUnit, DbQuery, DbSpace, FilterExpr, TColumnDiff, TDbDefaultFn, TDbDeleteResult, TDbFieldMeta, TDbInsertIgnoreSlot, TDbInsertManyResult, TDbInsertResult, TDbObjectKind, TDbUpdateResult, TEnsureTableOptions, TExistingColumn, TFieldOps, TPrimaryKeyChange, TReferencingForeignKey, TSearchIndexInfo, TSyncColumnResult, TValueFormatterPair, TViewCapability } from "@atscript/db";
+import { AggregateFn, BaseDbAdapter, BucketUnit, DbQuery, DbSpace, FilterExpr, TColumnDiff, TDbDefaultFn, TDbDeleteResult, TDbFieldMeta, TDbInsertIgnoreSlot, TDbInsertManyResult, TDbInsertResult, TDbObjectKind, TDbUpdateOptions, TDbUpdateResult, TEnsureTableOptions, TExistingColumn, TFieldOps, TPrimaryKeyChange, TReferencingForeignKey, TSearchIndexInfo, TSyncColumnResult, TValueFormatterPair, TViewCapability } from "@atscript/db";
 import { TMetadataMap } from "@atscript/typescript/utils";
 import { TFilterVisitorOptions, TSqlFragment } from "@atscript/db-sql-tools";
 
@@ -79,8 +79,42 @@ declare class PostgresAdapter extends BaseDbAdapter {
   private _nocaseColumns;
   /** Whether citext extension has been provisioned (avoids redundant round-trips). */
   private _citextProvisioned;
-  /** Whether the connected PostgreSQL instance has the PostGIS extension. */
+  /**
+   * Whether the connected PostgreSQL instance has the PostGIS extension —
+   * `undefined` until known: set by schema sync ({@link prepareTypeMapper},
+   * which installs it), or by the read-only geo probe ({@link _probeGeo}).
+   * Decides DDL and geo search; how a geo VALUE binds is decided per column
+   * ({@link _geoNative}).
+   */
   private _supportsGeo;
+  /** Whether {@link _detectGeoSupport} (the installing detection) already ran. */
+  private _geoInstallTried;
+  /** Memo of {@link _hasGeoPointFields}. */
+  private _geoFields?;
+  /** Physical names of the unencrypted `db.geoPoint` columns (set with the metadata). */
+  private _geoColumnNames;
+  /**
+   * Physical geo column → whether it is a PostGIS column (`geography` /
+   * `geometry`: EWKT) or not (JSONB: the JSON form). Learned from the catalog
+   * — after schema sync ({@link afterSyncTable}) or before the first statement
+   * binding a geo value — never from the extension alone: a JSONB column
+   * created before PostGIS was installed stays JSONB until a sync migrates
+   * it. Cleared by every DDL path ({@link _geoSchemaChanged}).
+   */
+  private _geoNative;
+  /** The in-flight shared geo probe and the executor it runs on. */
+  private _geoProbe?;
+  /** Bumped by {@link _geoSchemaChanged}: a probe started before a DDL caches nothing. */
+  private _geoSchemaGen;
+  /** The pool executor with geo-marker resolution (built once). */
+  private _poolExec?;
+  /** The last transaction connection's wrapped executor. */
+  private _txExec?;
+  private _pkColumnsMemo?;
+  private _replaceColumnsMemo?;
+  private _ignorePlanMemo?;
+  private _fulltextMemo?;
+  private _searchIndexesMemo?;
   /** Whether the connected PostgreSQL instance has the pgvector extension. */
   private _supportsVector;
   /** Vector fields: physical field name → { dimensions, similarity, indexName }. */
@@ -108,6 +142,19 @@ declare class PostgresAdapter extends BaseDbAdapter {
    * otherwise the pool-based driver.
    */
   private _exec;
+  /**
+   * `exec` resolving `PendingGeoPoint` params before the statement runs. Every
+   * adapter wraps — not only geo tables: a relational filter on another
+   * table's geo column carries that table's markers into this one's
+   * statement. A statement without markers runs as is (one param scan).
+   */
+  private _geoResolvingExec;
+  /**
+   * `$geoWithin` passed the core guard while PostGIS presence was unknown
+   * ({@link isGeoSearchable} answers optimistically then): learn it, and
+   * refuse like the guard would have when it is absent.
+   */
+  private _assertGeoWithin;
   /**
    * Relational predicates (`$some` / `$none`) render as correlated
    * `[NOT] EXISTS` subqueries — in reads and in mutation filters alike.
@@ -163,12 +210,21 @@ declare class PostgresAdapter extends BaseDbAdapter {
    * unique key columns>`: one statement per chunk (a conflict never raises, so
    * the surrounding transaction survives). Skipped rows are the ones missing
    * from RETURNING — mapped back by key values, see {@link mapIgnoredBatch}.
-   * Each chunk runs inside a SAVEPOINT: when the mapping is ambiguous (a key
-   * the server returns in another form than it was sent) the chunk is rolled
-   * back to the savepoint and redone row by row with the same
-   * `ON CONFLICT DO NOTHING`, so the result is always exact.
+   * A multi-row chunk of a keyed table runs inside a SAVEPOINT: when the
+   * mapping is ambiguous (a key the server returns in another form than it
+   * was sent) the chunk is rolled back to the savepoint and redone row by row
+   * with the same `ON CONFLICT DO NOTHING`, so the result is always exact. A
+   * one-row chunk (or a table without keys) maps exactly by construction, so
+   * it needs no savepoint — and a single such chunk no transaction either.
    */
   insertManyIgnore(data: Array<Record<string, unknown>>): Promise<TDbInsertIgnoreSlot[]>;
+  /**
+   * The key columns of a conflict-ignoring insert (built once per table):
+   * every primary / unique key set, their RETURNING list, and the key columns
+   * whose physical type is not text (see {@link mapIgnoredBatch}). Keyed on the
+   * detected extension state the type mapper reads.
+   */
+  private _ignorePlan;
   findOne(query: DbQuery): Promise<Record<string, unknown> | null>;
   findMany(query: DbQuery): Promise<Array<Record<string, unknown>>>;
   /**
@@ -178,8 +234,19 @@ declare class PostgresAdapter extends BaseDbAdapter {
   findManyPerPartition(query: DbQuery, partitionBy: readonly string[]): Promise<Array<Record<string, unknown>>>;
   count(query: DbQuery): Promise<number>;
   aggregate(query: DbQuery): Promise<Array<Record<string, unknown>>>;
-  /** Physical primary-key columns (`@db.column` renames applied). */
-  private _pkColumns;
+  /**
+   * Physical primary-key columns (`@db.column` renames applied) and their
+   * ` RETURNING …` clause (empty without a PK) — built once per table.
+   */
+  private _pk;
+  /**
+   * Whether `filter` pins at most one row by itself: a plain object holding
+   * exactly the primary-key columns, each equal to a scalar (`{ id: 5 }` or
+   * `{ id: { $eq: 5 } }`) — what the core sends for a by-id write. Such a
+   * filter needs no `LIMIT 1` re-keying subquery: the outer predicate is the
+   * PK equality either way.
+   */
+  private _isExactPkFilter;
   /**
    * The predicate that narrows a single-row UPDATE/DELETE to the first row
    * matching `whereSql`: `<key> <op> (SELECT <cols> … LIMIT 1)`. Single-col
@@ -189,14 +256,21 @@ declare class PostgresAdapter extends BaseDbAdapter {
    * existing behavior rather than guess.
    */
   private _limitOnePredicate;
-  updateOne(filter: FilterExpr, data: Record<string, unknown>, ops?: TFieldOps, expectedVersion?: number): Promise<TDbUpdateResult>;
-  updateMany(filter: FilterExpr, data: Record<string, unknown>, ops?: TFieldOps): Promise<TDbUpdateResult>;
+  updateOne(filter: FilterExpr, data: Record<string, unknown>, ops?: TFieldOps, expectedVersion?: number, opts?: TDbUpdateOptions): Promise<TDbUpdateResult>;
+  updateMany(filter: FilterExpr, data: Record<string, unknown>, ops?: TFieldOps, opts?: TDbUpdateOptions): Promise<TDbUpdateResult>;
   replaceOne(filter: FilterExpr, data: Record<string, unknown>, expectedVersion?: number): Promise<TDbUpdateResult>;
+  /** The columns a full replace assigns (`replaceColumnsFor`), built once per table. */
+  private _replaceColumns;
   replaceMany(filter: FilterExpr, data: Record<string, unknown>): Promise<TDbUpdateResult>;
   deleteOne(filter: FilterExpr): Promise<TDbDeleteResult>;
   deleteMany(filter: FilterExpr): Promise<TDbDeleteResult>;
+  private _deleteWhere;
   prepareTypeMapper(): Promise<void>;
-  /** Whether the table declares any `db.geoPoint` fields (unencrypted). */
+  /**
+   * Whether the table declares any `db.geoPoint` fields (unencrypted) — set
+   * when the metadata is built (`false` before, and on an administrative
+   * adapter: no geo value can be formatted without built metadata).
+   */
   private _hasGeoPointFields;
   ensureTable(opts?: TEnsureTableOptions): Promise<void>;
   /** `schema.name` when the adapter targets a named schema. */
@@ -267,6 +341,7 @@ declare class PostgresAdapter extends BaseDbAdapter {
   /** Queries information_schema for existing FK constraints. */
   private _getExistingFkConstraints;
   getSearchIndexes(): TSearchIndexInfo[];
+  private _buildSearchIndexes;
   search(text: string, query: DbQuery, indexName?: string): Promise<Array<Record<string, unknown>>>;
   searchWithCount(text: string, query: DbQuery, indexName?: string): Promise<{
     data: Array<Record<string, unknown>>;
@@ -276,6 +351,8 @@ declare class PostgresAdapter extends BaseDbAdapter {
   /** Builds the tsvector SQL expression for a fulltext index's fields. Must match between index DDL and queries. */
   private _buildTsvectorExpr;
   private _getFulltextIndex;
+  /** The table's fulltext indexes and the default one, built once per table. */
+  private _fulltextIndexes;
   /**
    * Detects pgvector support by attempting to enable the extension.
    * Idempotent — safe to call multiple times.
@@ -296,11 +373,47 @@ declare class PostgresAdapter extends BaseDbAdapter {
   /** Resolves threshold: query-time $threshold > schema-level @db.search.vector.threshold. */
   private _resolveVectorThreshold;
   /**
-   * Detects PostGIS support by attempting to enable the extension.
-   * Idempotent — safe to call multiple times.
+   * Detects PostGIS support by attempting to enable the extension — schema
+   * sync's detection ({@link prepareTypeMapper}). Runs once; a probe that
+   * already found PostGIS skips it.
    */
   private _detectGeoSupport;
+  /**
+   * Whether geo column `column` is a PostGIS column (EWKT) — synchronously
+   * when known, else after {@link _probeGeo} on `exec` (the statement's own
+   * executor). A column the catalog does not show (table not created yet)
+   * follows PostGIS presence — what sync would create — and is probed again
+   * next time.
+   */
+  private _geoColumnNative;
+  /**
+   * The read-only geo probe ({@link GEO_PROBE_SQL}) of this table on `exec`:
+   * records PostGIS presence when not known yet, and caches the type of every
+   * geo column the catalog shows (unless a DDL path ran meanwhile).
+   *
+   * Concurrent callers on the SAME executor share one probe; a caller on
+   * another executor runs its own — waiting on a probe queued for a pool
+   * connection while holding a transaction connection could deadlock a
+   * small pool, and a transaction's failure (an aborted one) never reaches
+   * callers outside it. A failed probe is not cached, and a caller that
+   * joined it retries once (a pool probe may have hit a broken connection).
+   */
+  private _probeGeo;
+  private _runGeoProbe;
+  /**
+   * A DDL path ran (create / alter / recreate / rename / drop): the geo
+   * column types are learned anew, and a probe in flight caches nothing.
+   */
+  private _geoSchemaChanged;
+  /**
+   * PostGIS presence when known; while unknown (no sync, no statement yet),
+   * a table with geo columns answers `true` — the geo paths learn presence
+   * before they run and refuse with `GEO_NOT_SUPPORTED` then, so the first
+   * geo search of a process that never syncs is not refused up front.
+   */
   isGeoSearchable(): boolean;
+  /** PostGIS presence, probed when not known yet (geo search entry points). */
+  private _ensureGeoKnown;
   geoSearch(point: [number, number], query: DbQuery, indexName?: string): Promise<Array<Record<string, unknown>>>;
   geoSearchWithCount(point: [number, number], query: DbQuery, indexName?: string): Promise<{
     data: Array<Record<string, unknown>>;

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { AggregateFn, BaseDbAdapter, BucketUnit, DbQuery, DbSpace, FilterExpr, TColumnDiff, TDbDefaultFn, TDbDeleteResult, TDbFieldMeta, TDbInsertIgnoreSlot, TDbInsertManyResult, TDbInsertResult, TDbObjectKind, TDbUpdateResult, TEnsureTableOptions, TExistingColumn, TFieldOps, TPrimaryKeyChange, TReferencingForeignKey, TSearchIndexInfo, TSyncColumnResult, TValueFormatterPair, TViewCapability } from "@atscript/db";
+import { AggregateFn, BaseDbAdapter, BucketUnit, DbQuery, DbSpace, FilterExpr, TColumnDiff, TDbDefaultFn, TDbDeleteResult, TDbFieldMeta, TDbInsertIgnoreSlot, TDbInsertManyResult, TDbInsertResult, TDbObjectKind, TDbUpdateOptions, TDbUpdateResult, TEnsureTableOptions, TExistingColumn, TFieldOps, TPrimaryKeyChange, TReferencingForeignKey, TSearchIndexInfo, TSyncColumnResult, TValueFormatterPair, TViewCapability } from "@atscript/db";
 import { TFilterVisitorOptions, TSqlFragment } from "@atscript/db-sql-tools";
 import { TMetadataMap } from "@atscript/typescript/utils";
 
@@ -79,8 +79,42 @@ declare class PostgresAdapter extends BaseDbAdapter {
   private _nocaseColumns;
   /** Whether citext extension has been provisioned (avoids redundant round-trips). */
   private _citextProvisioned;
-  /** Whether the connected PostgreSQL instance has the PostGIS extension. */
+  /**
+   * Whether the connected PostgreSQL instance has the PostGIS extension —
+   * `undefined` until known: set by schema sync ({@link prepareTypeMapper},
+   * which installs it), or by the read-only geo probe ({@link _probeGeo}).
+   * Decides DDL and geo search; how a geo VALUE binds is decided per column
+   * ({@link _geoNative}).
+   */
   private _supportsGeo;
+  /** Whether {@link _detectGeoSupport} (the installing detection) already ran. */
+  private _geoInstallTried;
+  /** Memo of {@link _hasGeoPointFields}. */
+  private _geoFields?;
+  /** Physical names of the unencrypted `db.geoPoint` columns (set with the metadata). */
+  private _geoColumnNames;
+  /**
+   * Physical geo column → whether it is a PostGIS column (`geography` /
+   * `geometry`: EWKT) or not (JSONB: the JSON form). Learned from the catalog
+   * — after schema sync ({@link afterSyncTable}) or before the first statement
+   * binding a geo value — never from the extension alone: a JSONB column
+   * created before PostGIS was installed stays JSONB until a sync migrates
+   * it. Cleared by every DDL path ({@link _geoSchemaChanged}).
+   */
+  private _geoNative;
+  /** The in-flight shared geo probe and the executor it runs on. */
+  private _geoProbe?;
+  /** Bumped by {@link _geoSchemaChanged}: a probe started before a DDL caches nothing. */
+  private _geoSchemaGen;
+  /** The pool executor with geo-marker resolution (built once). */
+  private _poolExec?;
+  /** The last transaction connection's wrapped executor. */
+  private _txExec?;
+  private _pkColumnsMemo?;
+  private _replaceColumnsMemo?;
+  private _ignorePlanMemo?;
+  private _fulltextMemo?;
+  private _searchIndexesMemo?;
   /** Whether the connected PostgreSQL instance has the pgvector extension. */
   private _supportsVector;
   /** Vector fields: physical field name → { dimensions, similarity, indexName }. */
@@ -108,6 +142,19 @@ declare class PostgresAdapter extends BaseDbAdapter {
    * otherwise the pool-based driver.
    */
   private _exec;
+  /**
+   * `exec` resolving `PendingGeoPoint` params before the statement runs. Every
+   * adapter wraps — not only geo tables: a relational filter on another
+   * table's geo column carries that table's markers into this one's
+   * statement. A statement without markers runs as is (one param scan).
+   */
+  private _geoResolvingExec;
+  /**
+   * `$geoWithin` passed the core guard while PostGIS presence was unknown
+   * ({@link isGeoSearchable} answers optimistically then): learn it, and
+   * refuse like the guard would have when it is absent.
+   */
+  private _assertGeoWithin;
   /**
    * Relational predicates (`$some` / `$none`) render as correlated
    * `[NOT] EXISTS` subqueries — in reads and in mutation filters alike.
@@ -163,12 +210,21 @@ declare class PostgresAdapter extends BaseDbAdapter {
    * unique key columns>`: one statement per chunk (a conflict never raises, so
    * the surrounding transaction survives). Skipped rows are the ones missing
    * from RETURNING — mapped back by key values, see {@link mapIgnoredBatch}.
-   * Each chunk runs inside a SAVEPOINT: when the mapping is ambiguous (a key
-   * the server returns in another form than it was sent) the chunk is rolled
-   * back to the savepoint and redone row by row with the same
-   * `ON CONFLICT DO NOTHING`, so the result is always exact.
+   * A multi-row chunk of a keyed table runs inside a SAVEPOINT: when the
+   * mapping is ambiguous (a key the server returns in another form than it
+   * was sent) the chunk is rolled back to the savepoint and redone row by row
+   * with the same `ON CONFLICT DO NOTHING`, so the result is always exact. A
+   * one-row chunk (or a table without keys) maps exactly by construction, so
+   * it needs no savepoint — and a single such chunk no transaction either.
    */
   insertManyIgnore(data: Array<Record<string, unknown>>): Promise<TDbInsertIgnoreSlot[]>;
+  /**
+   * The key columns of a conflict-ignoring insert (built once per table):
+   * every primary / unique key set, their RETURNING list, and the key columns
+   * whose physical type is not text (see {@link mapIgnoredBatch}). Keyed on the
+   * detected extension state the type mapper reads.
+   */
+  private _ignorePlan;
   findOne(query: DbQuery): Promise<Record<string, unknown> | null>;
   findMany(query: DbQuery): Promise<Array<Record<string, unknown>>>;
   /**
@@ -178,8 +234,19 @@ declare class PostgresAdapter extends BaseDbAdapter {
   findManyPerPartition(query: DbQuery, partitionBy: readonly string[]): Promise<Array<Record<string, unknown>>>;
   count(query: DbQuery): Promise<number>;
   aggregate(query: DbQuery): Promise<Array<Record<string, unknown>>>;
-  /** Physical primary-key columns (`@db.column` renames applied). */
-  private _pkColumns;
+  /**
+   * Physical primary-key columns (`@db.column` renames applied) and their
+   * ` RETURNING …` clause (empty without a PK) — built once per table.
+   */
+  private _pk;
+  /**
+   * Whether `filter` pins at most one row by itself: a plain object holding
+   * exactly the primary-key columns, each equal to a scalar (`{ id: 5 }` or
+   * `{ id: { $eq: 5 } }`) — what the core sends for a by-id write. Such a
+   * filter needs no `LIMIT 1` re-keying subquery: the outer predicate is the
+   * PK equality either way.
+   */
+  private _isExactPkFilter;
   /**
    * The predicate that narrows a single-row UPDATE/DELETE to the first row
    * matching `whereSql`: `<key> <op> (SELECT <cols> … LIMIT 1)`. Single-col
@@ -189,14 +256,21 @@ declare class PostgresAdapter extends BaseDbAdapter {
    * existing behavior rather than guess.
    */
   private _limitOnePredicate;
-  updateOne(filter: FilterExpr, data: Record<string, unknown>, ops?: TFieldOps, expectedVersion?: number): Promise<TDbUpdateResult>;
-  updateMany(filter: FilterExpr, data: Record<string, unknown>, ops?: TFieldOps): Promise<TDbUpdateResult>;
+  updateOne(filter: FilterExpr, data: Record<string, unknown>, ops?: TFieldOps, expectedVersion?: number, opts?: TDbUpdateOptions): Promise<TDbUpdateResult>;
+  updateMany(filter: FilterExpr, data: Record<string, unknown>, ops?: TFieldOps, opts?: TDbUpdateOptions): Promise<TDbUpdateResult>;
   replaceOne(filter: FilterExpr, data: Record<string, unknown>, expectedVersion?: number): Promise<TDbUpdateResult>;
+  /** The columns a full replace assigns (`replaceColumnsFor`), built once per table. */
+  private _replaceColumns;
   replaceMany(filter: FilterExpr, data: Record<string, unknown>): Promise<TDbUpdateResult>;
   deleteOne(filter: FilterExpr): Promise<TDbDeleteResult>;
   deleteMany(filter: FilterExpr): Promise<TDbDeleteResult>;
+  private _deleteWhere;
   prepareTypeMapper(): Promise<void>;
-  /** Whether the table declares any `db.geoPoint` fields (unencrypted). */
+  /**
+   * Whether the table declares any `db.geoPoint` fields (unencrypted) — set
+   * when the metadata is built (`false` before, and on an administrative
+   * adapter: no geo value can be formatted without built metadata).
+   */
   private _hasGeoPointFields;
   ensureTable(opts?: TEnsureTableOptions): Promise<void>;
   /** `schema.name` when the adapter targets a named schema. */
@@ -267,6 +341,7 @@ declare class PostgresAdapter extends BaseDbAdapter {
   /** Queries information_schema for existing FK constraints. */
   private _getExistingFkConstraints;
   getSearchIndexes(): TSearchIndexInfo[];
+  private _buildSearchIndexes;
   search(text: string, query: DbQuery, indexName?: string): Promise<Array<Record<string, unknown>>>;
   searchWithCount(text: string, query: DbQuery, indexName?: string): Promise<{
     data: Array<Record<string, unknown>>;
@@ -276,6 +351,8 @@ declare class PostgresAdapter extends BaseDbAdapter {
   /** Builds the tsvector SQL expression for a fulltext index's fields. Must match between index DDL and queries. */
   private _buildTsvectorExpr;
   private _getFulltextIndex;
+  /** The table's fulltext indexes and the default one, built once per table. */
+  private _fulltextIndexes;
   /**
    * Detects pgvector support by attempting to enable the extension.
    * Idempotent — safe to call multiple times.
@@ -296,11 +373,47 @@ declare class PostgresAdapter extends BaseDbAdapter {
   /** Resolves threshold: query-time $threshold > schema-level @db.search.vector.threshold. */
   private _resolveVectorThreshold;
   /**
-   * Detects PostGIS support by attempting to enable the extension.
-   * Idempotent — safe to call multiple times.
+   * Detects PostGIS support by attempting to enable the extension — schema
+   * sync's detection ({@link prepareTypeMapper}). Runs once; a probe that
+   * already found PostGIS skips it.
    */
   private _detectGeoSupport;
+  /**
+   * Whether geo column `column` is a PostGIS column (EWKT) — synchronously
+   * when known, else after {@link _probeGeo} on `exec` (the statement's own
+   * executor). A column the catalog does not show (table not created yet)
+   * follows PostGIS presence — what sync would create — and is probed again
+   * next time.
+   */
+  private _geoColumnNative;
+  /**
+   * The read-only geo probe ({@link GEO_PROBE_SQL}) of this table on `exec`:
+   * records PostGIS presence when not known yet, and caches the type of every
+   * geo column the catalog shows (unless a DDL path ran meanwhile).
+   *
+   * Concurrent callers on the SAME executor share one probe; a caller on
+   * another executor runs its own — waiting on a probe queued for a pool
+   * connection while holding a transaction connection could deadlock a
+   * small pool, and a transaction's failure (an aborted one) never reaches
+   * callers outside it. A failed probe is not cached, and a caller that
+   * joined it retries once (a pool probe may have hit a broken connection).
+   */
+  private _probeGeo;
+  private _runGeoProbe;
+  /**
+   * A DDL path ran (create / alter / recreate / rename / drop): the geo
+   * column types are learned anew, and a probe in flight caches nothing.
+   */
+  private _geoSchemaChanged;
+  /**
+   * PostGIS presence when known; while unknown (no sync, no statement yet),
+   * a table with geo columns answers `true` — the geo paths learn presence
+   * before they run and refuse with `GEO_NOT_SUPPORTED` then, so the first
+   * geo search of a process that never syncs is not refused up front.
+   */
   isGeoSearchable(): boolean;
+  /** PostGIS presence, probed when not known yet (geo search entry points). */
+  private _ensureGeoKnown;
   geoSearch(point: [number, number], query: DbQuery, indexName?: string): Promise<Array<Record<string, unknown>>>;
   geoSearchWithCount(point: [number, number], query: DbQuery, indexName?: string): Promise<{
     data: Array<Record<string, unknown>>;