Skip to content

Commit 52b9604

Browse files
wschurmanwschurman
committed
feat: add count equivalent for knex loaer methods
1 parent 9b642b3 commit 52b9604

13 files changed

Lines changed: 518 additions & 18 deletions

‎packages/entity-database-adapter-knex-testing-utils/src/StubPostgresDatabaseAdapter.ts‎

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -201,6 +201,30 @@ export class StubPostgresDatabaseAdapter<
201201
throw new Error('SQL fragments not supported for StubDatabaseAdapter');
202202
}
203203

204+
protected async countByFieldEqualityConjunctionInternalAsync(
205+
queryInterface: any,
206+
tableName: string,
207+
tableFieldSingleValueEqualityOperands: TableFieldSingleValueEqualityCondition[],
208+
tableFieldMultiValueEqualityOperands: TableFieldMultiValueEqualityCondition[],
209+
): Promise<number> {
210+
const results = await this.fetchManyByFieldEqualityConjunctionInternalAsync(
211+
queryInterface,
212+
tableName,
213+
tableFieldSingleValueEqualityOperands,
214+
tableFieldMultiValueEqualityOperands,
215+
{ orderBy: undefined, offset: undefined, limit: undefined },
216+
);
217+
return results.length;
218+
}
219+
220+
protected countBySQLFragmentInternalAsync(
221+
_queryInterface: any,
222+
_tableName: string,
223+
_sqlFragment: SQLFragment<TFields>,
224+
): Promise<number> {
225+
throw new Error('SQL fragment count not supported for StubDatabaseAdapter');
226+
}
227+
204228
private generateRandomID(): any {
205229
const idSchemaField = this.entityConfiguration2.schema.get(this.entityConfiguration2.idField);
206230
invariant(

‎packages/entity-database-adapter-knex-testing-utils/src/__tests__/StubPostgresDatabaseAdapter-test.ts‎

Lines changed: 75 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -489,6 +489,81 @@ describe(StubPostgresDatabaseAdapter, () => {
489489
});
490490
});
491491

492+
describe('countByFieldEqualityConjunctionAsync', () => {
493+
it('counts matching records', async () => {
494+
const queryContext = instance(mock(EntityQueryContext));
495+
const databaseAdapter = new StubPostgresDatabaseAdapter<TestFields, 'customIdField'>(
496+
testEntityConfiguration,
497+
StubPostgresDatabaseAdapter.convertFieldObjectsToDataStore(
498+
testEntityConfiguration,
499+
new Map([
500+
[
501+
testEntityConfiguration.tableName,
502+
[
503+
{
504+
customIdField: 'hello',
505+
testIndexedField: 'h1',
506+
intField: 3,
507+
stringField: 'a',
508+
dateField: new Date(),
509+
nullableField: null,
510+
},
511+
{
512+
customIdField: 'world',
513+
testIndexedField: 'h2',
514+
intField: 3,
515+
stringField: 'b',
516+
dateField: new Date(),
517+
nullableField: null,
518+
},
519+
{
520+
customIdField: 'other',
521+
testIndexedField: 'h3',
522+
intField: 5,
523+
stringField: 'c',
524+
dateField: new Date(),
525+
nullableField: null,
526+
},
527+
],
528+
],
529+
]),
530+
),
531+
);
532+
533+
const count = await databaseAdapter.countByFieldEqualityConjunctionAsync(queryContext, [
534+
{ fieldName: 'intField', fieldValue: 3 },
535+
]);
536+
expect(count).toBe(2);
537+
538+
const countAll = await databaseAdapter.countByFieldEqualityConjunctionAsync(queryContext, []);
539+
expect(countAll).toBe(3);
540+
541+
const countMultiValue = await databaseAdapter.countByFieldEqualityConjunctionAsync(
542+
queryContext,
543+
[{ fieldName: 'customIdField', fieldValues: ['hello', 'world'] }],
544+
);
545+
expect(countMultiValue).toBe(2);
546+
547+
const countNone = await databaseAdapter.countByFieldEqualityConjunctionAsync(queryContext, [
548+
{ fieldName: 'intField', fieldValue: 999 },
549+
]);
550+
expect(countNone).toBe(0);
551+
});
552+
});
553+
554+
describe('countBySQLFragmentAsync', () => {
555+
it('throws because it is unsupported', async () => {
556+
const queryContext = instance(mock(EntityQueryContext));
557+
const databaseAdapter = new StubPostgresDatabaseAdapter<TestFields, 'customIdField'>(
558+
testEntityConfiguration,
559+
new Map(),
560+
);
561+
await expect(databaseAdapter.countBySQLFragmentAsync(queryContext, sql``)).rejects.toThrow(
562+
'SQL fragment count not supported for StubDatabaseAdapter',
563+
);
564+
});
565+
});
566+
492567
describe('fetchManyBySQLFragmentAsync', () => {
493568
it('throws because it is unsupported', async () => {
494569
const queryContext = instance(mock(EntityQueryContext));

‎packages/entity-database-adapter-knex/src/AuthorizationResultBasedKnexEntityLoader.ts‎

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -400,6 +400,38 @@ export class AuthorizationResultBasedKnexEntityLoader<
400400
return await this.constructionUtils.constructAndAuthorizeEntitiesArrayAsync(fieldObjects);
401401
}
402402

403+
/**
404+
* Count entities matching the conjunction of field equality operands.
405+
* This does not perform authorization since count does not load full entities.
406+
*
407+
* @returns count of entities matching the filters
408+
*/
409+
async countByFieldEqualityConjunctionAsync<N extends keyof Pick<TFields, TSelectedFields>>(
410+
fieldEqualityOperands: readonly FieldEqualityCondition<TFields, N>[],
411+
): Promise<number> {
412+
for (const fieldEqualityOperand of fieldEqualityOperands) {
413+
const fieldValues = isSingleValueFieldEqualityCondition(fieldEqualityOperand)
414+
? [fieldEqualityOperand.fieldValue]
415+
: fieldEqualityOperand.fieldValues;
416+
this.constructionUtils.validateFieldAndValues(fieldEqualityOperand.fieldName, fieldValues);
417+
}
418+
419+
return await this.knexDataManager.countByFieldEqualityConjunctionAsync(
420+
this.queryContext,
421+
fieldEqualityOperands,
422+
);
423+
}
424+
425+
/**
426+
* Count entities matching a SQL fragment.
427+
* This does not perform authorization since count does not load full entities.
428+
*
429+
* @returns count of entities matching the query
430+
*/
431+
async countBySQLAsync(fragment: SQLFragment<Pick<TFields, TSelectedFields>>): Promise<number> {
432+
return await this.knexDataManager.countBySQLFragmentAsync(this.queryContext, fragment);
433+
}
434+
403435
/**
404436
* Authorization-result-based version of the EnforcingKnexEntityLoader method by the same name.
405437
* @returns SQL query builder for building and executing SQL queries that when executed returns entity results where result error can be UnauthorizedError.

‎packages/entity-database-adapter-knex/src/BasePostgresEntityDatabaseAdapter.ts‎

Lines changed: 67 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -248,6 +248,73 @@ export abstract class BasePostgresEntityDatabaseAdapter<
248248
querySelectionModifiers: TableQuerySelectionModifiers<TFields>,
249249
): Promise<object[]>;
250250

251+
/**
252+
* Count objects matching the conjunction of where clauses constructed from
253+
* specified field equality operands.
254+
*
255+
* @param queryContext - query context with which to perform the count
256+
* @param fieldEqualityOperands - list of field equality where clause operand specifications
257+
* @returns count of objects matching the query
258+
*/
259+
async countByFieldEqualityConjunctionAsync<N extends keyof TFields>(
260+
queryContext: EntityQueryContext,
261+
fieldEqualityOperands: readonly FieldEqualityCondition<TFields, N>[],
262+
): Promise<number> {
263+
const tableFieldSingleValueOperands: TableFieldSingleValueEqualityCondition[] = [];
264+
const tableFieldMultipleValueOperands: TableFieldMultiValueEqualityCondition[] = [];
265+
for (const operand of fieldEqualityOperands) {
266+
if (isSingleValueFieldEqualityCondition(operand)) {
267+
tableFieldSingleValueOperands.push({
268+
tableField: getDatabaseFieldForEntityField(this.entityConfiguration, operand.fieldName),
269+
tableValue: operand.fieldValue,
270+
});
271+
} else {
272+
tableFieldMultipleValueOperands.push({
273+
tableField: getDatabaseFieldForEntityField(this.entityConfiguration, operand.fieldName),
274+
tableValues: operand.fieldValues,
275+
});
276+
}
277+
}
278+
279+
return await this.countByFieldEqualityConjunctionInternalAsync(
280+
queryContext.getQueryInterface(),
281+
this.entityConfiguration.tableName,
282+
tableFieldSingleValueOperands,
283+
tableFieldMultipleValueOperands,
284+
);
285+
}
286+
287+
protected abstract countByFieldEqualityConjunctionInternalAsync(
288+
queryInterface: Knex,
289+
tableName: string,
290+
tableFieldSingleValueEqualityOperands: TableFieldSingleValueEqualityCondition[],
291+
tableFieldMultiValueEqualityOperands: TableFieldMultiValueEqualityCondition[],
292+
): Promise<number>;
293+
294+
/**
295+
* Count objects matching the SQL fragment.
296+
*
297+
* @param queryContext - query context with which to perform the count
298+
* @param sqlFragment - SQLFragment for the WHERE clause of the query
299+
* @returns count of objects matching the query
300+
*/
301+
async countBySQLFragmentAsync(
302+
queryContext: EntityQueryContext,
303+
sqlFragment: SQLFragment<TFields>,
304+
): Promise<number> {
305+
return await this.countBySQLFragmentInternalAsync(
306+
queryContext.getQueryInterface(),
307+
this.entityConfiguration.tableName,
308+
sqlFragment,
309+
);
310+
}
311+
312+
protected abstract countBySQLFragmentInternalAsync(
313+
queryInterface: Knex,
314+
tableName: string,
315+
sqlFragment: SQLFragment<TFields>,
316+
): Promise<number>;
317+
251318
private convertToTableQueryModifiers(
252319
querySelectionModifiers: PostgresQuerySelectionModifiers<TFields>,
253320
): TableQuerySelectionModifiers<TFields> {

‎packages/entity-database-adapter-knex/src/EnforcingKnexEntityLoader.ts‎

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -104,6 +104,28 @@ export class EnforcingKnexEntityLoader<
104104
return entityResults.map((result) => result.enforceValue());
105105
}
106106

107+
/**
108+
* Count entities matching the conjunction of field equality operands.
109+
* This does not perform authorization since count does not load full entities.
110+
*
111+
* @returns count of entities matching the filters
112+
*/
113+
async countByFieldEqualityConjunctionAsync<N extends keyof Pick<TFields, TSelectedFields>>(
114+
fieldEqualityOperands: FieldEqualityCondition<TFields, N>[],
115+
): Promise<number> {
116+
return await this.knexEntityLoader.countByFieldEqualityConjunctionAsync(fieldEqualityOperands);
117+
}
118+
119+
/**
120+
* Count entities matching a SQL fragment.
121+
* This does not perform authorization since count does not load full entity rows.
122+
*
123+
* @returns count of entities matching the query
124+
*/
125+
async countBySQLAsync(fragment: SQLFragment<Pick<TFields, TSelectedFields>>): Promise<number> {
126+
return await this.knexEntityLoader.countBySQLAsync(fragment);
127+
}
128+
107129
/**
108130
* Load entities using a SQL query builder. When executed, all queries will enforce authorization and throw if not authorized.
109131
*

‎packages/entity-database-adapter-knex/src/PostgresEntityDatabaseAdapter.ts‎

Lines changed: 66 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -164,14 +164,12 @@ export class PostgresEntityDatabaseAdapter<
164164
return ret;
165165
}
166166

167-
protected async fetchManyByFieldEqualityConjunctionInternalAsync(
168-
queryInterface: Knex,
169-
tableName: string,
167+
private applyFieldEqualityConjunctionWhereClause(
168+
query: Knex.QueryBuilder,
170169
tableFieldSingleValueEqualityOperands: TableFieldSingleValueEqualityCondition[],
171170
tableFieldMultiValueEqualityOperands: TableFieldMultiValueEqualityCondition[],
172-
querySelectionModifiers: TableQuerySelectionModifiers<TFields>,
173-
): Promise<object[]> {
174-
let query = queryInterface.select().from(tableName);
171+
): Knex.QueryBuilder {
172+
let result = query;
175173

176174
if (tableFieldSingleValueEqualityOperands.length > 0) {
177175
const whereObject: { [key: string]: any } = {};
@@ -184,19 +182,19 @@ export class PostgresEntityDatabaseAdapter<
184182
for (const { tableField, tableValue } of nonNullTableFieldSingleValueEqualityOperands) {
185183
whereObject[tableField] = tableValue;
186184
}
187-
query = query.where(whereObject);
185+
result = result.where(whereObject);
188186
}
189187
if (nullTableFieldSingleValueEqualityOperands.length > 0) {
190188
for (const { tableField } of nullTableFieldSingleValueEqualityOperands) {
191-
query = query.whereNull(tableField);
189+
result = result.whereNull(tableField);
192190
}
193191
}
194192
}
195193

196194
if (tableFieldMultiValueEqualityOperands.length > 0) {
197195
for (const { tableField, tableValues } of tableFieldMultiValueEqualityOperands) {
198196
const nonNullTableValues = tableValues.filter((tableValue) => tableValue !== null);
199-
query = query.where((builder) => {
197+
result = result.where((builder) => {
200198
builder.whereRaw('?? = ANY(?)', [tableField, [...nonNullTableValues]]);
201199
// there was at least one null, allow null in this equality clause
202200
if (nonNullTableValues.length !== tableValues.length) {
@@ -206,29 +204,79 @@ export class PostgresEntityDatabaseAdapter<
206204
}
207205
}
208206

207+
return result;
208+
}
209+
210+
protected async fetchManyByFieldEqualityConjunctionInternalAsync(
211+
queryInterface: Knex,
212+
tableName: string,
213+
tableFieldSingleValueEqualityOperands: TableFieldSingleValueEqualityCondition[],
214+
tableFieldMultiValueEqualityOperands: TableFieldMultiValueEqualityCondition[],
215+
querySelectionModifiers: TableQuerySelectionModifiers<TFields>,
216+
): Promise<object[]> {
217+
let query = this.applyFieldEqualityConjunctionWhereClause(
218+
queryInterface.select().from(tableName),
219+
tableFieldSingleValueEqualityOperands,
220+
tableFieldMultiValueEqualityOperands,
221+
);
209222
query = this.applyQueryModifiersToQuery(query, querySelectionModifiers);
210223
return await wrapNativePostgresCallAsync(() => query);
211224
}
212225

226+
private applySQLFragmentWhereClause(
227+
query: Knex.QueryBuilder,
228+
sqlFragment: SQLFragment<TFields>,
229+
): Knex.QueryBuilder {
230+
return query.whereRaw(
231+
sqlFragment.sql,
232+
sqlFragment.getKnexBindings((fieldName) =>
233+
getDatabaseFieldForEntityField(this.entityConfiguration, fieldName),
234+
),
235+
);
236+
}
237+
213238
protected async fetchManyBySQLFragmentInternalAsync(
214239
queryInterface: Knex,
215240
tableName: string,
216241
sqlFragment: SQLFragment<TFields>,
217242
querySelectionModifiers: TableQuerySelectionModifiers<TFields>,
218243
): Promise<object[]> {
219-
let query = queryInterface
220-
.select()
221-
.from(tableName)
222-
.whereRaw(
223-
sqlFragment.sql,
224-
sqlFragment.getKnexBindings((fieldName) =>
225-
getDatabaseFieldForEntityField(this.entityConfiguration, fieldName),
226-
),
227-
);
244+
let query = this.applySQLFragmentWhereClause(
245+
queryInterface.select().from(tableName),
246+
sqlFragment,
247+
);
228248
query = this.applyQueryModifiersToQuery(query, querySelectionModifiers);
229249
return await wrapNativePostgresCallAsync(() => query);
230250
}
231251

252+
protected async countByFieldEqualityConjunctionInternalAsync(
253+
queryInterface: Knex,
254+
tableName: string,
255+
tableFieldSingleValueEqualityOperands: TableFieldSingleValueEqualityCondition[],
256+
tableFieldMultiValueEqualityOperands: TableFieldMultiValueEqualityCondition[],
257+
): Promise<number> {
258+
const query = this.applyFieldEqualityConjunctionWhereClause(
259+
queryInterface.count('* as count').from(tableName),
260+
tableFieldSingleValueEqualityOperands,
261+
tableFieldMultiValueEqualityOperands,
262+
);
263+
const result = await wrapNativePostgresCallAsync(() => query);
264+
return parseInt(String(result[0].count), 10);
265+
}
266+
267+
protected async countBySQLFragmentInternalAsync(
268+
queryInterface: Knex,
269+
tableName: string,
270+
sqlFragment: SQLFragment<TFields>,
271+
): Promise<number> {
272+
const query = this.applySQLFragmentWhereClause(
273+
queryInterface.count('* as count').from(tableName),
274+
sqlFragment,
275+
);
276+
const result = await wrapNativePostgresCallAsync(() => query);
277+
return parseInt(String(result[0].count), 10);
278+
}
279+
232280
protected async insertInternalAsync(
233281
queryInterface: Knex,
234282
tableName: string,

0 commit comments

Comments
 (0)