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

package/build/src/BasePostgresEntityDatabaseAdapter.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasePostgresEntityDatabaseAdapter = exports.OrderByOrdering = exports.NullsOrdering = void 0;
+exports.isSingleValueFieldEqualityCondition = isSingleValueFieldEqualityCondition;
+const entity_1 = require("@expo/entity");
+function isSingleValueFieldEqualityCondition(condition) {
+    return condition.fieldValue !== undefined;
+}
+var NullsOrdering;
+(function (NullsOrdering) {
+    NullsOrdering["FIRST"] = "first";
+    NullsOrdering["LAST"] = "last";
+})(NullsOrdering || (exports.NullsOrdering = NullsOrdering = {}));
+/**
+ * Ordering options for `orderBy` clauses.
+ */
+var OrderByOrdering;
+(function (OrderByOrdering) {
+    /**
+     * Ascending order (lowest to highest).
+     * Ascending order puts smaller values first, where "smaller" is defined in terms of the %3C operator.
+     */
+    OrderByOrdering["ASCENDING"] = "asc";
+    /**
+     * Descending order (highest to lowest).
+     * Descending order puts larger values first, where "larger" is defined in terms of the %3E operator.
+     */
+    OrderByOrdering["DESCENDING"] = "desc";
+})(OrderByOrdering || (exports.OrderByOrdering = OrderByOrdering = {}));
+class BasePostgresEntityDatabaseAdapter extends entity_1.EntityDatabaseAdapter {
+    /**
+     * Get the maximum page size for pagination.
+     * @returns maximum page size if configured, undefined otherwise
+     */
+    get paginationMaxPageSize() {
+        return 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
+     */
+    async fetchManyByFieldEqualityConjunctionAsync(queryContext, fieldEqualityOperands, querySelectionModifiers) {
+        const tableFieldSingleValueOperands = [];
+        const tableFieldMultipleValueOperands = [];
+        for (const operand of fieldEqualityOperands) {
+            if (isSingleValueFieldEqualityCondition(operand)) {
+                tableFieldSingleValueOperands.push({
+                    tableField: (0, entity_1.getDatabaseFieldForEntityField)(this.entityConfiguration, operand.fieldName),
+                    tableValue: operand.fieldValue,
+                });
+            }
+            else {
+                tableFieldMultipleValueOperands.push({
+                    tableField: (0, entity_1.getDatabaseFieldForEntityField)(this.entityConfiguration, operand.fieldName),
+                    tableValues: operand.fieldValues,
+                });
+            }
+        }
+        const results = await this.fetchManyByFieldEqualityConjunctionInternalAsync(queryContext.getQueryInterface(), this.entityConfiguration.tableName, tableFieldSingleValueOperands, tableFieldMultipleValueOperands, this.convertToTableQueryModifiers(querySelectionModifiers));
+        return results.map((result) => (0, entity_1.transformDatabaseObjectToFields)(this.entityConfiguration, this.fieldTransformerMap, result));
+    }
+    /**
+     * 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
+     */
+    async fetchManyByRawWhereClauseAsync(queryContext, rawWhereClause, bindings, querySelectionModifiers) {
+        const results = await this.fetchManyByRawWhereClauseInternalAsync(queryContext.getQueryInterface(), this.entityConfiguration.tableName, rawWhereClause, bindings, this.convertToTableQueryModifiers(querySelectionModifiers));
+        return results.map((result) => (0, entity_1.transformDatabaseObjectToFields)(this.entityConfiguration, this.fieldTransformerMap, result));
+    }
+    /**
+     * 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
+     */
+    async fetchManyBySQLFragmentAsync(queryContext, sqlFragment, querySelectionModifiers) {
+        const results = await this.fetchManyBySQLFragmentInternalAsync(queryContext.getQueryInterface(), this.entityConfiguration.tableName, sqlFragment, this.convertToTableQueryModifiers(querySelectionModifiers));
+        return results.map((result) => (0, entity_1.transformDatabaseObjectToFields)(this.entityConfiguration, this.fieldTransformerMap, result));
+    }
+    convertToTableQueryModifiers(querySelectionModifiers) {
+        const orderBy = querySelectionModifiers.orderBy;
+        return {
+            orderBy: orderBy !== undefined
+                ? orderBy.map((orderBySpecification) => {
+                    if ('fieldName' in orderBySpecification) {
+                        return {
+                            columnName: (0, entity_1.getDatabaseFieldForEntityField)(this.entityConfiguration, orderBySpecification.fieldName),
+                            order: orderBySpecification.order,
+                            nulls: orderBySpecification.nulls,
+                        };
+                    }
+                    else {
+                        return {
+                            columnFragment: orderBySpecification.fieldFragment,
+                            order: orderBySpecification.order,
+                            nulls: orderBySpecification.nulls,
+                        };
+                    }
+                })
+                : undefined,
+            offset: querySelectionModifiers.offset,
+            limit: querySelectionModifiers.limit,
+        };
+    }
+}
+exports.BasePostgresEntityDatabaseAdapter = BasePostgresEntityDatabaseAdapter;
+//# sourceMappingURL=BasePostgresEntityDatabaseAdapter.js.map

package/build/src/BasePostgresEntityDatabaseAdapter.js.map

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

package/build/src/BaseSQLQueryBuilder.d.ts

@@ -0,0 +1,61 @@
+import { EntityLoaderOrderByClause, EntityLoaderQuerySelectionModifiers } from './AuthorizationResultBasedKnexEntityLoader';
+import { NullsOrdering, OrderByOrdering } from './BasePostgresEntityDatabaseAdapter';
+import { SQLFragment } from './SQLOperator';
+/**
+ * Base SQL query builder that provides common functionality for building SQL queries.
+ */
+export declare abstract class BaseSQLQueryBuilder<TFields extends Record<string, any>, TSelectedFields extends keyof TFields, TResultType> {
+    private readonly sqlFragment;
+    private readonly modifiers;
+    private executed;
+    constructor(sqlFragment: SQLFragment<Pick<TFields, TSelectedFields>>, modifiers: {
+        limit?: number;
+        offset?: number;
+        orderBy?: readonly EntityLoaderOrderByClause<TFields, TSelectedFields>[];
+    });
+    /**
+     * Limit the number of results
+     */
+    limit(n: number): this;
+    /**
+     * Skip a number of results
+     */
+    offset(n: number): this;
+    /**
+     * Order by a field. Can be called multiple times to add multiple order bys.
+     */
+    orderBy(fieldName: TSelectedFields, order?: OrderByOrdering, nulls?: NullsOrdering | undefined): this;
+    /**
+     * Order by a SQL fragment expression.
+     * Provides type-safe, parameterized ORDER BY clauses
+     *
+     * @example
+     * ```ts
+     * query.orderByFragment(
+     *   sql`(data->>'createdAt')::timestamp`,
+     *   OrderByOrdering.DESCENDING,
+     * );
+     * // Generates ORDER BY clause that orders by the createdAt field in the JSONB data column, cast to a timestamp, in descending order.
+     * // Note that the SQL fragment is parameterized, so it is safe from SQL injection.
+     * // The generated SQL would look like: ORDER BY (data->>'createdAt')::timestamp DESC
+     * ```
+     *
+     * @param fragment - The SQL fragment to order by. Must not include the ASC/DESC keyword, as ordering direction is determined by the `order` parameter.
+     * @param order - The ordering direction (ascending or descending). Defaults to ascending.
+     */
+    orderBySQL(fragment: SQLFragment<Pick<TFields, TSelectedFields>>, order?: OrderByOrdering, nulls?: NullsOrdering | undefined): this;
+    /**
+     * Get the current modifiers as QuerySelectionModifiersWithOrderByFragment<TFields>
+     */
+    protected getModifiers(): EntityLoaderQuerySelectionModifiers<TFields, TSelectedFields>;
+    /**
+     * Get the SQL fragment
+     */
+    protected getSQLFragment(): SQLFragment<Pick<TFields, TSelectedFields>>;
+    /**
+     * Execute the query and return results.
+     * Implementation depends on the specific loader type.
+     */
+    executeAsync(): Promise<readonly TResultType[]>;
+    protected abstract executeInternalAsync(): Promise<readonly TResultType[]>;
+}

package/build/src/BaseSQLQueryBuilder.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSQLQueryBuilder = void 0;
+const BasePostgresEntityDatabaseAdapter_1 = require("./BasePostgresEntityDatabaseAdapter");
+/**
+ * Base SQL query builder that provides common functionality for building SQL queries.
+ */
+class BaseSQLQueryBuilder {
+    sqlFragment;
+    modifiers;
+    executed = false;
+    constructor(sqlFragment, modifiers) {
+        this.sqlFragment = sqlFragment;
+        this.modifiers = modifiers;
+    }
+    /**
+     * Limit the number of results
+     */
+    limit(n) {
+        this.modifiers.limit = n;
+        return this;
+    }
+    /**
+     * Skip a number of results
+     */
+    offset(n) {
+        this.modifiers.offset = n;
+        return this;
+    }
+    /**
+     * Order by a field. Can be called multiple times to add multiple order bys.
+     */
+    orderBy(fieldName, order = BasePostgresEntityDatabaseAdapter_1.OrderByOrdering.ASCENDING, nulls = undefined) {
+        this.modifiers.orderBy = [...(this.modifiers.orderBy ?? []), { fieldName, order, nulls }];
+        return this;
+    }
+    /**
+     * Order by a SQL fragment expression.
+     * Provides type-safe, parameterized ORDER BY clauses
+     *
+     * @example
+     * ```ts
+     * query.orderByFragment(
+     *   sql`(data->>'createdAt')::timestamp`,
+     *   OrderByOrdering.DESCENDING,
+     * );
+     * // Generates ORDER BY clause that orders by the createdAt field in the JSONB data column, cast to a timestamp, in descending order.
+     * // Note that the SQL fragment is parameterized, so it is safe from SQL injection.
+     * // The generated SQL would look like: ORDER BY (data->>'createdAt')::timestamp DESC
+     * ```
+     *
+     * @param fragment - The SQL fragment to order by. Must not include the ASC/DESC keyword, as ordering direction is determined by the `order` parameter.
+     * @param order - The ordering direction (ascending or descending). Defaults to ascending.
+     */
+    orderBySQL(fragment, order = BasePostgresEntityDatabaseAdapter_1.OrderByOrdering.ASCENDING, nulls = undefined) {
+        this.modifiers.orderBy = [
+            ...(this.modifiers.orderBy ?? []),
+            { fieldFragment: fragment, order, nulls },
+        ];
+        return this;
+    }
+    /**
+     * Get the current modifiers as QuerySelectionModifiersWithOrderByFragment<TFields>
+     */
+    getModifiers() {
+        return this.modifiers;
+    }
+    /**
+     * Get the SQL fragment
+     */
+    getSQLFragment() {
+        return this.sqlFragment;
+    }
+    /**
+     * Execute the query and return results.
+     * Implementation depends on the specific loader type.
+     */
+    async executeAsync() {
+        if (this.executed) {
+            throw new Error('Query has already been executed. Create a new query builder to execute again.');
+        }
+        this.executed = true;
+        return await this.executeInternalAsync();
+    }
+}
+exports.BaseSQLQueryBuilder = BaseSQLQueryBuilder;
+//# sourceMappingURL=BaseSQLQueryBuilder.js.map

package/build/src/BaseSQLQueryBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseSQLQueryBuilder.js","sourceRoot":"","sources":["../../src/BaseSQLQueryBuilder.ts"],"names":[],"mappings":";;;AAIA,2FAAqF;AAGrF;;GAEG;AACH,MAAsB,mBAAmB;IAQpB;IACA;IAJX,QAAQ,GAAG,KAAK,CAAC;IAEzB,YACmB,WAAwD,EACxD,SAIhB;QALgB,gBAAW,GAAX,WAAW,CAA6C;QACxD,cAAS,GAAT,SAAS,CAIzB;IACA,CAAC;IAEJ;;OAEG;IACH,KAAK,CAAC,CAAS;QACb,IAAI,CAAC,SAAS,CAAC,KAAK,GAAG,CAAC,CAAC;QACzB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,CAAS;QACd,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC;QAC1B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,OAAO,CACL,SAA0B,EAC1B,QAAyB,mDAAe,CAAC,SAAS,EAClD,QAAmC,SAAS;QAE5C,IAAI,CAAC,SAAS,CAAC,OAAO,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,IAAI,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;QAC1F,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,UAAU,CACR,QAAqD,EACrD,QAAyB,mDAAe,CAAC,SAAS,EAClD,QAAmC,SAAS;QAE5C,IAAI,CAAC,SAAS,CAAC,OAAO,GAAG;YACvB,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,IAAI,EAAE,CAAC;YACjC,EAAE,aAAa,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE;SAC1C,CAAC;QACF,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACO,YAAY;QACpB,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED;;OAEG;IACO,cAAc;QACtB,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,YAAY;QACvB,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAClB,MAAM,IAAI,KAAK,CACb,+EAA+E,CAChF,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,OAAO,MAAM,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAC3C,CAAC;CAGF;AAvGD,kDAuGC"}

package/build/src/EnforcingKnexEntityLoader.d.ts

@@ -0,0 +1,124 @@
+import { EntityConstructionUtils, EntityPrivacyPolicy, EntityQueryContext, IEntityMetricsAdapter, ReadonlyEntity, ViewerContext } from '@expo/entity';
+import { AuthorizationResultBasedKnexEntityLoader, EntityLoaderLoadPageArgs, EntityLoaderQuerySelectionModifiers } from './AuthorizationResultBasedKnexEntityLoader';
+import { FieldEqualityCondition } from './BasePostgresEntityDatabaseAdapter';
+import { BaseSQLQueryBuilder } from './BaseSQLQueryBuilder';
+import { SQLFragment } from './SQLOperator';
+import type { Connection, EntityKnexDataManager } from './internal/EntityKnexDataManager';
+/**
+ * Enforcing knex entity loader for non-data-loader-based load methods.
+ * All loads through this loader will throw if the load is not successful.
+ */
+export declare class EnforcingKnexEntityLoader<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> {
+    private readonly knexEntityLoader;
+    private readonly queryContext;
+    private readonly knexDataManager;
+    protected readonly metricsAdapter: IEntityMetricsAdapter;
+    private readonly constructionUtils;
+    constructor(knexEntityLoader: AuthorizationResultBasedKnexEntityLoader<TFields, TIDField, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields>, queryContext: EntityQueryContext, knexDataManager: EntityKnexDataManager<TFields, TIDField>, metricsAdapter: IEntityMetricsAdapter, constructionUtils: EntityConstructionUtils<TFields, TIDField, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields>);
+    /**
+     * Load the first entity matching the conjunction of field equality operands and
+     * query modifiers.
+     *
+     * This is a convenience method for {@link loadManyByFieldEqualityConjunctionAsync}. However, the
+     * orderBy query modifier is required to ensure consistent results if more than one entity matches
+     * the filters.
+     *
+     * @throws EntityNotAuthorizedError if viewer is not authorized to view the entity
+     * @returns the first entity matching the filters, or null if none match
+     */
+    loadFirstByFieldEqualityConjunctionAsync<N extends keyof Pick<TFields, TSelectedFields>>(fieldEqualityOperands: FieldEqualityCondition<TFields, N>[], querySelectionModifiers: Omit<EntityLoaderQuerySelectionModifiers<TFields, TSelectedFields>, 'limit'> & Required<Pick<EntityLoaderQuerySelectionModifiers<TFields, TSelectedFields>, 'orderBy'>>): Promise<TEntity | null>;
+    /**
+     * Load entities matching the conjunction of field equality operands and
+     * query modifiers.
+     *
+     * Typically this is used for complex queries that cannot be expressed through simpler
+     * convenience methods such as {@link loadManyByFieldEqualingAsync}.
+     *
+     * @throws EntityNotAuthorizedError if viewer is not authorized to view the entity
+     * @returns entities matching the filters
+     */
+    loadManyByFieldEqualityConjunctionAsync<N extends keyof Pick<TFields, TSelectedFields>>(fieldEqualityOperands: FieldEqualityCondition<TFields, N>[], querySelectionModifiers?: EntityLoaderQuerySelectionModifiers<TFields, TSelectedFields>): Promise<readonly TEntity[]>;
+    /**
+     * Load entities with a raw SQL WHERE clause.
+     *
+     * @example
+     * Load entities with SQL function
+     * ```typescript
+     * const entitiesWithJsonKey = await ExampleEntity.loader(vc)
+     *   .loadManyByRawWhereClauseAsync(
+     *     "json_column->>'key_name' = ?",
+     *     ['value'],
+     *   );
+     * ```
+     *
+     * @example
+     * Load entities with tuple matching
+     * ```typescript
+     * const entities = await ExampleEntity.loader(vc)
+     *   .loadManyByRawWhereClauseAsync(
+     *     '(column_1, column_2) IN ((?, ?), (?, ?))',
+     *     [value1, value2, value3, value4],
+     *   );
+     * ```
+     * @param rawWhereClause - SQL WHERE clause. Interpolated values should be specified as ?-placeholders or :key_name
+     * @param bindings - values to bind to the placeholders in the WHERE clause
+     * @param querySelectionModifiers - limit, offset, and orderBy for the query.
+     * @returns entities matching the WHERE clause
+     * @throws EntityNotAuthorizedError when viewer is not authorized to view one or more of the returned entities
+     * @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 TEntity[]>;
+    /**
+     * Load entities using a SQL query builder. When executed, all queries will enforce authorization and throw if not authorized.
+     *
+     * @example
+     * ```ts
+     * const entities = await ExampleEntity.loader(vc)
+     *   .loadManyBySQL(sql`age >= ${18} AND status = ${'active'}`)
+     *   .orderBy('createdAt', 'DESC')
+     *   .limit(10)
+     *   .executeAsync();
+     *
+     * const { between, inArray } = SQLFragmentHelpers;
+     * const filtered = await ExampleEntity.loader(vc)
+     *   .loadManyBySQL(
+     *     sql`${between('age', 18, 65)} AND ${inArray('role', ['admin', 'moderator'])}`
+     *   )
+     *   .executeAsync();
+     * ```
+     */
+    loadManyBySQL(fragment: SQLFragment<Pick<TFields, TSelectedFields>>, modifiers?: EntityLoaderQuerySelectionModifiers<TFields, TSelectedFields>): EnforcingSQLQueryBuilder<TFields, TIDField, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields>;
+    /**
+     * Load a page of entities with Relay-style cursor pagination.
+     *
+     * @param args - Pagination arguments with pagination and either first/after or last/before
+     * @returns a page of entities matching the pagination arguments
+     * @throws EntityNotAuthorizedError if viewer is not authorized to view any returned entity
+     */
+    loadPageAsync(args: EntityLoaderLoadPageArgs<TFields, TSelectedFields>): Promise<Connection<TEntity>>;
+    /**
+     * Get cursor for a given entity that matches what loadPageAsync would produce.
+     * Useful for constructing pagination cursors for entities returned from other loader methods that can then be passed to loadPageAsync for pagination.
+     * Most commonly used for testing pagination behavior.
+     *
+     * @param entity - The entity to get the pagination cursor for.
+     * @returns The pagination cursor for the given entity.
+     */
+    getPaginationCursorForEntity(entity: TEntity): string;
+}
+/**
+ * SQL query builder for EnforcingKnexEntityLoader.
+ * Provides a fluent API for building and executing SQL queries with enforced authorization.
+ */
+export declare class EnforcingSQLQueryBuilder<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, TEntity> {
+    private readonly knexEntityLoader;
+    constructor(knexEntityLoader: AuthorizationResultBasedKnexEntityLoader<TFields, TIDField, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields>, sqlFragment: SQLFragment<Pick<TFields, TSelectedFields>>, modifiers: EntityLoaderQuerySelectionModifiers<TFields, TSelectedFields>);
+    /**
+     * Execute the query.
+     * @returns entities matching the query
+     * @throws EntityNotAuthorizedError if viewer is not authorized to view any entity
+     */
+    executeInternalAsync(): Promise<readonly TEntity[]>;
+}

package/build/src/EnforcingKnexEntityLoader.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnforcingSQLQueryBuilder = exports.EnforcingKnexEntityLoader = void 0;
+const BaseSQLQueryBuilder_1 = require("./BaseSQLQueryBuilder");
+/**
+ * Enforcing knex entity loader for non-data-loader-based load methods.
+ * All loads through this loader will throw if the load is not successful.
+ */
+class EnforcingKnexEntityLoader {
+    knexEntityLoader;
+    queryContext;
+    knexDataManager;
+    metricsAdapter;
+    constructionUtils;
+    constructor(knexEntityLoader, queryContext, knexDataManager, metricsAdapter, constructionUtils) {
+        this.knexEntityLoader = knexEntityLoader;
+        this.queryContext = queryContext;
+        this.knexDataManager = knexDataManager;
+        this.metricsAdapter = metricsAdapter;
+        this.constructionUtils = constructionUtils;
+    }
+    /**
+     * Load the first entity matching the conjunction of field equality operands and
+     * query modifiers.
+     *
+     * This is a convenience method for {@link loadManyByFieldEqualityConjunctionAsync}. However, the
+     * orderBy query modifier is required to ensure consistent results if more than one entity matches
+     * the filters.
+     *
+     * @throws EntityNotAuthorizedError if viewer is not authorized to view the entity
+     * @returns the first entity matching the filters, or null if none match
+     */
+    async loadFirstByFieldEqualityConjunctionAsync(fieldEqualityOperands, querySelectionModifiers) {
+        const entityResult = await this.knexEntityLoader.loadFirstByFieldEqualityConjunctionAsync(fieldEqualityOperands, querySelectionModifiers);
+        return entityResult?.enforceValue() ?? null;
+    }
+    /**
+     * Load entities matching the conjunction of field equality operands and
+     * query modifiers.
+     *
+     * Typically this is used for complex queries that cannot be expressed through simpler
+     * convenience methods such as {@link loadManyByFieldEqualingAsync}.
+     *
+     * @throws EntityNotAuthorizedError if viewer is not authorized to view the entity
+     * @returns entities matching the filters
+     */
+    async loadManyByFieldEqualityConjunctionAsync(fieldEqualityOperands, querySelectionModifiers = {}) {
+        const entityResults = await this.knexEntityLoader.loadManyByFieldEqualityConjunctionAsync(fieldEqualityOperands, querySelectionModifiers);
+        return entityResults.map((result) => result.enforceValue());
+    }
+    /**
+     * Load entities with a raw SQL WHERE clause.
+     *
+     * @example
+     * Load entities with SQL function
+     * ```typescript
+     * const entitiesWithJsonKey = await ExampleEntity.loader(vc)
+     *   .loadManyByRawWhereClauseAsync(
+     *     "json_column->>'key_name' = ?",
+     *     ['value'],
+     *   );
+     * ```
+     *
+     * @example
+     * Load entities with tuple matching
+     * ```typescript
+     * const entities = await ExampleEntity.loader(vc)
+     *   .loadManyByRawWhereClauseAsync(
+     *     '(column_1, column_2) IN ((?, ?), (?, ?))',
+     *     [value1, value2, value3, value4],
+     *   );
+     * ```
+     * @param rawWhereClause - SQL WHERE clause. Interpolated values should be specified as ?-placeholders or :key_name
+     * @param bindings - values to bind to the placeholders in the WHERE clause
+     * @param querySelectionModifiers - limit, offset, and orderBy for the query.
+     * @returns entities matching the WHERE clause
+     * @throws EntityNotAuthorizedError when viewer is not authorized to view one or more of the returned entities
+     * @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 entityResults = await this.knexEntityLoader.loadManyByRawWhereClauseAsync(rawWhereClause, bindings, querySelectionModifiers);
+        return entityResults.map((result) => result.enforceValue());
+    }
+    /**
+     * Load entities using a SQL query builder. When executed, all queries will enforce authorization and throw if not authorized.
+     *
+     * @example
+     * ```ts
+     * const entities = await ExampleEntity.loader(vc)
+     *   .loadManyBySQL(sql`age >= ${18} AND status = ${'active'}`)
+     *   .orderBy('createdAt', 'DESC')
+     *   .limit(10)
+     *   .executeAsync();
+     *
+     * const { between, inArray } = SQLFragmentHelpers;
+     * const filtered = await ExampleEntity.loader(vc)
+     *   .loadManyBySQL(
+     *     sql`${between('age', 18, 65)} AND ${inArray('role', ['admin', 'moderator'])}`
+     *   )
+     *   .executeAsync();
+     * ```
+     */
+    loadManyBySQL(fragment, modifiers = {}) {
+        return new EnforcingSQLQueryBuilder(this.knexEntityLoader, fragment, modifiers);
+    }
+    /**
+     * Load a page of entities with Relay-style cursor pagination.
+     *
+     * @param args - Pagination arguments with pagination and either first/after or last/before
+     * @returns a page of entities matching the pagination arguments
+     * @throws EntityNotAuthorizedError if viewer is not authorized to view any returned entity
+     */
+    async loadPageAsync(args) {
+        const pageResult = await this.knexDataManager.loadPageAsync(this.queryContext, args);
+        const edges = await Promise.all(pageResult.edges.map(async (edge) => {
+            const entityResult = await this.constructionUtils.constructAndAuthorizeEntityAsync(edge.node);
+            const entity = entityResult.enforceValue();
+            return {
+                ...edge,
+                node: entity,
+            };
+        }));
+        return {
+            edges,
+            pageInfo: pageResult.pageInfo,
+        };
+    }
+    /**
+     * Get cursor for a given entity that matches what loadPageAsync would produce.
+     * Useful for constructing pagination cursors for entities returned from other loader methods that can then be passed to loadPageAsync for pagination.
+     * Most commonly used for testing pagination behavior.
+     *
+     * @param entity - The entity to get the pagination cursor for.
+     * @returns The pagination cursor for the given entity.
+     */
+    getPaginationCursorForEntity(entity) {
+        return this.knexEntityLoader.getPaginationCursorForEntity(entity);
+    }
+}
+exports.EnforcingKnexEntityLoader = EnforcingKnexEntityLoader;
+/**
+ * SQL query builder for EnforcingKnexEntityLoader.
+ * Provides a fluent API for building and executing SQL queries with enforced authorization.
+ */
+class EnforcingSQLQueryBuilder extends BaseSQLQueryBuilder_1.BaseSQLQueryBuilder {
+    knexEntityLoader;
+    constructor(knexEntityLoader, sqlFragment, modifiers) {
+        super(sqlFragment, modifiers);
+        this.knexEntityLoader = knexEntityLoader;
+    }
+    /**
+     * Execute the query.
+     * @returns entities matching the query
+     * @throws EntityNotAuthorizedError if viewer is not authorized to view any entity
+     */
+    async executeInternalAsync() {
+        const entityResults = await this.knexEntityLoader
+            .loadManyBySQL(this.getSQLFragment(), this.getModifiers())
+            .executeAsync();
+        return entityResults.map((result) => result.enforceValue());
+    }
+}
+exports.EnforcingSQLQueryBuilder = EnforcingSQLQueryBuilder;
+//# sourceMappingURL=EnforcingKnexEntityLoader.js.map

package/build/src/EnforcingKnexEntityLoader.js.map

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

package/build/src/KnexEntityLoaderFactory.d.ts

@@ -0,0 +1,25 @@
+import { EntityCompanion, EntityPrivacyPolicy, EntityPrivacyPolicyEvaluationContext, EntityQueryContext, ReadonlyEntity, ViewerContext, IEntityMetricsAdapter } from '@expo/entity';
+import { AuthorizationResultBasedKnexEntityLoader } from './AuthorizationResultBasedKnexEntityLoader';
+import { EnforcingKnexEntityLoader } from './EnforcingKnexEntityLoader';
+import { EntityKnexDataManager } from './internal/EntityKnexDataManager';
+/**
+ * The primary entry point for loading entities via knex queries (non-data-loader methods).
+ */
+export declare class KnexEntityLoaderFactory<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> {
+    private readonly entityCompanion;
+    private readonly knexDataManager;
+    protected readonly metricsAdapter: IEntityMetricsAdapter;
+    constructor(entityCompanion: EntityCompanion<TFields, TIDField, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields>, knexDataManager: EntityKnexDataManager<TFields, TIDField>, metricsAdapter: IEntityMetricsAdapter);
+    /**
+     * Vend knex loader for loading an entity in a given query context.
+     * @param viewerContext - viewer context of loading user
+     * @param queryContext - query context in which to perform the load
+     */
+    forLoad(viewerContext: TViewerContext, queryContext: EntityQueryContext, privacyPolicyEvaluationContext: EntityPrivacyPolicyEvaluationContext<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>): AuthorizationResultBasedKnexEntityLoader<TFields, TIDField, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields>;
+    /**
+     * Vend enforcing knex loader for loading an entity in a given query context.
+     * @param viewerContext - viewer context of loading user
+     * @param queryContext - query context in which to perform the load
+     */
+    forLoadEnforcing(viewerContext: TViewerContext, queryContext: EntityQueryContext, privacyPolicyEvaluationContext: EntityPrivacyPolicyEvaluationContext<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>): EnforcingKnexEntityLoader<TFields, TIDField, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields>;
+}

package/build/src/KnexEntityLoaderFactory.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnexEntityLoaderFactory = void 0;
+const entity_1 = require("@expo/entity");
+const AuthorizationResultBasedKnexEntityLoader_1 = require("./AuthorizationResultBasedKnexEntityLoader");
+const EnforcingKnexEntityLoader_1 = require("./EnforcingKnexEntityLoader");
+/**
+ * The primary entry point for loading entities via knex queries (non-data-loader methods).
+ */
+class KnexEntityLoaderFactory {
+    entityCompanion;
+    knexDataManager;
+    metricsAdapter;
+    constructor(entityCompanion, knexDataManager, metricsAdapter) {
+        this.entityCompanion = entityCompanion;
+        this.knexDataManager = knexDataManager;
+        this.metricsAdapter = metricsAdapter;
+    }
+    /**
+     * Vend knex loader for loading an entity in a given query context.
+     * @param viewerContext - viewer context of loading user
+     * @param queryContext - query context in which to perform the load
+     */
+    forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext) {
+        const constructionUtils = new entity_1.EntityConstructionUtils(viewerContext, queryContext, privacyPolicyEvaluationContext, this.entityCompanion.entityCompanionDefinition.entityConfiguration, this.entityCompanion.entityCompanionDefinition.entityClass, this.entityCompanion.entityCompanionDefinition.entitySelectedFields, this.entityCompanion.privacyPolicy, this.metricsAdapter);
+        return new AuthorizationResultBasedKnexEntityLoader_1.AuthorizationResultBasedKnexEntityLoader(queryContext, this.knexDataManager, this.metricsAdapter, constructionUtils);
+    }
+    /**
+     * Vend enforcing knex loader for loading an entity in a given query context.
+     * @param viewerContext - viewer context of loading user
+     * @param queryContext - query context in which to perform the load
+     */
+    forLoadEnforcing(viewerContext, queryContext, privacyPolicyEvaluationContext) {
+        const constructionUtils = new entity_1.EntityConstructionUtils(viewerContext, queryContext, privacyPolicyEvaluationContext, this.entityCompanion.entityCompanionDefinition.entityConfiguration, this.entityCompanion.entityCompanionDefinition.entityClass, this.entityCompanion.entityCompanionDefinition.entitySelectedFields, this.entityCompanion.privacyPolicy, this.metricsAdapter);
+        return new EnforcingKnexEntityLoader_1.EnforcingKnexEntityLoader(this.forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext), queryContext, this.knexDataManager, this.metricsAdapter, constructionUtils);
+    }
+}
+exports.KnexEntityLoaderFactory = KnexEntityLoaderFactory;
+//# sourceMappingURL=KnexEntityLoaderFactory.js.map

package/build/src/KnexEntityLoaderFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KnexEntityLoaderFactory.js","sourceRoot":"","sources":["../../src/KnexEntityLoaderFactory.ts"],"names":[],"mappings":";;;AAAA,yCASsB;AAEtB,yGAAsG;AACtG,2EAAwE;AAGxE;;GAEG;AACH,MAAa,uBAAuB;IAef;IAQA;IACE;IAVrB,YACmB,eAOhB,EACgB,eAAyD,EACvD,cAAqC;QATvC,oBAAe,GAAf,eAAe,CAO/B;QACgB,oBAAe,GAAf,eAAe,CAA0C;QACvD,mBAAc,GAAd,cAAc,CAAuB;IACvD,CAAC;IAEJ;;;;OAIG;IACH,OAAO,CACL,aAA6B,EAC7B,YAAgC,EAChC,8BAMC;QASD,MAAM,iBAAiB,GAAG,IAAI,gCAAuB,CACnD,aAAa,EACb,YAAY,EACZ,8BAA8B,EAC9B,IAAI,CAAC,eAAe,CAAC,yBAAyB,CAAC,mBAAmB,EAClE,IAAI,CAAC,eAAe,CAAC,yBAAyB,CAAC,WAAW,EAC1D,IAAI,CAAC,eAAe,CAAC,yBAAyB,CAAC,oBAAoB,EACnE,IAAI,CAAC,eAAe,CAAC,aAAa,EAClC,IAAI,CAAC,cAAc,CACpB,CAAC;QAEF,OAAO,IAAI,mFAAwC,CACjD,YAAY,EACZ,IAAI,CAAC,eAAe,EACpB,IAAI,CAAC,cAAc,EACnB,iBAAiB,CAClB,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,gBAAgB,CACd,aAA6B,EAC7B,YAAgC,EAChC,8BAMC;QASD,MAAM,iBAAiB,GAAG,IAAI,gCAAuB,CACnD,aAAa,EACb,YAAY,EACZ,8BAA8B,EAC9B,IAAI,CAAC,eAAe,CAAC,yBAAyB,CAAC,mBAAmB,EAClE,IAAI,CAAC,eAAe,CAAC,yBAAyB,CAAC,WAAW,EAC1D,IAAI,CAAC,eAAe,CAAC,yBAAyB,CAAC,oBAAoB,EACnE,IAAI,CAAC,eAAe,CAAC,aAAa,EAClC,IAAI,CAAC,cAAc,CACpB,CAAC;QAEF,OAAO,IAAI,qDAAyB,CAClC,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,YAAY,EAAE,8BAA8B,CAAC,EACzE,YAAY,EACZ,IAAI,CAAC,eAAe,EACpB,IAAI,CAAC,cAAc,EACnB,iBAAiB,CAClB,CAAC;IACJ,CAAC;CACF;AA/GD,0DA+GC"}