@expo/entity-database-adapter-knex 0.55.0 → 0.57.0

package/build/src/AuthorizationResultBasedKnexEntityLoader.d.ts

@@ -0,0 +1,279 @@
+import { EntityConstructionUtils, EntityPrivacyPolicy, EntityQueryContext, ReadonlyEntity, ViewerContext, IEntityMetricsAdapter } from '@expo/entity';
+import { Result } from '@expo/results';
+import { FieldEqualityCondition, NullsOrdering, OrderByOrdering } from './BasePostgresEntityDatabaseAdapter';
+import { BaseSQLQueryBuilder } from './BaseSQLQueryBuilder';
+import { PaginationStrategy } from './PaginationStrategy';
+import { SQLFragment } from './SQLOperator';
+import type { Connection } from './internal/EntityKnexDataManager';
+import { EntityKnexDataManager } from './internal/EntityKnexDataManager';
+import { NonNullableKeys } from './internal/utilityTypes';
+export type EntityLoaderBaseOrderByClause = {
+    /**
+     * The OrderByOrdering to order by.
+     */
+    order: OrderByOrdering;
+    /**
+     * Optional nulls ordering for this order by clause. If not provided, no specific nulls ordering is applied.
+     */
+    nulls?: NullsOrdering | undefined;
+};
+export type EntityLoaderFieldNameOrderByClause<TFields extends Record<string, any>, TSelectedFields extends keyof TFields = keyof TFields> = EntityLoaderBaseOrderByClause & {
+    /**
+     * The field name to order by.
+     */
+    fieldName: TSelectedFields;
+};
+export type EntityLoaderFieldFragmentOrderByClause<TFields extends Record<string, any>, TSelectedFields extends keyof TFields = keyof TFields> = EntityLoaderBaseOrderByClause & {
+    /**
+     * The SQL fragment to order by, which can reference selected fields. Example: `COALESCE(NULLIF(display_name, ''), split_part(full_name, '/', 2))`.
+     * May not contain ASC or DESC, as ordering direction is controlled by the `order` property.
+     */
+    fieldFragment: SQLFragment<Pick<TFields, TSelectedFields>>;
+};
+export type EntityLoaderOrderByClause<TFields extends Record<string, any>, TSelectedFields extends keyof TFields = keyof TFields> = EntityLoaderFieldNameOrderByClause<TFields, TSelectedFields> | EntityLoaderFieldFragmentOrderByClause<TFields, TSelectedFields>;
+/**
+ * SQL modifiers that only affect the selection but not the projection.
+ */
+export interface EntityLoaderQuerySelectionModifiers<TFields extends Record<string, any>, TSelectedFields extends keyof TFields = keyof TFields> {
+    /**
+     * Order the entities by specified columns and orders.
+     */
+    orderBy?: readonly EntityLoaderOrderByClause<TFields, TSelectedFields>[];
+    /**
+     * Skip the specified number of entities queried before returning.
+     */
+    offset?: number;
+    /**
+     * Limit the number of entities returned.
+     */
+    limit?: number;
+}
+/**
+ * Function to be used for constructing search fields based on field names.
+ * The function takes a field name and returns a SQLFragment that can be used in the search field portion.
+ */
+export type EntityLoaderFieldNameConstructorFn<TFields extends Record<string, any>, TSelectedFields extends keyof TFields = keyof TFields> = (fieldName: TSelectedFields) => SQLFragment<TFields>;
+/**
+ * Specification for a search field that is a manually constructed SQLFragment. Useful for complex search fields that require
+ * transformations or combinations of multiple fields, such as `COALESCE(NULLIF(display_name, ''), split_part(full_name, '/', 2))`
+ * to search by display name with fallback to full name.
+ */
+export type EntityLoaderSearchFieldSQLFragmentFnSpecification<TFields extends Record<string, any>, TSelectedFields extends keyof TFields = keyof TFields> = {
+    /**
+     * Function that constructs the SQLFragment for the search field.
+     *
+     * @param getFragmentForFieldName - A helper function that takes a field name and returns a SQLFragment for that field, which should be used
+     *                                  to construct the final SQLFragment for the search field.
+     * @returns a SQLFragment representing the search field, which must reference selected fields through the provided helper function.
+     *
+     * @example
+     * For example, to construct a search field that searches by display name (nullable column) with fallback to full name,
+     * the fieldConstructor function could be implemented as follows:
+     * ```
+     * fieldConstructor: (getFragmentForFieldName) => {
+     *   const displayNameFragment = getFragmentForFieldName('display_name');
+     *   const fullNameFragment = getFragmentForFieldName('full_name');
+     *   return sql`COALESCE(NULLIF(${displayNameFragment}, ''), split_part(${fullNameFragment}, '/', 2))`;
+     * }
+     * ```
+     */
+    fieldConstructor: (
+    /**
+     * Helper function to get a SQLFragment for a given field name, which should be used to construct the final SQLFragment for the search field.
+     */
+    getFragmentForFieldName: EntityLoaderFieldNameConstructorFn<TFields, TSelectedFields>) => SQLFragment<Pick<TFields, TSelectedFields>>;
+};
+/**
+ * Set of selected fields that are non-nullable, which can be used for search fields that require non-nullable fields.
+ * To use a nullable field as a search field, use an EntityLoaderSearchFieldSQLFragmentFnSpecification with appropriate SQL
+ * to handle null values, such as `COALESCE(field_name, '')` to treat nulls as empty strings for searching.
+ */
+export type NonNullableSelectedFields<TFields extends Record<string, any>, TSelectedFields extends keyof TFields> = TSelectedFields & NonNullableKeys<TFields>;
+/**
+ * Specification for a search field that can be either a simple selected field name (which must be non-nullable) or a manually constructed
+ * SQLFragment using EntityLoaderSearchFieldSQLFragmentFnSpecification.
+ */
+export type EntityLoaderSearchFieldSpecification<TFields extends Record<string, any>, TSelectedFields extends keyof TFields = keyof TFields> = NonNullableSelectedFields<TFields, TSelectedFields> | EntityLoaderSearchFieldSQLFragmentFnSpecification<TFields, TSelectedFields>;
+interface SearchSpecificationBase<TFields extends Record<string, any>, TSelectedFields extends keyof TFields = keyof TFields> {
+    /**
+     * The search term to search for. Must be a non-empty string.
+     */
+    term: string;
+    /**
+     * The fields to search within.
+     */
+    fields: readonly EntityLoaderSearchFieldSpecification<TFields, TSelectedFields>[];
+}
+interface ILikeSearchSpecification<TFields extends Record<string, any>, TSelectedFields extends keyof TFields = keyof TFields> extends SearchSpecificationBase<TFields, TSelectedFields> {
+    /**
+     * Case-insensitive pattern matching search using SQL ILIKE operator.
+     * Results are ordered by the fields being searched within in the order specified, then by ID for tie-breaking and stable pagination.
+     */
+    strategy: PaginationStrategy.ILIKE_SEARCH;
+}
+interface TrigramSearchSpecification<TFields extends Record<string, any>, TSelectedFields extends keyof TFields = keyof TFields> extends SearchSpecificationBase<TFields, TSelectedFields> {
+    /**
+     * Similarity search using PostgreSQL trigram similarity. Results are ordered by exact match priority, then by similarity score, then by specified extra order by fields if provided, then by ID for tie-breaking and stable pagination.
+     * Note that trigram similarity search can be significantly slower than ILIKE search, especially on large datasets without appropriate indexes, and results may not be as relevant as more advanced full-text search solutions.
+     * It is recommended to use this strategy only when ILIKE search does not meet the application's needs and to ensure appropriate database indexing for performance.
+     */
+    strategy: PaginationStrategy.TRIGRAM_SEARCH;
+    /**
+     * Similarity threshold for trigram matching.
+     * Must be between 0 and 1, where:
+     * - 0 matches everything
+     * - 1 requires exact match
+     *
+     * Recommended threshold values:
+     * - 0.3: Loose matching, allows more variation (default PostgreSQL similarity threshold)
+     * - 0.4-0.5: Moderate matching, good balance for most use cases
+     * - 0.6+: Strict matching, requires high similarity
+     */
+    threshold: number;
+    /**
+     * Optional additional fields to order by after similarity score and before ID for tie-breaking.
+     * These fields are independent of search fields and can be used to provide meaningful
+     * ordering when multiple results have the same similarity score.
+     */
+    extraOrderByFields?: readonly EntityLoaderSearchFieldSpecification<TFields, TSelectedFields>[];
+}
+interface StandardPaginationSpecification<TFields extends Record<string, any>, TSelectedFields extends keyof TFields = keyof TFields> {
+    /**
+     * Standard pagination without search. Results are ordered by the specified orderBy fields.
+     */
+    strategy: PaginationStrategy.STANDARD;
+    /**
+     * Order the entities by specified columns and orders. If the ID field is not included, it will be automatically added for stable pagination.
+     */
+    orderBy: readonly EntityLoaderOrderByClause<TFields, TSelectedFields>[];
+}
+/**
+ * Pagination specification for SQL-based pagination (with or without search).
+ */
+export type PaginationSpecification<TFields extends Record<string, any>, TSelectedFields extends keyof TFields = keyof TFields> = StandardPaginationSpecification<TFields, TSelectedFields> | ILikeSearchSpecification<TFields, TSelectedFields> | TrigramSearchSpecification<TFields, TSelectedFields>;
+/**
+ * Base unified pagination arguments
+ */
+interface EntityLoaderBaseUnifiedPaginationArgs<TFields extends Record<string, any>, TSelectedFields extends keyof TFields = keyof TFields> {
+    /**
+     * SQLFragment representing the WHERE clause to filter the entities being paginated.
+     */
+    where?: SQLFragment<Pick<TFields, TSelectedFields>>;
+    /**
+     * Pagination specification determining how to order and paginate results.
+     */
+    pagination: PaginationSpecification<TFields, TSelectedFields>;
+}
+/**
+ * Forward unified pagination arguments
+ */
+export interface EntityLoaderForwardUnifiedPaginationArgs<TFields extends Record<string, any>, TSelectedFields extends keyof TFields = keyof TFields> extends EntityLoaderBaseUnifiedPaginationArgs<TFields, TSelectedFields> {
+    /**
+     * The number of entities to return starting from the entity after the cursor. Must be a positive integer.
+     */
+    first: number;
+    /**
+     * The number of entities to return starting from the entity before the cursor. Must be a positive integer.
+     * Not allowed with forward pagination.
+     */
+    last?: never;
+    /**
+     * The cursor to paginate after for forward pagination.
+     */
+    after?: string;
+    /**
+     * The cursor to paginate before for backward pagination.
+     * Not allowed with forward pagination.
+     */
+    before?: never;
+}
+/**
+ * Backward unified pagination arguments
+ */
+export interface EntityLoaderBackwardUnifiedPaginationArgs<TFields extends Record<string, any>, TSelectedFields extends keyof TFields = keyof TFields> extends EntityLoaderBaseUnifiedPaginationArgs<TFields, TSelectedFields> {
+    /**
+     * The number of entities to return starting from the entity after the cursor. Must be a positive integer.
+     * Not allowed with backward pagination.
+     */
+    first?: never;
+    /**
+     * The number of entities to return starting from the entity before the cursor. Must be a positive integer.
+     */
+    last: number;
+    /**
+     * The cursor to paginate after for forward pagination.
+     * Not allowed with backward pagination.
+     */
+    after?: never;
+    /**
+     * The cursor to paginate before for backward pagination.
+     */
+    before?: string;
+}
+/**
+ * Load page pagination arguments, which can be either forward or backward unified pagination arguments.
+ */
+export type EntityLoaderLoadPageArgs<TFields extends Record<string, any>, TSelectedFields extends keyof TFields = keyof TFields> = EntityLoaderForwardUnifiedPaginationArgs<TFields, TSelectedFields> | EntityLoaderBackwardUnifiedPaginationArgs<TFields, TSelectedFields>;
+/**
+ * Authorization-result-based knex entity loader for non-data-loader-based load methods.
+ * All loads through this loader are results (or null for some loader methods), where an
+ * unsuccessful result means an authorization error or entity construction error occurred.
+ * Other errors are thrown.
+ */
+export declare class AuthorizationResultBasedKnexEntityLoader<TFields extends Record<string, any>, TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>, TViewerContext extends ViewerContext, TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>, TPrivacyPolicy extends EntityPrivacyPolicy<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>, TSelectedFields extends keyof TFields = keyof TFields> {
+    private readonly queryContext;
+    private readonly knexDataManager;
+    protected readonly metricsAdapter: IEntityMetricsAdapter;
+    private readonly constructionUtils;
+    constructor(queryContext: EntityQueryContext, knexDataManager: EntityKnexDataManager<TFields, TIDField>, metricsAdapter: IEntityMetricsAdapter, constructionUtils: EntityConstructionUtils<TFields, TIDField, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields>);
+    /**
+     * Authorization-result-based version of the EnforcingKnexEntityLoader method by the same name.
+     * @returns the first entity results that matches the query, where result error can be
+     *  UnauthorizedError
+     */
+    loadFirstByFieldEqualityConjunctionAsync<N extends keyof Pick<TFields, TSelectedFields>>(fieldEqualityOperands: readonly FieldEqualityCondition<TFields, N>[], querySelectionModifiers: Omit<EntityLoaderQuerySelectionModifiers<TFields, TSelectedFields>, 'limit'> & Required<Pick<EntityLoaderQuerySelectionModifiers<TFields, TSelectedFields>, 'orderBy'>>): Promise<Result<TEntity> | null>;
+    /**
+     * Authorization-result-based version of the EnforcingKnexEntityLoader method by the same name.
+     * @returns array of entity results that match the query, where result error can be UnauthorizedError
+     */
+    loadManyByFieldEqualityConjunctionAsync<N extends keyof Pick<TFields, TSelectedFields>>(fieldEqualityOperands: readonly FieldEqualityCondition<TFields, N>[], querySelectionModifiers?: EntityLoaderQuerySelectionModifiers<TFields, TSelectedFields>): Promise<readonly Result<TEntity>[]>;
+    /**
+     * Authorization-result-based version of the EnforcingKnexEntityLoader method by the same name.
+     * @returns array of entity results that match the query, where result error can be UnauthorizedError
+     * @throws Error when rawWhereClause or bindings are invalid
+     *
+     * @deprecated Use loadManyBySQL instead for safer value bindings and more flexible query building.
+     */
+    loadManyByRawWhereClauseAsync(rawWhereClause: string, bindings: any[] | object, querySelectionModifiers?: EntityLoaderQuerySelectionModifiers<TFields, TSelectedFields>): Promise<readonly Result<TEntity>[]>;
+    /**
+     * Authorization-result-based version of the EnforcingKnexEntityLoader method by the same name.
+     * @returns SQL query builder for building and executing SQL queries that when executed returns entity results where result error can be UnauthorizedError.
+     */
+    loadManyBySQL(fragment: SQLFragment<Pick<TFields, TSelectedFields>>, modifiers?: EntityLoaderQuerySelectionModifiers<TFields, TSelectedFields>): AuthorizationResultBasedSQLQueryBuilder<TFields, TIDField, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields>;
+    /**
+     * Load a page of entities with Relay-style cursor pagination using a unified pagination specification.
+     * Only returns successfully authorized entities for cursor stability; failed authorization results are filtered out.
+     *
+     * @returns Connection with only successfully authorized entities
+     */
+    loadPageAsync(args: EntityLoaderLoadPageArgs<TFields, TSelectedFields>): Promise<Connection<TEntity>>;
+    /**
+     * Authorization-result-based version of the EnforcingKnexEntityLoader method by the same name.
+     * @returns The pagination cursor for the given entity.
+     */
+    getPaginationCursorForEntity(entity: TEntity): string;
+}
+/**
+ * SQL query builder implementation for AuthorizationResultBasedKnexEntityLoader.
+ */
+export declare class AuthorizationResultBasedSQLQueryBuilder<TFields extends Record<string, any>, TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>, TViewerContext extends ViewerContext, TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>, TPrivacyPolicy extends EntityPrivacyPolicy<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>, TSelectedFields extends keyof TFields> extends BaseSQLQueryBuilder<TFields, TSelectedFields, Result<TEntity>> {
+    private readonly knexDataManager;
+    private readonly constructionUtils;
+    private readonly queryContext;
+    constructor(knexDataManager: EntityKnexDataManager<TFields, TIDField>, constructionUtils: EntityConstructionUtils<TFields, TIDField, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields>, queryContext: EntityQueryContext, sqlFragment: SQLFragment<Pick<TFields, TSelectedFields>>, modifiers: EntityLoaderQuerySelectionModifiers<TFields, TSelectedFields>);
+    /**
+     * Execute the query and return results.
+     */
+    executeInternalAsync(): Promise<readonly Result<TEntity>[]>;
+}
+export {};

package/build/src/AuthorizationResultBasedKnexEntityLoader.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthorizationResultBasedSQLQueryBuilder = exports.AuthorizationResultBasedKnexEntityLoader = void 0;
+const BasePostgresEntityDatabaseAdapter_1 = require("./BasePostgresEntityDatabaseAdapter");
+const BaseSQLQueryBuilder_1 = require("./BaseSQLQueryBuilder");
+/**
+ * Authorization-result-based knex entity loader for non-data-loader-based load methods.
+ * All loads through this loader are results (or null for some loader methods), where an
+ * unsuccessful result means an authorization error or entity construction error occurred.
+ * Other errors are thrown.
+ */
+class AuthorizationResultBasedKnexEntityLoader {
+    queryContext;
+    knexDataManager;
+    metricsAdapter;
+    constructionUtils;
+    constructor(queryContext, knexDataManager, metricsAdapter, constructionUtils) {
+        this.queryContext = queryContext;
+        this.knexDataManager = knexDataManager;
+        this.metricsAdapter = metricsAdapter;
+        this.constructionUtils = constructionUtils;
+    }
+    /**
+     * Authorization-result-based version of the EnforcingKnexEntityLoader method by the same name.
+     * @returns the first entity results that matches the query, where result error can be
+     *  UnauthorizedError
+     */
+    async loadFirstByFieldEqualityConjunctionAsync(fieldEqualityOperands, querySelectionModifiers) {
+        const results = await this.loadManyByFieldEqualityConjunctionAsync(fieldEqualityOperands, {
+            ...querySelectionModifiers,
+            limit: 1,
+        });
+        return results[0] ?? null;
+    }
+    /**
+     * Authorization-result-based version of the EnforcingKnexEntityLoader method by the same name.
+     * @returns array of entity results that match the query, where result error can be UnauthorizedError
+     */
+    async loadManyByFieldEqualityConjunctionAsync(fieldEqualityOperands, querySelectionModifiers = {}) {
+        for (const fieldEqualityOperand of fieldEqualityOperands) {
+            const fieldValues = (0, BasePostgresEntityDatabaseAdapter_1.isSingleValueFieldEqualityCondition)(fieldEqualityOperand)
+                ? [fieldEqualityOperand.fieldValue]
+                : fieldEqualityOperand.fieldValues;
+            this.constructionUtils.validateFieldAndValues(fieldEqualityOperand.fieldName, fieldValues);
+        }
+        const fieldObjects = await this.knexDataManager.loadManyByFieldEqualityConjunctionAsync(this.queryContext, fieldEqualityOperands, querySelectionModifiers);
+        return await this.constructionUtils.constructAndAuthorizeEntitiesArrayAsync(fieldObjects);
+    }
+    /**
+     * Authorization-result-based version of the EnforcingKnexEntityLoader method by the same name.
+     * @returns array of entity results that match the query, where result error can be UnauthorizedError
+     * @throws Error when rawWhereClause or bindings are invalid
+     *
+     * @deprecated Use loadManyBySQL instead for safer value bindings and more flexible query building.
+     */
+    async loadManyByRawWhereClauseAsync(rawWhereClause, bindings, querySelectionModifiers = {}) {
+        const fieldObjects = await this.knexDataManager.loadManyByRawWhereClauseAsync(this.queryContext, rawWhereClause, bindings, querySelectionModifiers);
+        return await this.constructionUtils.constructAndAuthorizeEntitiesArrayAsync(fieldObjects);
+    }
+    /**
+     * Authorization-result-based version of the EnforcingKnexEntityLoader method by the same name.
+     * @returns SQL query builder for building and executing SQL queries that when executed returns entity results where result error can be UnauthorizedError.
+     */
+    loadManyBySQL(fragment, modifiers = {}) {
+        return new AuthorizationResultBasedSQLQueryBuilder(this.knexDataManager, this.constructionUtils, this.queryContext, fragment, modifiers);
+    }
+    /**
+     * Load a page of entities with Relay-style cursor pagination using a unified pagination specification.
+     * Only returns successfully authorized entities for cursor stability; failed authorization results are filtered out.
+     *
+     * @returns Connection with only successfully authorized entities
+     */
+    async loadPageAsync(args) {
+        const pageResult = await this.knexDataManager.loadPageAsync(this.queryContext, args);
+        const edgeResults = await Promise.all(pageResult.edges.map(async (edge) => {
+            const entityResult = await this.constructionUtils.constructAndAuthorizeEntityAsync(edge.node);
+            if (!entityResult.ok) {
+                return null;
+            }
+            return {
+                ...edge,
+                node: entityResult.value,
+            };
+        }));
+        const edges = edgeResults.filter((edge) => edge !== null);
+        const pageInfo = {
+            ...pageResult.pageInfo,
+            startCursor: edges[0]?.cursor ?? null,
+            endCursor: edges[edges.length - 1]?.cursor ?? null,
+        };
+        return {
+            edges,
+            pageInfo,
+        };
+    }
+    /**
+     * Authorization-result-based version of the EnforcingKnexEntityLoader method by the same name.
+     * @returns The pagination cursor for the given entity.
+     */
+    getPaginationCursorForEntity(entity) {
+        return this.knexDataManager.getCursorForEntityID(entity.getID());
+    }
+}
+exports.AuthorizationResultBasedKnexEntityLoader = AuthorizationResultBasedKnexEntityLoader;
+/**
+ * SQL query builder implementation for AuthorizationResultBasedKnexEntityLoader.
+ */
+class AuthorizationResultBasedSQLQueryBuilder extends BaseSQLQueryBuilder_1.BaseSQLQueryBuilder {
+    knexDataManager;
+    constructionUtils;
+    queryContext;
+    constructor(knexDataManager, constructionUtils, queryContext, sqlFragment, modifiers) {
+        super(sqlFragment, modifiers);
+        this.knexDataManager = knexDataManager;
+        this.constructionUtils = constructionUtils;
+        this.queryContext = queryContext;
+    }
+    /**
+     * Execute the query and return results.
+     */
+    async executeInternalAsync() {
+        const fieldObjects = await this.knexDataManager.loadManyBySQLFragmentAsync(this.queryContext, this.getSQLFragment(), this.getModifiers());
+        return await this.constructionUtils.constructAndAuthorizeEntitiesArrayAsync(fieldObjects);
+    }
+}
+exports.AuthorizationResultBasedSQLQueryBuilder = AuthorizationResultBasedSQLQueryBuilder;
+//# sourceMappingURL=AuthorizationResultBasedKnexEntityLoader.js.map

package/build/src/AuthorizationResultBasedKnexEntityLoader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthorizationResultBasedKnexEntityLoader.js","sourceRoot":"","sources":["../../src/AuthorizationResultBasedKnexEntityLoader.ts"],"names":[],"mappings":"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"}

package/build/src/BasePostgresEntityDatabaseAdapter.d.ts

@@ -0,0 +1,150 @@
+import { EntityDatabaseAdapter, EntityQueryContext } from '@expo/entity';
+import { Knex } from 'knex';
+import { SQLFragment } from './SQLOperator';
+/**
+ * Equality operand that is used for selecting entities with a field with a single value.
+ */
+export interface SingleValueFieldEqualityCondition<TFields extends Record<string, any>, N extends keyof TFields = keyof TFields> {
+    fieldName: N;
+    fieldValue: TFields[N];
+}
+/**
+ * Equality operand that is used for selecting entities with a field matching one of multiple values.
+ */
+export interface MultiValueFieldEqualityCondition<TFields extends Record<string, any>, N extends keyof TFields = keyof TFields> {
+    fieldName: N;
+    fieldValues: readonly TFields[N][];
+}
+/**
+ * A single equality operand for use in a selection clause.
+ * See EntityLoader.loadManyByFieldEqualityConjunctionAsync documentation for examples.
+ */
+export type FieldEqualityCondition<TFields extends Record<string, any>, N extends keyof TFields = keyof TFields> = SingleValueFieldEqualityCondition<TFields, N> | MultiValueFieldEqualityCondition<TFields, N>;
+export declare function isSingleValueFieldEqualityCondition<TFields extends Record<string, any>, N extends keyof TFields = keyof TFields>(condition: FieldEqualityCondition<TFields, N>): condition is SingleValueFieldEqualityCondition<TFields, N>;
+export interface TableFieldSingleValueEqualityCondition {
+    tableField: string;
+    tableValue: any;
+}
+export interface TableFieldMultiValueEqualityCondition {
+    tableField: string;
+    tableValues: readonly any[];
+}
+export declare enum NullsOrdering {
+    FIRST = "first",
+    LAST = "last"
+}
+/**
+ * Ordering options for `orderBy` clauses.
+ */
+export declare enum OrderByOrdering {
+    /**
+     * Ascending order (lowest to highest).
+     * Ascending order puts smaller values first, where "smaller" is defined in terms of the %3C operator.
+     */
+    ASCENDING = "asc",
+    /**
+     * Descending order (highest to lowest).
+     * Descending order puts larger values first, where "larger" is defined in terms of the %3E operator.
+     */
+    DESCENDING = "desc"
+}
+export type PostgresOrderByClause<TFields extends Record<string, any>> = {
+    /**
+     * The field name to order by.
+     */
+    fieldName: keyof TFields;
+    /**
+     * The OrderByOrdering to order by.
+     */
+    order: OrderByOrdering;
+    /**
+     * Optional nulls ordering. If not provided, the database default is used
+     * (NULLS LAST for ASC, NULLS FIRST for DESC in PostgreSQL).
+     */
+    nulls?: NullsOrdering | undefined;
+} | {
+    /**
+     * A raw SQL fragment to order by. May not contain ASC or DESC, as ordering direction is determined by the `order` property.
+     */
+    fieldFragment: SQLFragment<TFields>;
+    /**
+     * The OrderByOrdering to order by.
+     */
+    order: OrderByOrdering;
+    /**
+     * Optional nulls ordering. If not provided, the database default is used
+     * (NULLS LAST for ASC, NULLS FIRST for DESC in PostgreSQL).
+     */
+    nulls?: NullsOrdering | undefined;
+};
+/**
+ * SQL modifiers that only affect the selection but not the projection.
+ */
+export interface PostgresQuerySelectionModifiers<TFields extends Record<string, any>> {
+    /**
+     * Order the entities by specified columns and orders.
+     */
+    orderBy?: readonly PostgresOrderByClause<TFields>[];
+    /**
+     * Skip the specified number of entities queried before returning.
+     */
+    offset?: number;
+    /**
+     * Limit the number of entities returned.
+     */
+    limit?: number;
+}
+export type TableOrderByClause<TFields extends Record<string, any>> = {
+    columnName: string;
+    order: OrderByOrdering;
+    nulls: NullsOrdering | undefined;
+} | {
+    columnFragment: SQLFragment<TFields>;
+    order: OrderByOrdering;
+    nulls: NullsOrdering | undefined;
+};
+export interface TableQuerySelectionModifiers<TFields extends Record<string, any>> {
+    orderBy: TableOrderByClause<TFields>[] | undefined;
+    offset: number | undefined;
+    limit: number | undefined;
+}
+export declare abstract class BasePostgresEntityDatabaseAdapter<TFields extends Record<string, any>, TIDField extends keyof TFields> extends EntityDatabaseAdapter<TFields, TIDField> {
+    /**
+     * Get the maximum page size for pagination.
+     * @returns maximum page size if configured, undefined otherwise
+     */
+    get paginationMaxPageSize(): number | undefined;
+    /**
+     * Fetch many objects matching the conjunction of where clauses constructed from
+     * specified field equality operands.
+     *
+     * @param queryContext - query context with which to perform the fetch
+     * @param fieldEqualityOperands - list of field equality where clause operand specifications
+     * @param querySelectionModifiers - limit, offset, orderBy, and orderByRaw for the query
+     * @returns array of objects matching the query
+     */
+    fetchManyByFieldEqualityConjunctionAsync<N extends keyof TFields>(queryContext: EntityQueryContext, fieldEqualityOperands: readonly FieldEqualityCondition<TFields, N>[], querySelectionModifiers: PostgresQuerySelectionModifiers<TFields>): Promise<readonly Readonly<TFields>[]>;
+    protected abstract fetchManyByFieldEqualityConjunctionInternalAsync(queryInterface: Knex, tableName: string, tableFieldSingleValueEqualityOperands: TableFieldSingleValueEqualityCondition[], tableFieldMultiValueEqualityOperands: TableFieldMultiValueEqualityCondition[], querySelectionModifiers: TableQuerySelectionModifiers<TFields>): Promise<object[]>;
+    /**
+     * Fetch many objects matching the raw WHERE clause.
+     *
+     * @param queryContext - query context with which to perform the fetch
+     * @param rawWhereClause - parameterized SQL WHERE clause with positional binding placeholders or named binding placeholders
+     * @param bindings - array of positional bindings or object of named bindings
+     * @param querySelectionModifiers - limit, offset, and orderBy for the query
+     * @returns array of objects matching the query
+     */
+    fetchManyByRawWhereClauseAsync(queryContext: EntityQueryContext, rawWhereClause: string, bindings: any[] | object, querySelectionModifiers: PostgresQuerySelectionModifiers<TFields>): Promise<readonly Readonly<TFields>[]>;
+    protected abstract fetchManyByRawWhereClauseInternalAsync(queryInterface: Knex, tableName: string, rawWhereClause: string, bindings: object | any[], querySelectionModifiers: TableQuerySelectionModifiers<TFields>): Promise<object[]>;
+    /**
+     * Fetch many objects matching the SQL fragment.
+     *
+     * @param queryContext - query context with which to perform the fetch
+     * @param sqlFragment - SQLFragment for the WHERE clause of the query
+     * @param querySelectionModifiers - limit, offset, and orderByFragment for the query
+     * @returns array of objects matching the query
+     */
+    fetchManyBySQLFragmentAsync(queryContext: EntityQueryContext, sqlFragment: SQLFragment<TFields>, querySelectionModifiers: PostgresQuerySelectionModifiers<TFields>): Promise<readonly Readonly<TFields>[]>;
+    protected abstract fetchManyBySQLFragmentInternalAsync(queryInterface: Knex, tableName: string, sqlFragment: SQLFragment<TFields>, querySelectionModifiers: TableQuerySelectionModifiers<TFields>): Promise<object[]>;
+    private convertToTableQueryModifiers;
+}