chore: Move knex-specific database adapter code out of EntityDatabaseAdapter

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

@@ -2,10 +2,6 @@ import {
   EntityDatabaseAdapter,
   FieldTransformer,
   FieldTransformerMap,
-  TableFieldMultiValueEqualityCondition,
-  TableFieldSingleValueEqualityCondition,
-  TableQuerySelectionModifiers,
-  TableQuerySelectionModifiersWithOrderByRaw,
 } from '@expo/entity';
 import { Knex } from 'knex';
 
@@ -86,106 +82,6 @@ export class PostgresEntityDatabaseAdapter<
     );
   }
 
-  private applyQueryModifiersToQueryOrderByRaw(
-    query: Knex.QueryBuilder,
-    querySelectionModifiers: TableQuerySelectionModifiersWithOrderByRaw,
-  ): Knex.QueryBuilder {
-    let ret = this.applyQueryModifiersToQuery(query, querySelectionModifiers);
-
-    const { orderByRaw } = querySelectionModifiers;
-    if (orderByRaw !== undefined) {
-      ret = ret.orderByRaw(orderByRaw);
-    }
-
-    return ret;
-  }
-
-  private applyQueryModifiersToQuery(
-    query: Knex.QueryBuilder,
-    querySelectionModifiers: TableQuerySelectionModifiers,
-  ): Knex.QueryBuilder {
-    const { orderBy, offset, limit } = querySelectionModifiers;
-
-    let ret = query;
-
-    if (orderBy !== undefined) {
-      for (const orderBySpecification of orderBy) {
-        ret = ret.orderBy(orderBySpecification.columnName, orderBySpecification.order);
-      }
-    }
-
-    if (offset !== undefined) {
-      ret = ret.offset(offset);
-    }
-
-    if (limit !== undefined) {
-      ret = ret.limit(limit);
-    }
-
-    return ret;
-  }
-
-  protected async fetchManyByFieldEqualityConjunctionInternalAsync(
-    queryInterface: Knex,
-    tableName: string,
-    tableFieldSingleValueEqualityOperands: TableFieldSingleValueEqualityCondition[],
-    tableFieldMultiValueEqualityOperands: TableFieldMultiValueEqualityCondition[],
-    querySelectionModifiers: TableQuerySelectionModifiers,
-  ): Promise<object[]> {
-    let query = queryInterface.select().from(tableName);
-
-    if (tableFieldSingleValueEqualityOperands.length > 0) {
-      const whereObject: { [key: string]: any } = {};
-      const nonNullTableFieldSingleValueEqualityOperands =
-        tableFieldSingleValueEqualityOperands.filter(({ tableValue }) => tableValue !== null);
-      const nullTableFieldSingleValueEqualityOperands =
-        tableFieldSingleValueEqualityOperands.filter(({ tableValue }) => tableValue === null);
-
-      if (nonNullTableFieldSingleValueEqualityOperands.length > 0) {
-        for (const { tableField, tableValue } of nonNullTableFieldSingleValueEqualityOperands) {
-          whereObject[tableField] = tableValue;
-        }
-        query = query.where(whereObject);
-      }
-      if (nullTableFieldSingleValueEqualityOperands.length > 0) {
-        for (const { tableField } of nullTableFieldSingleValueEqualityOperands) {
-          query = query.whereNull(tableField);
-        }
-      }
-    }
-
-    if (tableFieldMultiValueEqualityOperands.length > 0) {
-      for (const { tableField, tableValues } of tableFieldMultiValueEqualityOperands) {
-        const nonNullTableValues = tableValues.filter((tableValue) => tableValue !== null);
-        query = query.where((builder) => {
-          builder.whereRaw('?? = ANY(?)', [tableField, [...nonNullTableValues]]);
-          // there was at least one null, allow null in this equality clause
-          if (nonNullTableValues.length !== tableValues.length) {
-            builder.orWhereNull(tableField);
-          }
-        });
-      }
-    }
-
-    query = this.applyQueryModifiersToQuery(query, querySelectionModifiers);
-    return await wrapNativePostgresCallAsync(() => query);
-  }
-
-  protected async fetchManyByRawWhereClauseInternalAsync(
-    queryInterface: Knex,
-    tableName: string,
-    rawWhereClause: string,
-    bindings: object | any[],
-    querySelectionModifiers: TableQuerySelectionModifiersWithOrderByRaw,
-  ): Promise<object[]> {
-    let query = queryInterface
-      .select()
-      .from(tableName)
-      .whereRaw(rawWhereClause, bindings as any);
-    query = this.applyQueryModifiersToQueryOrderByRaw(query, querySelectionModifiers);
-    return await wrapNativePostgresCallAsync(() => query);
-  }
-
   protected async insertInternalAsync(
     queryInterface: Knex,
     tableName: string,

packages/entity-database-adapter-knex/src/PostgresEntityDatabaseAdapterProvider.ts

@@ -1,15 +1,42 @@
 import {
   EntityConfiguration,
   EntityDatabaseAdapter,
+  EntityKnexDatabaseAdapter,
   IEntityDatabaseAdapterProvider,
 } from '@expo/entity';
 
 import { PostgresEntityDatabaseAdapter } from './PostgresEntityDatabaseAdapter';
+import { PostgresEntityKnexDatabaseAdapter } from './PostgresEntityKnexDatabaseAdapter';
 
 export class PostgresEntityDatabaseAdapterProvider implements IEntityDatabaseAdapterProvider {
+  private readonly postgresEntityDatabaseAdapters = new Map<
+    EntityConfiguration<any, any>,
+    PostgresEntityDatabaseAdapter<any, any>
+  >();
+
   getDatabaseAdapter<TFields extends Record<string, any>, TIDField extends keyof TFields>(
     entityConfiguration: EntityConfiguration<TFields, TIDField>,
   ): EntityDatabaseAdapter<TFields, TIDField> {
-    return new PostgresEntityDatabaseAdapter(entityConfiguration);
+    let adapter = this.postgresEntityDatabaseAdapters.get(entityConfiguration);
+    if (!adapter) {
+      adapter = new PostgresEntityDatabaseAdapter(entityConfiguration);
+      this.postgresEntityDatabaseAdapters.set(entityConfiguration, adapter);
+    }
+    return adapter as PostgresEntityDatabaseAdapter<TFields, TIDField>;
+  }
+
+  getKnexDatabaseAdapter<TFields extends Record<string, any>, TIDField extends keyof TFields>(
+    entityConfiguration: EntityConfiguration<TFields, TIDField>,
+  ): EntityKnexDatabaseAdapter<TFields, TIDField> {
+    // Get the regular adapter to access its field transformer map
+    const databaseAdapter = this.getDatabaseAdapter(
+      entityConfiguration,
+    ) as PostgresEntityDatabaseAdapter<TFields, TIDField>;
+    // Since getFieldTransformerMap is protected, we need to make it accessible
+    // For now, we'll create a new instance
+    return new PostgresEntityKnexDatabaseAdapter(
+      entityConfiguration,
+      (databaseAdapter as any).getFieldTransformerMap(),
+    );
   }
 }

packages/entity-database-adapter-knex/src/PostgresEntityKnexDatabaseAdapter.ts

@@ -0,0 +1,124 @@
+import {
+  EntityConfiguration,
+  EntityKnexDatabaseAdapter,
+  FieldTransformerMap,
+  TableFieldMultiValueEqualityCondition,
+  TableFieldSingleValueEqualityCondition,
+  TableQuerySelectionModifiers,
+  TableQuerySelectionModifiersWithOrderByRaw,
+} from '@expo/entity';
+import { Knex } from 'knex';
+
+import { wrapNativePostgresCallAsync } from './errors/wrapNativePostgresCallAsync';
+
+export class PostgresEntityKnexDatabaseAdapter<
+  TFields extends Record<string, any>,
+  TIDField extends keyof TFields,
+> extends EntityKnexDatabaseAdapter<TFields, TIDField> {
+  constructor(
+    entityConfiguration: EntityConfiguration<TFields, TIDField>,
+    fieldTransformerMap: FieldTransformerMap,
+  ) {
+    super(entityConfiguration, fieldTransformerMap);
+  }
+
+  private applyQueryModifiersToQueryOrderByRaw(
+    query: Knex.QueryBuilder,
+    querySelectionModifiers: TableQuerySelectionModifiersWithOrderByRaw,
+  ): Knex.QueryBuilder {
+    let ret = this.applyQueryModifiersToQuery(query, querySelectionModifiers);
+
+    const { orderByRaw } = querySelectionModifiers;
+    if (orderByRaw !== undefined) {
+      ret = ret.orderByRaw(orderByRaw);
+    }
+
+    return ret;
+  }
+
+  private applyQueryModifiersToQuery(
+    query: Knex.QueryBuilder,
+    querySelectionModifiers: TableQuerySelectionModifiers,
+  ): Knex.QueryBuilder {
+    const { orderBy, offset, limit } = querySelectionModifiers;
+
+    let ret = query;
+
+    if (orderBy !== undefined) {
+      for (const orderBySpecification of orderBy) {
+        ret = ret.orderBy(orderBySpecification.columnName, orderBySpecification.order);
+      }
+    }
+
+    if (offset !== undefined) {
+      ret = ret.offset(offset);
+    }
+
+    if (limit !== undefined) {
+      ret = ret.limit(limit);
+    }
+
+    return ret;
+  }
+
+  protected async fetchManyByFieldEqualityConjunctionInternalAsync(
+    queryInterface: Knex,
+    tableName: string,
+    tableFieldSingleValueEqualityOperands: TableFieldSingleValueEqualityCondition[],
+    tableFieldMultiValueEqualityOperands: TableFieldMultiValueEqualityCondition[],
+    querySelectionModifiers: TableQuerySelectionModifiers,
+  ): Promise<object[]> {
+    let query = queryInterface.select().from(tableName);
+
+    if (tableFieldSingleValueEqualityOperands.length > 0) {
+      const whereObject: { [key: string]: any } = {};
+      const nonNullTableFieldSingleValueEqualityOperands =
+        tableFieldSingleValueEqualityOperands.filter(({ tableValue }) => tableValue !== null);
+      const nullTableFieldSingleValueEqualityOperands =
+        tableFieldSingleValueEqualityOperands.filter(({ tableValue }) => tableValue === null);
+
+      if (nonNullTableFieldSingleValueEqualityOperands.length > 0) {
+        for (const { tableField, tableValue } of nonNullTableFieldSingleValueEqualityOperands) {
+          whereObject[tableField] = tableValue;
+        }
+        query = query.where(whereObject);
+      }
+      if (nullTableFieldSingleValueEqualityOperands.length > 0) {
+        for (const { tableField } of nullTableFieldSingleValueEqualityOperands) {
+          query = query.whereNull(tableField);
+        }
+      }
+    }
+
+    if (tableFieldMultiValueEqualityOperands.length > 0) {
+      for (const { tableField, tableValues } of tableFieldMultiValueEqualityOperands) {
+        const nonNullTableValues = tableValues.filter((tableValue) => tableValue !== null);
+        query = query.where((builder) => {
+          builder.whereRaw('?? = ANY(?)', [tableField, [...nonNullTableValues]]);
+          // there was at least one null, allow null in this equality clause
+          if (nonNullTableValues.length !== tableValues.length) {
+            builder.orWhereNull(tableField);
+          }
+        });
+      }
+    }
+
+    query = this.applyQueryModifiersToQuery(query, querySelectionModifiers);
+    return await wrapNativePostgresCallAsync(() => query);
+  }
+
+  protected async fetchManyByRawWhereClauseInternalAsync(
+    queryInterface: Knex,
+    tableName: string,
+    rawWhereClause: string,
+    bindings: object | any[],
+    querySelectionModifiers: TableQuerySelectionModifiersWithOrderByRaw,
+  ): Promise<object[]> {
+    let query = queryInterface
+      .select()
+      .from(tableName)
+      .whereRaw(rawWhereClause, bindings as any);
+    query = this.applyQueryModifiersToQueryOrderByRaw(query, querySelectionModifiers);
+    return await wrapNativePostgresCallAsync(() => query);
+  }
+}

packages/entity-database-adapter-knex/src/index.ts

@@ -6,6 +6,7 @@
 
 export * from './EntityFields';
 export * from './PostgresEntityDatabaseAdapter';
+export * from './PostgresEntityKnexDatabaseAdapter';
 export * from './PostgresEntityDatabaseAdapterProvider';
 export * from './PostgresEntityQueryContextProvider';
 export * from './errors/wrapNativePostgresCallAsync';