@expo/entity-database-adapter-knex 0.54.0 → 0.57.0

package/src/__tests__/PostgresEntity-test.ts

@@ -0,0 +1,172 @@
+import {
+  AlwaysAllowPrivacyPolicyRule,
+  EntityCompanionDefinition,
+  EntityConfiguration,
+  EntityPrivacyPolicy,
+  StringField,
+  UUIDField,
+  ViewerContext,
+} 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';
+
+type TestPostgresFields = {
+  id: string;
+  name: string;
+};
+
+const testPostgresEntityConfiguration = new EntityConfiguration<TestPostgresFields, 'id'>({
+  idField: 'id',
+  tableName: 'postgres_entity_test',
+  schema: {
+    id: new UUIDField({ columnName: 'id', cache: true }),
+    name: new StringField({ columnName: 'name' }),
+  },
+  databaseAdapterFlavor: 'postgres',
+  cacheAdapterFlavor: 'redis',
+});
+
+class TestPostgresEntityPrivacyPolicy extends EntityPrivacyPolicy<
+  TestPostgresFields,
+  'id',
+  ViewerContext,
+  TestPostgresEntity
+> {
+  protected override readonly readRules = [
+    new AlwaysAllowPrivacyPolicyRule<TestPostgresFields, 'id', ViewerContext, TestPostgresEntity>(),
+  ];
+  protected override readonly createRules = [
+    new AlwaysAllowPrivacyPolicyRule<TestPostgresFields, 'id', ViewerContext, TestPostgresEntity>(),
+  ];
+  protected override readonly updateRules = [
+    new AlwaysAllowPrivacyPolicyRule<TestPostgresFields, 'id', ViewerContext, TestPostgresEntity>(),
+  ];
+  protected override readonly deleteRules = [
+    new AlwaysAllowPrivacyPolicyRule<TestPostgresFields, 'id', ViewerContext, TestPostgresEntity>(),
+  ];
+}
+
+class TestPostgresEntity extends PostgresEntity<TestPostgresFields, 'id', ViewerContext> {
+  static defineCompanionDefinition(): EntityCompanionDefinition<
+    TestPostgresFields,
+    'id',
+    ViewerContext,
+    TestPostgresEntity,
+    TestPostgresEntityPrivacyPolicy
+  > {
+    return {
+      entityClass: TestPostgresEntity,
+      entityConfiguration: testPostgresEntityConfiguration,
+      privacyPolicyClass: TestPostgresEntityPrivacyPolicy,
+    };
+  }
+}
+
+class TestReadonlyPostgresEntityPrivacyPolicy extends EntityPrivacyPolicy<
+  TestPostgresFields,
+  'id',
+  ViewerContext,
+  TestReadonlyPostgresEntity
+> {
+  protected override readonly readRules = [
+    new AlwaysAllowPrivacyPolicyRule<
+      TestPostgresFields,
+      'id',
+      ViewerContext,
+      TestReadonlyPostgresEntity
+    >(),
+  ];
+  protected override readonly createRules = [
+    new AlwaysAllowPrivacyPolicyRule<
+      TestPostgresFields,
+      'id',
+      ViewerContext,
+      TestReadonlyPostgresEntity
+    >(),
+  ];
+  protected override readonly updateRules = [
+    new AlwaysAllowPrivacyPolicyRule<
+      TestPostgresFields,
+      'id',
+      ViewerContext,
+      TestReadonlyPostgresEntity
+    >(),
+  ];
+  protected override readonly deleteRules = [
+    new AlwaysAllowPrivacyPolicyRule<
+      TestPostgresFields,
+      'id',
+      ViewerContext,
+      TestReadonlyPostgresEntity
+    >(),
+  ];
+}
+
+class TestReadonlyPostgresEntity extends ReadonlyPostgresEntity<
+  TestPostgresFields,
+  'id',
+  ViewerContext
+> {
+  static defineCompanionDefinition(): EntityCompanionDefinition<
+    TestPostgresFields,
+    'id',
+    ViewerContext,
+    TestReadonlyPostgresEntity,
+    TestReadonlyPostgresEntityPrivacyPolicy
+  > {
+    return {
+      entityClass: TestReadonlyPostgresEntity,
+      entityConfiguration: testPostgresEntityConfiguration,
+      privacyPolicyClass: TestReadonlyPostgresEntityPrivacyPolicy,
+    };
+  }
+}
+
+describe(PostgresEntity, () => {
+  describe('knexLoader', () => {
+    it('creates a new EnforcingKnexEntityLoader', () => {
+      const companionProvider = createUnitTestPostgresEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+      expect(TestPostgresEntity.knexLoader(viewerContext)).toBeInstanceOf(
+        EnforcingKnexEntityLoader,
+      );
+    });
+  });
+
+  describe('knexLoaderWithAuthorizationResults', () => {
+    it('creates a new AuthorizationResultBasedKnexEntityLoader', () => {
+      const companionProvider = createUnitTestPostgresEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+      expect(TestPostgresEntity.knexLoaderWithAuthorizationResults(viewerContext)).toBeInstanceOf(
+        AuthorizationResultBasedKnexEntityLoader,
+      );
+    });
+  });
+});
+
+describe(ReadonlyPostgresEntity, () => {
+  describe('knexLoader', () => {
+    it('creates a new EnforcingKnexEntityLoader', () => {
+      const companionProvider = createUnitTestPostgresEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+      expect(TestReadonlyPostgresEntity.knexLoader(viewerContext)).toBeInstanceOf(
+        EnforcingKnexEntityLoader,
+      );
+    });
+  });
+
+  describe('knexLoaderWithAuthorizationResults', () => {
+    it('creates a new AuthorizationResultBasedKnexEntityLoader', () => {
+      const companionProvider = createUnitTestPostgresEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+      expect(
+        TestReadonlyPostgresEntity.knexLoaderWithAuthorizationResults(viewerContext),
+      ).toBeInstanceOf(AuthorizationResultBasedKnexEntityLoader);
+    });
+  });
+});

package/src/__tests__/ReadonlyEntity-test.ts

@@ -0,0 +1,32 @@
+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';
+
+describe('knexLoader', () => {
+  describe('knexLoader', () => {
+    it('creates a new EnforcingKnexEntityLoader', async () => {
+      const companionProvider = createUnitTestPostgresEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+      expect(knexLoader(TestEntity, viewerContext)).toBeInstanceOf(EnforcingKnexEntityLoader);
+      expect(TestEntity.knexLoader(viewerContext)).toBeInstanceOf(EnforcingKnexEntityLoader);
+    });
+  });
+
+  describe('knexLoaderWithAuthorizationResults', () => {
+    it('creates a new AuthorizationResultBasedKnexEntityLoader', async () => {
+      const companionProvider = createUnitTestPostgresEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+      expect(knexLoaderWithAuthorizationResults(TestEntity, viewerContext)).toBeInstanceOf(
+        AuthorizationResultBasedKnexEntityLoader,
+      );
+      expect(TestEntity.knexLoaderWithAuthorizationResults(viewerContext)).toBeInstanceOf(
+        AuthorizationResultBasedKnexEntityLoader,
+      );
+    });
+  });
+});