@expo/entity-testing-utils 0.41.0

package/build/describeFieldTestCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"describeFieldTestCase.js","sourceRoot":"","sources":["../src/describeFieldTestCase.ts"],"names":[],"mappings":";;AAEA,wCAkBC;AAlBD,SAAwB,qBAAqB,CAC3C,eAA8C,EAC9C,WAAgB,EAChB,aAAoB;IAEpB,QAAQ,CAAC,eAAe,CAAC,WAAW,CAAC,IAAI,EAAE,GAAG,EAAE;QAC9C,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC3B,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,GAAG,eAAe,CAAC,WAAW,CAAC,IAAI,WAAW,EAAE,CAAC,KAAK,EAAE,EAAE;gBAC/E,MAAM,CAAC,eAAe,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC/D,CAAC,CAAC,CAAC;QACL,CAAC;QAED,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC7B,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,GAAG,eAAe,CAAC,WAAW,CAAC,IAAI,aAAa,EAAE,CAAC,KAAK,EAAE,EAAE;gBACnF,MAAM,CAAC,eAAe,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAChE,CAAC,CAAC,CAAC;QACL,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC"}

package/build/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @packageDocumentation
+ * @module @expo/entity-testing-utils
+ */
+export * from './createUnitTestEntityCompanionProvider';
+export { default as describeFieldTestCase } from './describeFieldTestCase';
+export * from './PrivacyPolicyRuleTestUtils';
+export * from './StubCacheAdapter';
+export { default as StubDatabaseAdapter } from './StubDatabaseAdapter';
+export { default as StubDatabaseAdapterProvider } from './StubDatabaseAdapterProvider';
+export { default as StubQueryContextProvider } from './StubQueryContextProvider';
+export * from './TSMockitoExtensions';

package/build/index.js

@@ -0,0 +1,38 @@
+"use strict";
+/* eslint-disable tsdoc/syntax */
+/**
+ * @packageDocumentation
+ * @module @expo/entity-testing-utils
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StubQueryContextProvider = exports.StubDatabaseAdapterProvider = exports.StubDatabaseAdapter = exports.describeFieldTestCase = void 0;
+__exportStar(require("./createUnitTestEntityCompanionProvider"), exports);
+var describeFieldTestCase_1 = require("./describeFieldTestCase");
+Object.defineProperty(exports, "describeFieldTestCase", { enumerable: true, get: function () { return __importDefault(describeFieldTestCase_1).default; } });
+__exportStar(require("./PrivacyPolicyRuleTestUtils"), exports);
+__exportStar(require("./StubCacheAdapter"), exports);
+var StubDatabaseAdapter_1 = require("./StubDatabaseAdapter");
+Object.defineProperty(exports, "StubDatabaseAdapter", { enumerable: true, get: function () { return __importDefault(StubDatabaseAdapter_1).default; } });
+var StubDatabaseAdapterProvider_1 = require("./StubDatabaseAdapterProvider");
+Object.defineProperty(exports, "StubDatabaseAdapterProvider", { enumerable: true, get: function () { return __importDefault(StubDatabaseAdapterProvider_1).default; } });
+var StubQueryContextProvider_1 = require("./StubQueryContextProvider");
+Object.defineProperty(exports, "StubQueryContextProvider", { enumerable: true, get: function () { return __importDefault(StubQueryContextProvider_1).default; } });
+__exportStar(require("./TSMockitoExtensions"), exports);
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA,iCAAiC;AACjC;;;GAGG;;;;;;;;;;;;;;;;;;;;AAEH,0EAAwD;AACxD,iEAA2E;AAAlE,+IAAA,OAAO,OAAyB;AACzC,+DAA6C;AAC7C,qDAAmC;AACnC,6DAAuE;AAA9D,2IAAA,OAAO,OAAuB;AACvC,6EAAuF;AAA9E,2JAAA,OAAO,OAA+B;AAC/C,uEAAiF;AAAxE,qJAAA,OAAO,OAA4B;AAC5C,wDAAsC"}

package/build/tsconfig.build.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/privacypolicyruletestutils.ts","../src/stubcacheadapter.ts","../src/stubdatabaseadapter.ts","../src/stubdatabaseadapterprovider.ts","../src/stubquerycontextprovider.ts","../src/tsmockitoextensions.ts","../src/createunittestentitycompanionprovider.ts","../src/describefieldtestcase.ts","../src/index.ts"],"version":"5.8.3"}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@expo/entity-testing-utils",
+  "version": "0.41.0",
+  "description": "A package containing utilities for testing applications that use Entity",
+  "files": [
+    "build",
+    "src"
+  ],
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "tsc": "tsc",
+    "build": "tsc -b tsconfig.build.json",
+    "clean": "rm -rf build coverage coverage-integration",
+    "lint": "eslint src",
+    "lint-fix": "eslint src --fix",
+    "test": "jest --rootDir . --config ../../resources/jest.config.js",
+    "ctix": "ctix build --config ../../.ctirc && ../../resources/prepend-barrel.sh '@expo/entity-testing-utils'"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "keywords": [
+    "entity"
+  ],
+  "author": "Expo",
+  "license": "MIT",
+  "dependencies": {
+    "@expo/entity": "workspace:^",
+    "lodash": "^4.17.21",
+    "ts-mockito": "^2.6.1"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/lodash": "^4.17.16",
+    "@types/node": "^20.14.1",
+    "ctix": "^2.7.0",
+    "eslint": "^8.57.1",
+    "eslint-config-universe": "^14.0.0",
+    "eslint-plugin-tsdoc": "^0.3.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.3.3",
+    "prettier-plugin-organize-imports": "^4.1.0",
+    "ts-jest": "^29.3.1",
+    "ts-mockito": "^2.6.1",
+    "typescript": "^5.8.3"
+  }
+}

package/src/PrivacyPolicyRuleTestUtils.ts

@@ -0,0 +1,138 @@
+import {
+  EntityPrivacyPolicyEvaluationContext,
+  EntityQueryContext,
+  ReadonlyEntity,
+  ViewerContext,
+  PrivacyPolicyRule,
+  RuleEvaluationResult,
+} from '@expo/entity';
+
+export interface Case<
+  TFields extends Record<string, any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
+  TViewerContext extends ViewerContext,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
+  TSelectedFields extends keyof TFields,
+> {
+  viewerContext: TViewerContext;
+  queryContext: EntityQueryContext;
+  evaluationContext: EntityPrivacyPolicyEvaluationContext<
+    TFields,
+    TIDField,
+    TViewerContext,
+    TEntity,
+    TSelectedFields
+  >;
+  entity: TEntity;
+}
+
+export type CaseMap<
+  TFields extends Record<string, any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
+  TViewerContext extends ViewerContext,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
+  TSelectedFields extends keyof TFields,
+> = Map<string, () => Promise<Case<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>>>;
+
+/**
+ * Useful for defining test cases that have async preconditions.
+ */
+export const describePrivacyPolicyRuleWithAsyncTestCase = <
+  TFields extends Record<string, any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
+  TViewerContext extends ViewerContext,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
+  TSelectedFields extends keyof TFields = keyof TFields,
+>(
+  privacyPolicyRule: PrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>,
+  {
+    allowCases = new Map(),
+    skipCases = new Map(),
+    denyCases = new Map(),
+  }: {
+    allowCases?: CaseMap<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>;
+    skipCases?: CaseMap<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>;
+    denyCases?: CaseMap<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>;
+  },
+): void => {
+  describe(privacyPolicyRule.constructor.name, () => {
+    if (allowCases && allowCases.size > 0) {
+      describe('allow cases', () => {
+        test.each(Array.from(allowCases.keys()))('%p', async (caseKey) => {
+          const { viewerContext, queryContext, evaluationContext, entity } =
+            await allowCases.get(caseKey)!();
+          await expect(
+            privacyPolicyRule.evaluateAsync(viewerContext, queryContext, evaluationContext, entity),
+          ).resolves.toEqual(RuleEvaluationResult.ALLOW);
+        });
+      });
+    }
+
+    if (skipCases && skipCases.size > 0) {
+      describe('skip cases', () => {
+        test.each(Array.from(skipCases.keys()))('%p', async (caseKey) => {
+          const { viewerContext, queryContext, evaluationContext, entity } =
+            await skipCases.get(caseKey)!();
+          await expect(
+            privacyPolicyRule.evaluateAsync(viewerContext, queryContext, evaluationContext, entity),
+          ).resolves.toEqual(RuleEvaluationResult.SKIP);
+        });
+      });
+    }
+
+    if (denyCases && denyCases.size > 0) {
+      describe('deny cases', () => {
+        test.each(Array.from(denyCases.keys()))('%p', async (caseKey) => {
+          const { viewerContext, queryContext, evaluationContext, entity } =
+            await denyCases.get(caseKey)!();
+          await expect(
+            privacyPolicyRule.evaluateAsync(viewerContext, queryContext, evaluationContext, entity),
+          ).resolves.toEqual(RuleEvaluationResult.DENY);
+        });
+      });
+    }
+  });
+};
+
+/**
+ * For test simple privacy rules that don't have complex async preconditions.
+ */
+export const describePrivacyPolicyRule = <
+  TFields extends Record<string, any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
+  TViewerContext extends ViewerContext,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
+  TSelectedFields extends keyof TFields = keyof TFields,
+>(
+  privacyPolicyRule: PrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>,
+  {
+    allowCases = [],
+    skipCases = [],
+    denyCases = [],
+  }: {
+    allowCases?: Case<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>[];
+    skipCases?: Case<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>[];
+    denyCases?: Case<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>[];
+  },
+): void => {
+  const makeCasesMap = (
+    cases: Case<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>[],
+  ): CaseMap<TFields, TIDField, TViewerContext, TEntity, TSelectedFields> =>
+    cases.reduce(
+      (
+        acc: CaseMap<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>,
+        testCase: Case<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>,
+        index,
+      ) => {
+        acc.set(`case ${index}`, async () => testCase);
+        return acc;
+      },
+      new Map(),
+    );
+
+  describePrivacyPolicyRuleWithAsyncTestCase(privacyPolicyRule, {
+    allowCases: makeCasesMap(allowCases),
+    skipCases: makeCasesMap(skipCases),
+    denyCases: makeCasesMap(denyCases),
+  });
+};

package/src/StubCacheAdapter.ts

@@ -0,0 +1,167 @@
+import {
+  EntityConfiguration,
+  IEntityCacheAdapter,
+  IEntityCacheAdapterProvider,
+  IEntityLoadKey,
+  IEntityLoadValue,
+  CacheStatus,
+  CacheLoadResult,
+} from '@expo/entity';
+import invariant from 'invariant';
+
+export class NoCacheStubCacheAdapterProvider implements IEntityCacheAdapterProvider {
+  getCacheAdapter<TFields extends Record<string, any>, TIDField extends keyof TFields>(
+    _entityConfiguration: EntityConfiguration<TFields, TIDField>,
+  ): IEntityCacheAdapter<TFields, TIDField> {
+    return new NoCacheStubCacheAdapter();
+  }
+}
+
+export class NoCacheStubCacheAdapter<
+  TFields extends Record<string, any>,
+  TIDField extends keyof TFields,
+> implements IEntityCacheAdapter<TFields, TIDField>
+{
+  public async loadManyAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(
+    key: TLoadKey,
+    values: readonly TLoadValue[],
+  ): Promise<ReadonlyMap<TLoadValue, CacheLoadResult<TFields>>> {
+    return values.reduce((acc: Map<TLoadValue, CacheLoadResult<TFields>>, v) => {
+      acc.set(v, {
+        status: CacheStatus.MISS,
+      });
+      return acc;
+    }, key.vendNewLoadValueMap<CacheLoadResult<TFields>>());
+  }
+
+  public async cacheManyAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(_key: TLoadKey, _objectMap: ReadonlyMap<TLoadValue, Readonly<TFields>>): Promise<void> {}
+
+  public async cacheDBMissesAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(_key: TLoadKey, _values: readonly TLoadValue[]): Promise<void> {}
+
+  public async invalidateManyAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(_key: TLoadKey, _values: readonly TLoadValue[]): Promise<void> {}
+}
+
+// Sentinel value we store in the in-memory cache to negatively cache a database miss.
+// The sentinel value is distinct from any (positively) cached value.
+export const DOES_NOT_EXIST = Symbol('inMemoryCacheDoesNotExistValue');
+
+export class InMemoryFullCacheStubCacheAdapterProvider implements IEntityCacheAdapterProvider {
+  private readonly cache: Map<string, Readonly<object> | typeof DOES_NOT_EXIST> = new Map();
+
+  getCacheAdapter<TFields extends Record<string, any>, TIDField extends keyof TFields>(
+    entityConfiguration: EntityConfiguration<TFields, TIDField>,
+  ): IEntityCacheAdapter<TFields, TIDField> {
+    return new InMemoryFullCacheStubCacheAdapter(
+      entityConfiguration,
+      this.cache as Map<string, Readonly<TFields>>,
+    );
+  }
+}
+
+export class InMemoryFullCacheStubCacheAdapter<
+  TFields extends Record<string, any>,
+  TIDField extends keyof TFields,
+> implements IEntityCacheAdapter<TFields, TIDField>
+{
+  constructor(
+    private readonly entityConfiguration: EntityConfiguration<TFields, TIDField>,
+    private readonly cache: Map<string, Readonly<TFields> | typeof DOES_NOT_EXIST>,
+  ) {}
+
+  public async loadManyAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(
+    key: TLoadKey,
+    values: readonly TLoadValue[],
+  ): Promise<ReadonlyMap<TLoadValue, CacheLoadResult<TFields>>> {
+    const results = key.vendNewLoadValueMap<CacheLoadResult<TFields>>();
+    values.forEach((value) => {
+      const cacheKey = this.createCacheKey(key, value);
+      if (!this.cache.has(cacheKey)) {
+        results.set(value, {
+          status: CacheStatus.MISS,
+        });
+      } else {
+        const objectForFieldValue = this.cache.get(cacheKey);
+        invariant(objectForFieldValue !== undefined, 'should have set value for key');
+        if (objectForFieldValue === DOES_NOT_EXIST) {
+          results.set(value, {
+            status: CacheStatus.NEGATIVE,
+          });
+        } else {
+          results.set(value, {
+            status: CacheStatus.HIT,
+            item: objectForFieldValue,
+          });
+        }
+      }
+    });
+    return results;
+  }
+
+  public async cacheManyAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(key: TLoadKey, objectMap: ReadonlyMap<TLoadValue, Readonly<TFields>>): Promise<void> {
+    objectMap.forEach((obj, value) => {
+      const cacheKey = this.createCacheKey(key, value);
+      this.cache.set(cacheKey, obj);
+    });
+  }
+
+  public async cacheDBMissesAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(key: TLoadKey, values: readonly TLoadValue[]): Promise<void> {
+    values.forEach((value) => {
+      const cacheKey = this.createCacheKey(key, value);
+      this.cache.set(cacheKey, DOES_NOT_EXIST);
+    });
+  }
+
+  public async invalidateManyAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(key: TLoadKey, values: readonly TLoadValue[]): Promise<void> {
+    values.forEach((value) => {
+      const cacheKey = this.createCacheKey(key, value);
+      this.cache.delete(cacheKey);
+    });
+  }
+
+  private createCacheKey<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(key: TLoadKey, value: TLoadValue): string {
+    const cacheKeyType = key.getLoadMethodType();
+    const parts = key.createCacheKeyPartsForLoadValue(this.entityConfiguration, value);
+    return [
+      this.entityConfiguration.tableName,
+      cacheKeyType,
+      `v${this.entityConfiguration.cacheKeyVersion}`,
+      ...parts,
+    ].join(':');
+  }
+}

package/src/StubDatabaseAdapter.ts

@@ -0,0 +1,249 @@
+import {
+  EntityConfiguration,
+  EntityDatabaseAdapter,
+  TableFieldSingleValueEqualityCondition,
+  TableFieldMultiValueEqualityCondition,
+  TableQuerySelectionModifiers,
+  OrderByOrdering,
+  StringField,
+  IntField,
+  getDatabaseFieldForEntityField,
+  FieldTransformerMap,
+  transformFieldsToDatabaseObject,
+  computeIfAbsent,
+  mapMap,
+} from '@expo/entity';
+import invariant from 'invariant';
+import { uuidv7 } from 'uuidv7';
+
+export default class StubDatabaseAdapter<
+  TFields extends Record<string, any>,
+  TIDField extends keyof TFields,
+> extends EntityDatabaseAdapter<TFields, TIDField> {
+  constructor(
+    private readonly entityConfiguration2: EntityConfiguration<TFields, TIDField>,
+    private readonly dataStore: Map<string, Readonly<{ [key: string]: any }>[]>,
+  ) {
+    super(entityConfiguration2);
+  }
+
+  public static convertFieldObjectsToDataStore<
+    TFields extends Record<string, any>,
+    TIDField extends keyof TFields,
+  >(
+    entityConfiguration: EntityConfiguration<TFields, TIDField>,
+    dataStore: Map<string, Readonly<TFields>[]>,
+  ): Map<string, Readonly<{ [key: string]: any }>[]> {
+    return mapMap(dataStore, (objectsForTable) =>
+      objectsForTable.map((objectForTable) =>
+        transformFieldsToDatabaseObject(entityConfiguration, new Map(), objectForTable),
+      ),
+    );
+  }
+
+  public getObjectCollectionForTable(tableName: string): { [key: string]: any }[] {
+    return computeIfAbsent(this.dataStore, tableName, () => []);
+  }
+
+  protected getFieldTransformerMap(): FieldTransformerMap {
+    return new Map();
+  }
+
+  protected async fetchManyWhereInternalAsync(
+    _queryInterface: any,
+    tableName: string,
+    tableColumns: readonly string[],
+    tableTuples: (readonly any[])[],
+  ): Promise<object[]> {
+    const objectCollection = this.getObjectCollectionForTable(tableName);
+    const results = tableTuples.reduce(
+      (acc, tableTuple) => {
+        return acc.concat(
+          objectCollection.filter((obj) => {
+            return tableColumns.every((tableColumn, index) => {
+              return obj[tableColumn] === tableTuple[index];
+            });
+          }),
+        );
+      },
+      [] as { [key: string]: any }[],
+    );
+    return [...results];
+  }
+
+  private static compareByOrderBys(
+    orderBys: {
+      columnName: string;
+      order: OrderByOrdering;
+    }[],
+    objectA: { [key: string]: any },
+    objectB: { [key: string]: any },
+  ): 0 | 1 | -1 {
+    if (orderBys.length === 0) {
+      return 0;
+    }
+
+    const currentOrderBy = orderBys[0]!;
+    const aField = objectA[currentOrderBy.columnName];
+    const bField = objectB[currentOrderBy.columnName];
+    switch (currentOrderBy.order) {
+      case OrderByOrdering.DESCENDING: {
+        // simulate NULLS FIRST for DESC
+        if (aField === null && bField === null) {
+          return 0;
+        } else if (aField === null) {
+          return -1;
+        } else if (bField === null) {
+          return 1;
+        }
+
+        return aField > bField
+          ? -1
+          : aField < bField
+            ? 1
+            : this.compareByOrderBys(orderBys.slice(1), objectA, objectB);
+      }
+      case OrderByOrdering.ASCENDING: {
+        // simulate NULLS LAST for ASC
+        if (aField === null && bField === null) {
+          return 0;
+        } else if (bField === null) {
+          return -1;
+        } else if (aField === null) {
+          return 1;
+        }
+
+        return bField > aField
+          ? -1
+          : bField < aField
+            ? 1
+            : this.compareByOrderBys(orderBys.slice(1), objectA, objectB);
+      }
+    }
+  }
+
+  protected async fetchManyByFieldEqualityConjunctionInternalAsync(
+    _queryInterface: any,
+    tableName: string,
+    tableFieldSingleValueEqualityOperands: TableFieldSingleValueEqualityCondition[],
+    tableFieldMultiValueEqualityOperands: TableFieldMultiValueEqualityCondition[],
+    querySelectionModifiers: TableQuerySelectionModifiers,
+  ): Promise<object[]> {
+    let filteredObjects = this.getObjectCollectionForTable(tableName);
+    for (const { tableField, tableValue } of tableFieldSingleValueEqualityOperands) {
+      filteredObjects = filteredObjects.filter((obj) => obj[tableField] === tableValue);
+    }
+
+    for (const { tableField, tableValues } of tableFieldMultiValueEqualityOperands) {
+      filteredObjects = filteredObjects.filter((obj) => tableValues.includes(obj[tableField]));
+    }
+
+    const orderBy = querySelectionModifiers.orderBy;
+    if (orderBy !== undefined) {
+      filteredObjects = filteredObjects.sort((a, b) =>
+        StubDatabaseAdapter.compareByOrderBys(orderBy, a, b),
+      );
+    }
+
+    const offset = querySelectionModifiers.offset;
+    if (offset !== undefined) {
+      filteredObjects = filteredObjects.slice(offset);
+    }
+
+    const limit = querySelectionModifiers.limit;
+    if (limit !== undefined) {
+      filteredObjects = filteredObjects.slice(0, 0 + limit);
+    }
+
+    return filteredObjects;
+  }
+
+  protected fetchManyByRawWhereClauseInternalAsync(
+    _queryInterface: any,
+    _tableName: string,
+    _rawWhereClause: string,
+    _bindings: object | any[],
+    _querySelectionModifiers: TableQuerySelectionModifiers,
+  ): Promise<object[]> {
+    throw new Error('Raw WHERE clauses not supported for StubDatabaseAdapter');
+  }
+
+  private generateRandomID(): any {
+    const idSchemaField = this.entityConfiguration2.schema.get(this.entityConfiguration2.idField);
+    invariant(
+      idSchemaField,
+      `No schema field found for ${String(this.entityConfiguration2.idField)}`,
+    );
+    if (idSchemaField instanceof StringField) {
+      return uuidv7();
+    } else if (idSchemaField instanceof IntField) {
+      return Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
+    } else {
+      throw new Error(
+        `Unsupported ID type for StubDatabaseAdapter: ${idSchemaField.constructor.name}`,
+      );
+    }
+  }
+
+  protected async insertInternalAsync(
+    _queryInterface: any,
+    tableName: string,
+    object: object,
+  ): Promise<object[]> {
+    const objectCollection = this.getObjectCollectionForTable(tableName);
+
+    const idField = getDatabaseFieldForEntityField(
+      this.entityConfiguration2,
+      this.entityConfiguration2.idField,
+    );
+    const objectToInsert = {
+      [idField]: this.generateRandomID(),
+      ...object,
+    };
+    objectCollection.push(objectToInsert);
+    return [objectToInsert];
+  }
+
+  protected async updateInternalAsync(
+    _queryInterface: any,
+    tableName: string,
+    tableIdField: string,
+    id: any,
+    object: object,
+  ): Promise<object[]> {
+    // SQL does not support empty updates, mirror behavior here for better test simulation
+    if (Object.keys(object).length === 0) {
+      throw new Error(`Empty update (${tableIdField} = ${id})`);
+    }
+
+    const objectCollection = this.getObjectCollectionForTable(tableName);
+
+    const objectIndex = objectCollection.findIndex((obj) => {
+      return obj[tableIdField] === id;
+    });
+    invariant(objectIndex >= 0, 'should exist');
+    objectCollection[objectIndex] = {
+      ...objectCollection[objectIndex],
+      ...object,
+    };
+    return [objectCollection[objectIndex]];
+  }
+
+  protected async deleteInternalAsync(
+    _queryInterface: any,
+    tableName: string,
+    tableIdField: string,
+    id: any,
+  ): Promise<number> {
+    const objectCollection = this.getObjectCollectionForTable(tableName);
+
+    const objectIndex = objectCollection.findIndex((obj) => {
+      return obj[tableIdField] === id;
+    });
+    if (objectIndex < 0) {
+      return 0;
+    }
+    objectCollection.splice(objectIndex, 1);
+    return 1;
+  }
+}

package/src/StubDatabaseAdapterProvider.ts

@@ -0,0 +1,17 @@
+import {
+  EntityConfiguration,
+  EntityDatabaseAdapter,
+  IEntityDatabaseAdapterProvider,
+} from '@expo/entity';
+
+import StubDatabaseAdapter from './StubDatabaseAdapter';
+
+export default class StubDatabaseAdapterProvider implements IEntityDatabaseAdapterProvider {
+  private readonly objectCollection = new Map();
+
+  getDatabaseAdapter<TFields extends Record<string, any>, TIDField extends keyof TFields>(
+    entityConfiguration: EntityConfiguration<TFields, TIDField>,
+  ): EntityDatabaseAdapter<TFields, TIDField> {
+    return new StubDatabaseAdapter(entityConfiguration, this.objectCollection);
+  }
+}