feat: Adds constructQuery.

Author: ryasmi

readme.md

@@ -38,10 +38,14 @@ const todosFacade = factory<TodoEntity>({
   constructFilter: (filter) => {
     return filter;
   },
+  // Optional property to construct an initial database query. Defaults to the function below.
+  constrctQuery: (table) => {
+    return table;
+  },
   // Optional property to convert an entity sort to a DB sort. Defaults to the function below.
   constructSort: (sort) => {
     return sort;
-  }.
+  },
   db: connectToDb({
     client: 'mysql',
     connection: {

src/FacadeConfig.ts

@@ -9,6 +9,7 @@ export default interface FacadeConfig<E extends Entity> {
   readonly constructDocument: (patch: Partial<E>) => Document;
   readonly constructEntity: (document: Document) => E;
   readonly constructFilter: (filter: Filter<E>) => any;
+  readonly constructQuery: (table: knex.QueryBuilder) => knex.QueryBuilder;
   readonly constructSort: (sort: Sort<E>) => any;
   readonly db: () => Promise<knex>;
   readonly defaultPaginationLimit: number;

src/FactoryConfig.ts

@@ -9,6 +9,7 @@ export default interface FacadeConfig<E extends Entity> {
   readonly constructDocument?: (patch: Partial<E>) => Document;
   readonly constructEntity?: (document: Document) => E;
   readonly constructFilter?: (filter: Filter<E>) => any;
+  readonly constructQuery?: (table: knex.QueryBuilder) => knex.QueryBuilder;
   readonly constructSort?: (sort: Sort<E>) => any;
   readonly db: () => Promise<knex>;
   readonly defaultPaginationLimit?: number;

src/factory.ts

@@ -19,6 +19,7 @@ export default <E extends Entity>(factoryConfig: FactoryConfig<E>): Facade<E> =>
       return document;
     },
     constructFilter: (filter) => filter,
+    constructQuery: (table) => table,
     constructSort: (sort) => sort,
     defaultPaginationLimit: 10,
     tableName: factoryConfig.entityName,

src/functions/countEntities.ts

@@ -6,8 +6,9 @@ import filterEntities from '../utils/filterEntities';
 export default <E extends Entity>(config: FacadeConfig<E>): CountEntities<E> => {
   return async ({ filter = {} }) => {
     const table = (await config.db()).table(config.tableName);
+    const query = config.constructQuery(table);
     const constructedFilter = config.constructFilter(filter);
-    const [result] = await Promise.resolve(filterEntities(table, constructedFilter).count());
+    const [result] = await Promise.resolve(filterEntities(query, constructedFilter).count());
     return { count: result['count(*)'] };
   };
 };

src/functions/createEntity.ts

@@ -8,9 +8,10 @@ const conflictErrorCode = 1062;
 export default <E extends Entity>(config: FacadeConfig<E>): CreateEntity<E> => {
   return async ({ id, entity }) => {
     const table = (await config.db()).table(config.tableName);
+    const query = config.constructQuery(table);
     const document = config.constructDocument({ ...entity as any, id });
     try {
-      await Promise.resolve(table.insert(document));
+      await Promise.resolve(query.insert(document));
     } catch (err) {
       if (err.errno === conflictErrorCode) {
         throw new ConflictingEntityError(config.entityName, id);

src/functions/getEntities.ts

@@ -24,6 +24,7 @@ export default <E extends Entity>(config: FacadeConfig<E>): GetEntities<E> => {
   const defaultSort = { id: asc } as Sort<E>;
   return async ({ filter = {}, sort = defaultSort, pagination = defaultPagination }) => {
     const table = (await config.db()).table(config.tableName);
+    const query = config.constructQuery(table);
     const paginationFilter = createPaginationFilter(pagination, sort);
     const fullFilter = { $and: [filter, paginationFilter] };
     const constructedFilter = config.constructFilter(fullFilter);
@@ -32,7 +33,7 @@ export default <E extends Entity>(config: FacadeConfig<E>): GetEntities<E> => {
       return !xor(pagination.direction === forward, sortOrder === asc) ? 'asc' : 'desc';
     });
 
-    const filterQuery = filterEntities(table, constructedFilter);
+    const filterQuery = filterEntities(query, constructedFilter);
     const sortQuery = Object.keys(knexSort).reduce((result, sortKey) => {
       return result.orderBy(sortKey, (knexSort as any)[sortKey]);
     }, filterQuery);

src/functions/getEntity.ts

@@ -8,8 +8,9 @@ import filterEntities from '../utils/filterEntities';
 export default <E extends Entity>(config: FacadeConfig<E>): GetEntity<E> => {
   return async ({ id, filter = {} }) => {
     const table = (await config.db()).table(config.tableName);
+    const query = config.constructQuery(table);
     const constructedFilter = constructIdFilter({ id, filter, config });
-    const document = await Promise.resolve(filterEntities(table, constructedFilter).first());
+    const document = await Promise.resolve(filterEntities(query, constructedFilter).first());
 
     if (document === undefined || document === null) {
       throw new MissingEntityError(config.entityName, id);

src/functions/patchEntity.ts

@@ -8,9 +8,10 @@ import getEntity from './getEntity';
 export default <E extends Entity>(config: FacadeConfig<E>): PatchEntity<E> => {
   return async ({ id, patch, filter = {} }) => {
     const table = (await config.db()).table(config.tableName);
+    const query = config.constructQuery(table);
     const document = config.constructDocument({ ...patch as any, id });
     const constructedFilter = constructIdFilter({ id, filter, config });
-    await Promise.resolve(filterEntities(table, constructedFilter).update(document));
+    await Promise.resolve(filterEntities(query, constructedFilter).update(document));
     return getEntity<E>(config)({ id, filter });
   };
 };

src/functions/removeEntities.ts

@@ -6,7 +6,8 @@ import filterEntities from '../utils/filterEntities';
 export default <E extends Entity>(config: FacadeConfig<E>): RemoveEntities<E> => {
   return async ({ filter = {} }) => {
     const table = (await config.db()).table(config.tableName);
+    const query = config.constructQuery(table);
     const constructedFilter = config.constructFilter(filter);
-    await Promise.resolve(filterEntities(table, constructedFilter).delete());
+    await Promise.resolve(filterEntities(query, constructedFilter).delete());
   };
 };