@expo/entity-database-adapter-knex 0.59.0 → 0.61.0

package/src/__integration-tests__/EntityCreationUtils-test.ts

@@ -1,10 +1,11 @@
 import { createWithUniqueConstraintRecoveryAsync, ViewerContext } from '@expo/entity';
+import nullthrows from '@expo/nullthrows';
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from '@jest/globals';
-import knex, { Knex } from 'knex';
-import nullthrows from 'nullthrows';
+import type { Knex } from 'knex';
+import knex from 'knex';
 
-import { PostgresUniqueTestEntity } from '../__testfixtures__/PostgresUniqueTestEntity';
-import { createKnexIntegrationTestEntityCompanionProvider } from '../__testfixtures__/createKnexIntegrationTestEntityCompanionProvider';
+import { PostgresUniqueTestEntity } from '../__testfixtures__/PostgresUniqueTestEntity.ts';
+import { createKnexIntegrationTestEntityCompanionProvider } from '../__testfixtures__/createKnexIntegrationTestEntityCompanionProvider.ts';
 
 describe(createWithUniqueConstraintRecoveryAsync, () => {
   let knexInstance: Knex;

package/src/__integration-tests__/PostgresEntityIntegration-test.ts

@@ -4,23 +4,23 @@ import {
   ViewerContext,
 } from '@expo/entity';
 import { createUnitTestEntityCompanionProvider } from '@expo/entity-testing-utils';
+import nullthrows from '@expo/nullthrows';
 import { enforceAsyncResult } from '@expo/results';
 import { afterAll, beforeAll, beforeEach, describe, expect, it, test } from '@jest/globals';
-import { knex, Knex } from 'knex';
-import nullthrows from 'nullthrows';
+import type { Knex } from 'knex';
+import knex from 'knex';
 import { setTimeout } from 'timers/promises';
 
-import { PaginationSpecification } from '../AuthorizationResultBasedKnexEntityLoader';
-import { NullsOrdering, OrderByOrdering } from '../BasePostgresEntityDatabaseAdapter';
-import { PaginationStrategy } from '../PaginationStrategy';
-import { entityField, unsafeRaw, sql, SQLFragmentHelpers, SQLFragment } from '../SQLOperator';
-import {
-  PostgresTestEntity,
-  PostgresTestEntityFields,
-} from '../__testfixtures__/PostgresTestEntity';
-import { PostgresTriggerTestEntity } from '../__testfixtures__/PostgresTriggerTestEntity';
-import { PostgresValidatorTestEntity } from '../__testfixtures__/PostgresValidatorTestEntity';
-import { createKnexIntegrationTestEntityCompanionProvider } from '../__testfixtures__/createKnexIntegrationTestEntityCompanionProvider';
+import type { PaginationSpecification } from '../AuthorizationResultBasedKnexEntityLoader.ts';
+import { NullsOrdering, OrderByOrdering } from '../BasePostgresEntityDatabaseAdapter.ts';
+import { PaginationStrategy } from '../PaginationStrategy.ts';
+import type { SQLFragment } from '../SQLOperator.ts';
+import { entityField, sql, SQLExpression, unsafeRaw } from '../SQLOperator.ts';
+import type { PostgresTestEntityFields } from '../__testfixtures__/PostgresTestEntity.ts';
+import { PostgresTestEntity } from '../__testfixtures__/PostgresTestEntity.ts';
+import { PostgresTriggerTestEntity } from '../__testfixtures__/PostgresTriggerTestEntity.ts';
+import { PostgresValidatorTestEntity } from '../__testfixtures__/PostgresValidatorTestEntity.ts';
+import { createKnexIntegrationTestEntityCompanionProvider } from '../__testfixtures__/createKnexIntegrationTestEntityCompanionProvider.ts';
 
 describe('postgres entity integration', () => {
   let knexInstance: Knex;
@@ -456,7 +456,7 @@ describe('postgres entity integration', () => {
 
     it('supports SQL helper functions', async () => {
       const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
-      const { and, or, eq, neq, inArray } = SQLFragmentHelpers;
+      const { and, or, eq, neq, inArray } = SQLExpression;
 
       await enforceAsyncResult(
         PostgresTestEntity.creatorWithAuthorizationResults(vc1)
@@ -521,6 +521,33 @@ describe('postgres entity integration', () => {
       expect(complexQuery[1]!.getField('name')).toBe('User3');
     });
 
+    it('handles empty-array and empty-condition edge cases with TRUE/FALSE', async () => {
+      const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
+      const { and, or, inArray } = SQLExpression;
+
+      await enforceAsyncResult(
+        PostgresTestEntity.creatorWithAuthorizationResults(vc1)
+          .setField('name', 'TrueFalseUser')
+          .setField('hasACat', true)
+          .setField('hasADog', false)
+          .createAsync(),
+      );
+
+      // inArray([]) produces FALSE — should return no results
+      const emptyIn = await PostgresTestEntity.knexLoader(vc1)
+        .loadManyBySQL(inArray('name', []))
+        .executeAsync();
+      expect(emptyIn).toHaveLength(0);
+
+      // and() with no conditions produces TRUE — should return all results
+      const emptyAnd = await PostgresTestEntity.knexLoader(vc1).loadManyBySQL(and()).executeAsync();
+      expect(emptyAnd.length).toBeGreaterThanOrEqual(1);
+
+      // or() with no conditions produces FALSE — should return no results
+      const emptyOr = await PostgresTestEntity.knexLoader(vc1).loadManyBySQL(or()).executeAsync();
+      expect(emptyOr).toHaveLength(0);
+    });
+
     it('supports entityField for entity-to-DB field name translation', async () => {
       const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
 
@@ -743,7 +770,7 @@ describe('postgres entity integration', () => {
         sql`(has_a_cat = ${true} AND has_a_dog = ${true})`,
       ];
       const joinedResults = await PostgresTestEntity.knexLoader(vc1)
-        .loadManyBySQL(SQLFragmentHelpers.or<PostgresTestEntityFields>(...conditions))
+        .loadManyBySQL(SQLExpression.or<PostgresTestEntityFields>(...conditions))
         .orderBy('name', OrderByOrdering.ASCENDING)
         .executeAsync();
 

package/src/__integration-tests__/PostgresEntityQueryContextProvider-test.ts

@@ -1,11 +1,12 @@
 import { TransactionalDataLoaderMode, ViewerContext } from '@expo/entity';
+import nullthrows from '@expo/nullthrows';
 import { afterAll, beforeAll, beforeEach, describe, expect, it, test } from '@jest/globals';
-import { knex, Knex } from 'knex';
-import nullthrows from 'nullthrows';
+import type { Knex } from 'knex';
+import knex from 'knex';
 
-import { PostgresEntityQueryContextProvider } from '../PostgresEntityQueryContextProvider';
-import { PostgresUniqueTestEntity } from '../__testfixtures__/PostgresUniqueTestEntity';
-import { createKnexIntegrationTestEntityCompanionProvider } from '../__testfixtures__/createKnexIntegrationTestEntityCompanionProvider';
+import { PostgresEntityQueryContextProvider } from '../PostgresEntityQueryContextProvider.ts';
+import { PostgresUniqueTestEntity } from '../__testfixtures__/PostgresUniqueTestEntity.ts';
+import { createKnexIntegrationTestEntityCompanionProvider } from '../__testfixtures__/createKnexIntegrationTestEntityCompanionProvider.ts';
 
 describe(PostgresEntityQueryContextProvider, () => {
   let knexInstance: Knex;

package/src/__integration-tests__/PostgresInvalidSetup-test.ts

@@ -1,11 +1,12 @@
 import { ViewerContext } from '@expo/entity';
+import nullthrows from '@expo/nullthrows';
 import { enforceAsyncResult } from '@expo/results';
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from '@jest/globals';
-import { knex, Knex } from 'knex';
-import nullthrows from 'nullthrows';
+import type { Knex } from 'knex';
+import knex from 'knex';
 
-import { InvalidTestEntity } from '../__testfixtures__/InvalidTestEntity';
-import { createKnexIntegrationTestEntityCompanionProvider } from '../__testfixtures__/createKnexIntegrationTestEntityCompanionProvider';
+import { InvalidTestEntity } from '../__testfixtures__/InvalidTestEntity.ts';
+import { createKnexIntegrationTestEntityCompanionProvider } from '../__testfixtures__/createKnexIntegrationTestEntityCompanionProvider.ts';
 
 describe('postgres entity integration', () => {
   let knexInstance: Knex;

package/src/__integration-tests__/errors-test.ts

@@ -8,12 +8,13 @@ import {
   EntityDatabaseAdapterUnknownError,
   ViewerContext,
 } from '@expo/entity';
+import nullthrows from '@expo/nullthrows';
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from '@jest/globals';
-import { knex, Knex } from 'knex';
-import nullthrows from 'nullthrows';
+import type { Knex } from 'knex';
+import knex from 'knex';
 
-import { ErrorsTestEntity } from '../__testfixtures__/ErrorsTestEntity';
-import { createKnexIntegrationTestEntityCompanionProvider } from '../__testfixtures__/createKnexIntegrationTestEntityCompanionProvider';
+import { ErrorsTestEntity } from '../__testfixtures__/ErrorsTestEntity.ts';
+import { createKnexIntegrationTestEntityCompanionProvider } from '../__testfixtures__/createKnexIntegrationTestEntityCompanionProvider.ts';
 
 describe('postgres errors', () => {
   let knexInstance: Knex;

package/src/__testfixtures__/ErrorsTestEntity.ts

@@ -1,14 +1,13 @@
+import type { EntityCompanionDefinition, ViewerContext } from '@expo/entity';
 import {
   AlwaysAllowPrivacyPolicyRule,
   Entity,
-  EntityCompanionDefinition,
   EntityConfiguration,
   EntityPrivacyPolicy,
   IntField,
   StringField,
-  ViewerContext,
 } from '@expo/entity';
-import { Knex } from 'knex';
+import type { Knex } from 'knex';
 
 type ErrorsTestEntityFields = {
   id: number;

package/src/__testfixtures__/InvalidTestEntity.ts

@@ -1,14 +1,13 @@
+import type { EntityCompanionDefinition, ViewerContext } from '@expo/entity';
 import {
   AlwaysAllowPrivacyPolicyRule,
   Entity,
-  EntityCompanionDefinition,
   EntityConfiguration,
   EntityPrivacyPolicy,
   IntField,
   StringField,
-  ViewerContext,
 } from '@expo/entity';
-import { Knex } from 'knex';
+import type { Knex } from 'knex';
 
 type InvalidTestEntityFields = {
   id: number;

package/src/__testfixtures__/PostgresTestEntity.ts

@@ -1,21 +1,20 @@
+import type { EntityCompanionDefinition, ViewerContext } from '@expo/entity';
 import {
   AlwaysAllowPrivacyPolicyRule,
   BooleanField,
+  BufferField,
   DateField,
-  EntityCompanionDefinition,
   EntityConfiguration,
   EntityPrivacyPolicy,
   JSONObjectField,
   StringArrayField,
   StringField,
   UUIDField,
-  ViewerContext,
-  BufferField,
 } from '@expo/entity';
-import { Knex } from 'knex';
+import type { Knex } from 'knex';
 
-import { BigIntField, JSONArrayField, MaybeJSONArrayField } from '../EntityFields';
-import { PostgresEntity } from '../PostgresEntity';
+import { BigIntField, JSONArrayField, MaybeJSONArrayField } from '../EntityFields.ts';
+import { PostgresEntity } from '../PostgresEntity.ts';
 
 export type PostgresTestEntityFields = {
   id: string;

package/src/__testfixtures__/PostgresTriggerTestEntity.ts

@@ -1,18 +1,20 @@
+import type {
+  EntityCompanionDefinition,
+  EntityQueryContext,
+  EntityTriggerMutationInfo,
+  ViewerContext,
+} from '@expo/entity';
 import {
   AlwaysAllowPrivacyPolicyRule,
   Entity,
-  EntityCompanionDefinition,
   EntityConfiguration,
   EntityMutationTrigger,
   EntityNonTransactionalMutationTrigger,
   EntityPrivacyPolicy,
-  EntityQueryContext,
-  EntityTriggerMutationInfo,
   StringField,
   UUIDField,
-  ViewerContext,
 } from '@expo/entity';
-import { Knex } from 'knex';
+import type { Knex } from 'knex';
 
 type PostgresTriggerTestEntityFields = {
   id: string;

package/src/__testfixtures__/PostgresUniqueTestEntity.ts

@@ -1,15 +1,17 @@
+import type {
+  EntityCompanionDefinition,
+  EntityTransactionalQueryContext,
+  ViewerContext,
+} from '@expo/entity';
 import {
   AlwaysAllowPrivacyPolicyRule,
   Entity,
-  EntityCompanionDefinition,
   EntityConfiguration,
   EntityPrivacyPolicy,
-  EntityTransactionalQueryContext,
   StringField,
   UUIDField,
-  ViewerContext,
 } from '@expo/entity';
-import { Knex } from 'knex';
+import type { Knex } from 'knex';
 
 type PostgresUniqueTestEntityFields = {
   id: string;

package/src/__testfixtures__/PostgresValidatorTestEntity.ts

@@ -1,17 +1,19 @@
+import type {
+  EntityCompanionDefinition,
+  EntityQueryContext,
+  EntityValidatorMutationInfo,
+  ViewerContext,
+} from '@expo/entity';
 import {
   AlwaysAllowPrivacyPolicyRule,
   Entity,
-  EntityCompanionDefinition,
   EntityConfiguration,
   EntityMutationTrigger,
   EntityPrivacyPolicy,
-  EntityQueryContext,
-  EntityValidatorMutationInfo,
   StringField,
   UUIDField,
-  ViewerContext,
 } from '@expo/entity';
-import { Knex } from 'knex';
+import type { Knex } from 'knex';
 
 type PostgresValidatorTestEntityFields = {
   id: string;

package/src/__testfixtures__/createKnexIntegrationTestEntityCompanionProvider.ts

@@ -1,13 +1,10 @@
-import {
-  EntityCompanionProvider,
-  IEntityMetricsAdapter,
-  NoOpEntityMetricsAdapter,
-} from '@expo/entity';
+import type { IEntityMetricsAdapter } from '@expo/entity';
+import { EntityCompanionProvider, NoOpEntityMetricsAdapter } from '@expo/entity';
 import { InMemoryFullCacheStubCacheAdapterProvider } from '@expo/entity-testing-utils';
-import { Knex } from 'knex';
+import type { Knex } from 'knex';
 
-import { PostgresEntityDatabaseAdapterProvider } from '../PostgresEntityDatabaseAdapterProvider';
-import { PostgresEntityQueryContextProvider } from '../PostgresEntityQueryContextProvider';
+import { PostgresEntityDatabaseAdapterProvider } from '../PostgresEntityDatabaseAdapterProvider.ts';
+import { PostgresEntityQueryContextProvider } from '../PostgresEntityQueryContextProvider.ts';
 
 export const createKnexIntegrationTestEntityCompanionProvider = (
   knex: Knex,

package/src/__tests__/AuthorizationResultBasedKnexEntityLoader-test.ts

@@ -1,32 +1,30 @@
-import {
+import type {
   EntityPrivacyPolicyEvaluationContext,
-  ViewerContext,
-  enforceResultsAsync,
-  IEntityMetricsAdapter,
-  EntityConstructionUtils,
   EntityQueryContext,
+  IEntityMetricsAdapter,
 } from '@expo/entity';
+import { enforceResultsAsync, EntityConstructionUtils, ViewerContext } from '@expo/entity';
 import { describe, expect, it } from '@jest/globals';
 import { anyOfClass, anything, instance, mock, spy, verify, when } from 'ts-mockito';
 import { v4 as uuidv4 } from 'uuid';
 
-import { AuthorizationResultBasedKnexEntityLoader } from '../AuthorizationResultBasedKnexEntityLoader';
-import { OrderByOrdering } from '../BasePostgresEntityDatabaseAdapter';
-import { PaginationStrategy } from '../PaginationStrategy';
-import { sql } from '../SQLOperator';
+import { AuthorizationResultBasedKnexEntityLoader } from '../AuthorizationResultBasedKnexEntityLoader.ts';
+import { OrderByOrdering } from '../BasePostgresEntityDatabaseAdapter.ts';
+import { PaginationStrategy } from '../PaginationStrategy.ts';
+import { sql } from '../SQLOperator.ts';
+import { EntityKnexDataManager } from '../internal/EntityKnexDataManager.ts';
+import type { TestFields } from './fixtures/TestEntity.ts';
 import {
   TestEntity,
   testEntityConfiguration,
   TestEntityPrivacyPolicy,
-  TestFields,
-} from './fixtures/TestEntity';
+} from './fixtures/TestEntity.ts';
+import type { TestPaginationFields } from './fixtures/TestPaginationEntity.ts';
 import {
   TestPaginationEntity,
   testPaginationEntityConfiguration,
   TestPaginationPrivacyPolicy,
-  TestPaginationFields,
-} from './fixtures/TestPaginationEntity';
-import { EntityKnexDataManager } from '../internal/EntityKnexDataManager';
+} from './fixtures/TestPaginationEntity.ts';
 
 describe(AuthorizationResultBasedKnexEntityLoader, () => {
   it('loads entities with loadManyByFieldEqualityConjunction', async () => {

package/src/__tests__/BasePostgresEntityDatabaseAdapter-test.ts

@@ -1,13 +1,15 @@
-import { EntityQueryContext, FieldTransformerMap } from '@expo/entity';
+import type { FieldTransformerMap } from '@expo/entity';
+import { EntityQueryContext } from '@expo/entity';
 import { describe, expect, it } from '@jest/globals';
 import { instance, mock } from 'ts-mockito';
 
-import {
-  BasePostgresEntityDatabaseAdapter,
+import type {
   TableFieldMultiValueEqualityCondition,
   TableFieldSingleValueEqualityCondition,
-} from '../BasePostgresEntityDatabaseAdapter';
-import { testEntityConfiguration, TestFields } from './fixtures/TestEntity';
+} from '../BasePostgresEntityDatabaseAdapter.ts';
+import { BasePostgresEntityDatabaseAdapter } from '../BasePostgresEntityDatabaseAdapter.ts';
+import type { TestFields } from './fixtures/TestEntity.ts';
+import { testEntityConfiguration } from './fixtures/TestEntity.ts';
 
 class TestEntityDatabaseAdapter extends BasePostgresEntityDatabaseAdapter<
   TestFields,

package/src/__tests__/EnforcingKnexEntityLoader-test.ts

@@ -1,4 +1,5 @@
-import { EntityConstructionUtils, EntityQueryContext, IEntityMetricsAdapter } from '@expo/entity';
+import type { IEntityMetricsAdapter } from '@expo/entity';
+import { EntityConstructionUtils, EntityQueryContext } from '@expo/entity';
 import { result } from '@expo/results';
 import { describe, expect, it } from '@jest/globals';
 import { anything, instance, mock, when } from 'ts-mockito';
@@ -6,11 +7,11 @@ import { anything, instance, mock, when } from 'ts-mockito';
 import {
   AuthorizationResultBasedKnexEntityLoader,
   AuthorizationResultBasedSQLQueryBuilder,
-} from '../AuthorizationResultBasedKnexEntityLoader';
-import { EnforcingKnexEntityLoader } from '../EnforcingKnexEntityLoader';
-import { PaginationStrategy } from '../PaginationStrategy';
-import { sql } from '../SQLOperator';
-import { EntityKnexDataManager } from '../internal/EntityKnexDataManager';
+} from '../AuthorizationResultBasedKnexEntityLoader.ts';
+import { EnforcingKnexEntityLoader } from '../EnforcingKnexEntityLoader.ts';
+import { PaginationStrategy } from '../PaginationStrategy.ts';
+import { sql } from '../SQLOperator.ts';
+import { EntityKnexDataManager } from '../internal/EntityKnexDataManager.ts';
 
 describe(EnforcingKnexEntityLoader, () => {
   describe('loadFirstByFieldEqualityConjunction', () => {

package/src/__tests__/EntityFields-test.ts

@@ -1,6 +1,6 @@
 import { describeFieldTestCase } from '@expo/entity-testing-utils';
 
-import { BigIntField, JSONArrayField, MaybeJSONArrayField } from '../EntityFields';
+import { BigIntField, JSONArrayField, MaybeJSONArrayField } from '../EntityFields.ts';
 
 describeFieldTestCase(
   new JSONArrayField({ columnName: 'wat' }),

package/src/__tests__/PostgresEntity-test.ts

@@ -1,6 +1,6 @@
+import type { EntityCompanionDefinition } from '@expo/entity';
 import {
   AlwaysAllowPrivacyPolicyRule,
-  EntityCompanionDefinition,
   EntityConfiguration,
   EntityPrivacyPolicy,
   StringField,
@@ -9,11 +9,11 @@ import {
 } from '@expo/entity';
 import { describe, expect, it } from '@jest/globals';
 
-import { AuthorizationResultBasedKnexEntityLoader } from '../AuthorizationResultBasedKnexEntityLoader';
-import { EnforcingKnexEntityLoader } from '../EnforcingKnexEntityLoader';
-import { PostgresEntity } from '../PostgresEntity';
-import { ReadonlyPostgresEntity } from '../ReadonlyPostgresEntity';
-import { createUnitTestPostgresEntityCompanionProvider } from './fixtures/createUnitTestPostgresEntityCompanionProvider';
+import { AuthorizationResultBasedKnexEntityLoader } from '../AuthorizationResultBasedKnexEntityLoader.ts';
+import { EnforcingKnexEntityLoader } from '../EnforcingKnexEntityLoader.ts';
+import { PostgresEntity } from '../PostgresEntity.ts';
+import { ReadonlyPostgresEntity } from '../ReadonlyPostgresEntity.ts';
+import { createUnitTestPostgresEntityCompanionProvider } from './fixtures/createUnitTestPostgresEntityCompanionProvider.ts';
 
 type TestPostgresFields = {
   id: string;

package/src/__tests__/ReadonlyEntity-test.ts

@@ -1,11 +1,11 @@
 import { ViewerContext } from '@expo/entity';
 import { describe, expect, it } from '@jest/globals';
 
-import { AuthorizationResultBasedKnexEntityLoader } from '../AuthorizationResultBasedKnexEntityLoader';
-import { EnforcingKnexEntityLoader } from '../EnforcingKnexEntityLoader';
-import { knexLoader, knexLoaderWithAuthorizationResults } from '../knexLoader';
-import { TestEntity } from './fixtures/TestEntity';
-import { createUnitTestPostgresEntityCompanionProvider } from './fixtures/createUnitTestPostgresEntityCompanionProvider';
+import { AuthorizationResultBasedKnexEntityLoader } from '../AuthorizationResultBasedKnexEntityLoader.ts';
+import { EnforcingKnexEntityLoader } from '../EnforcingKnexEntityLoader.ts';
+import { knexLoader, knexLoaderWithAuthorizationResults } from '../knexLoader.ts';
+import { TestEntity } from './fixtures/TestEntity.ts';
+import { createUnitTestPostgresEntityCompanionProvider } from './fixtures/createUnitTestPostgresEntityCompanionProvider.ts';
 
 describe('knexLoader', () => {
   describe('knexLoader', () => {