feat(api): add user data source

api/src/__tests__/create-context.test.js

@@ -33,5 +33,25 @@ describe('given the create context function', () => {
 
       expect(context.userKey).toEqual('1234')
     })
+
+    it('returns object with affiliation data source', async () => {
+      const context = await createContext({
+        query: jest.fn(),
+        transaction: jest.fn(),
+        collections: [],
+        req: {
+          language: 'en',
+          headers: {
+            authorization: tokenize({parameters: {userKey: '1234'}}),
+          },
+        },
+        res: {},
+      })
+
+      expect(context.dataSources.affiliation).toBeDefined()
+      expect(context.dataSources.affiliation.byKey).toBeDefined()
+      expect(context.dataSources.affiliation.connectionsByUserId).toBeDefined()
+      expect(context.dataSources.affiliation.connectionsByOrgId).toBeDefined()
+    })
   })
 })

api/src/__tests__/initialize-loaders.test.js

@@ -28,9 +28,6 @@ describe('initializeLoaders', () => {
       'loadUserConnectionsByUserId',
       'loadUserByKey',
       'loadMyTrackerByUserId',
-      'loadAffiliationByKey',
-      'loadAffiliationConnectionsByUserId',
-      'loadAffiliationConnectionsByOrgId',
       'loadVerifiedDomainsById',
       'loadVerifiedDomainByKey',
       'loadVerifiedDomainConnections',

api/src/affiliation/data-source.js

@@ -0,0 +1,227 @@
+import {
+  loadAffiliationByKey,
+  loadAffiliationConnectionsByOrgId,
+  loadAffiliationConnectionsByUserId,
+} from './loaders'
+
+export class AffiliationDataSource {
+  constructor({ query, userKey, i18n, language, cleanseInput, transaction, collections }) {
+    this._query = query
+    this._transaction = transaction
+    this._collections = collections
+
+    this.byKey = loadAffiliationByKey({ query, userKey, i18n })
+    this.connectionsByUserId = loadAffiliationConnectionsByUserId({
+      query,
+      language,
+      userKey,
+      cleanseInput,
+      i18n,
+    })
+    this.connectionsByOrgId = loadAffiliationConnectionsByOrgId({
+      query,
+      userKey,
+      cleanseInput,
+      i18n,
+    })
+  }
+
+  async affiliationByOrgAndUser({ orgId, userId }) {
+    let affiliationCursor
+    try {
+      affiliationCursor = await this._query`
+        WITH affiliations, organizations, users
+        FOR v, e IN 1..1 OUTBOUND ${orgId} affiliations
+          FILTER e._to == ${userId}
+          RETURN e
+      `
+    } catch (err) {
+      err.affiliationDataSourceOp = 'query'
+      throw err
+    }
+
+    if (affiliationCursor.count < 1) {
+      return undefined
+    }
+
+    try {
+      return await affiliationCursor.next()
+    } catch (err) {
+      err.affiliationDataSourceOp = 'cursor'
+      throw err
+    }
+  }
+
+  async createAffiliation({ orgId, userId, permission }) {
+    const transaction = await this._transaction(this._collections)
+
+    try {
+      await transaction.step(
+        () =>
+          this._query`
+            WITH affiliations, organizations, users
+            INSERT {
+              _from: ${orgId},
+              _to: ${userId},
+              permission: ${permission},
+            } INTO affiliations
+          `,
+      )
+    } catch (err) {
+      if (typeof transaction.abort === 'function') await transaction.abort()
+      err.affiliationDataSourceOp = 'trx-step'
+      throw err
+    }
+
+    try {
+      await transaction.commit()
+    } catch (err) {
+      if (typeof transaction.abort === 'function') await transaction.abort()
+      err.affiliationDataSourceOp = 'trx-commit'
+      throw err
+    }
+  }
+
+  async createPendingAffiliation({ orgId, userId }) {
+    return this.createAffiliation({ orgId, userId, permission: 'pending' })
+  }
+
+  async updateAffiliationPermission({ affiliationKey, orgId, userId, permission }) {
+    const trx = await this._transaction(this._collections)
+
+    const edge = {
+      _from: orgId,
+      _to: userId,
+      permission,
+    }
+
+    try {
+      await trx.step(
+        async () =>
+          await this._query`
+            WITH affiliations, organizations, users
+            UPSERT { _key: ${affiliationKey} }
+              INSERT ${edge}
+              UPDATE ${edge}
+              IN affiliations
+          `,
+      )
+    } catch (err) {
+      if (typeof trx.abort === 'function') await trx.abort()
+      err.affiliationDataSourceOp = 'trx-step'
+      throw err
+    }
+
+    try {
+      await trx.commit()
+    } catch (err) {
+      if (typeof trx.abort === 'function') await trx.abort()
+      err.affiliationDataSourceOp = 'trx-commit'
+      throw err
+    }
+  }
+
+  async removeAffiliation({ orgId, userId }) {
+    const trx = await this._transaction(this._collections)
+
+    try {
+      await trx.step(
+        () =>
+          this._query`
+            WITH affiliations, organizations, users
+            FOR aff IN affiliations
+              FILTER aff._from == ${orgId}
+              FILTER aff._to == ${userId}
+              REMOVE aff IN affiliations
+              RETURN true
+        `,
+      )
+    } catch (err) {
+      if (typeof trx.abort === 'function') await trx.abort()
+      err.affiliationDataSourceOp = 'trx-step'
+      throw err
+    }
+
+    try {
+      await trx.commit()
+    } catch (err) {
+      if (typeof trx.abort === 'function') await trx.abort()
+      err.affiliationDataSourceOp = 'trx-commit'
+      throw err
+    }
+  }
+
+  async transferOrgOwnership({ orgId, fromUserId, toUserId }) {
+    const trx = await this._transaction(this._collections)
+
+    try {
+      await trx.step(
+        () =>
+          this._query`
+            WITH affiliations, organizations, users
+            FOR aff IN affiliations
+              FILTER aff._from == ${orgId}
+              FILTER aff._to == ${fromUserId}
+              UPDATE { _key: aff._key } WITH {
+                permission: "admin",
+              } IN affiliations
+              RETURN aff
+        `,
+      )
+    } catch (err) {
+      if (typeof trx.abort === 'function') await trx.abort()
+      err.affiliationDataSourceOp = 'trx-step'
+      throw err
+    }
+
+    try {
+      await trx.step(
+        () =>
+          this._query`
+            WITH affiliations, organizations, users
+            FOR aff IN affiliations
+              FILTER aff._from == ${orgId}
+              FILTER aff._to == ${toUserId}
+              UPDATE { _key: aff._key } WITH {
+                permission: "owner",
+              } IN affiliations
+              RETURN aff
+        `,
+      )
+    } catch (err) {
+      if (typeof trx.abort === 'function') await trx.abort()
+      err.affiliationDataSourceOp = 'trx-step'
+      throw err
+    }
+
+    try {
+      await trx.commit()
+    } catch (err) {
+      if (typeof trx.abort === 'function') await trx.abort()
+      err.affiliationDataSourceOp = 'trx-commit'
+      throw err
+    }
+  }
+
+  async orgAdminUserKeys({ orgId }) {
+    let orgAdminsCursor
+    try {
+      orgAdminsCursor = await this._query`
+        WITH affiliations, organizations, users
+        FOR v, e IN 1..1 OUTBOUND ${orgId} affiliations
+          FILTER e.permission IN ["admin", "owner", "super_admin"]
+          RETURN v._key
+      `
+    } catch (err) {
+      err.affiliationDataSourceOp = 'query'
+      throw err
+    }
+
+    try {
+      return await orgAdminsCursor.all()
+    } catch (err) {
+      err.affiliationDataSourceOp = 'cursor'
+      throw err
+    }
+  }
+}

api/src/affiliation/index.js

@@ -1,3 +1,4 @@
+export * from './data-source'
 export * from './loaders'
 export * from './mutations'
 export * from './objects'

api/src/affiliation/mutations/__tests__/invite-user-to-org.test.js

@@ -1,7 +1,7 @@
 import { dbNameFromFile } from 'arango-tools'
 import { ensureDatabase as ensure } from '../../../testUtilities'
 import { setupI18n } from '@lingui/core'
-import { graphql, GraphQLSchema } from 'graphql'
+import { graphql as executeGraphql, GraphQLSchema } from 'graphql'
 import { toGlobalId } from 'graphql-relay'
 
 import englishMessages from '../../../locale/en/messages'
@@ -12,11 +12,38 @@ import { createQuerySchema } from '../../../query'
 import { cleanseInput } from '../../../validators'
 import { loadOrgByKey, loadOrganizationNamesById } from '../../../organization/loaders'
 import { loadUserByKey, loadUserByUserName } from '../../../user/loaders'
+import { AffiliationDataSource } from '../../data-source'
 import dbschema from '../../../../database.json'
 import { collectionNames } from '../../../collection-names'
 
 const { DB_PASS: rootPass, DB_URL: url, SIGN_IN_KEY } = process.env
 
+const withAffiliationDataSource = (contextValue = {}) => {
+  const dataSources = contextValue.dataSources || {}
+  if (dataSources.affiliation && dataSources.auditLogs) return contextValue
+
+  return {
+    ...contextValue,
+    dataSources: {
+      ...dataSources,
+      affiliation:
+        dataSources.affiliation ||
+        new AffiliationDataSource({
+          query: contextValue.query,
+          transaction: contextValue.transaction,
+          collections: contextValue.collections,
+          userKey: contextValue.userKey,
+          i18n: contextValue.i18n,
+          language: contextValue.request?.language,
+          cleanseInput: contextValue.validators?.cleanseInput,
+        }),
+      auditLogs: dataSources.auditLogs || { logActivity: jest.fn().mockResolvedValue(undefined) },
+    },
+  }
+}
+
+const graphql = (args) => executeGraphql({ ...args, contextValue: withAffiliationDataSource(args.contextValue) })
+
 describe('invite user to org', () => {
   let query, drop, truncate, schema, collections, transaction, i18n, tokenize, user, org, userToInvite
 
@@ -1622,7 +1649,7 @@ describe('invite user to org', () => {
               query,
               collections: collectionNames,
               transaction: jest.fn().mockReturnValue({
-                step: jest.fn().mockRejectedValue('trx step err'),
+                step: jest.fn().mockRejectedValue(new Error('trx step err')),
                 abort: jest.fn(),
               }),
               userKey: 123,
@@ -1659,7 +1686,7 @@ describe('invite user to org', () => {
 
           expect(response).toEqual(error)
           expect(consoleOutput).toEqual([
-            `Transaction step error occurred while user: 123 attempted to invite user: ${userToInvite._key} to org: treasury-board-secretariat, error: trx step err`,
+            `Transaction step error occurred while user: 123 attempted to invite user: ${userToInvite._key} to org: treasury-board-secretariat, error: Error: trx step err`,
           ])
         })
       })
@@ -1700,7 +1727,7 @@ describe('invite user to org', () => {
               collections: collectionNames,
               transaction: jest.fn().mockReturnValue({
                 step: jest.fn(),
-                commit: jest.fn().mockRejectedValue('trx commit err'),
+                commit: jest.fn().mockRejectedValue(new Error('trx commit err')),
                 abort: jest.fn(),
               }),
               userKey: 123,
@@ -1740,7 +1767,7 @@ describe('invite user to org', () => {
 
           expect(response).toEqual(error)
           expect(consoleOutput).toEqual([
-            `Transaction commit error occurred while user: 123 attempted to invite user: ${userToInvite._key} to org: treasury-board-secretariat, error: trx commit err`,
+            `Transaction commit error occurred while user: 123 attempted to invite user: ${userToInvite._key} to org: treasury-board-secretariat, error: Error: trx commit err`,
           ])
         })
       })

api/src/affiliation/mutations/__tests__/leave-organization.test.js

@@ -1,7 +1,7 @@
 import { setupI18n } from '@lingui/core'
 import { dbNameFromFile } from 'arango-tools'
 import { ensureDatabase as ensure } from '../../../testUtilities'
-import { graphql, GraphQLSchema, GraphQLError } from 'graphql'
+import { graphql as executeGraphql, GraphQLSchema, GraphQLError } from 'graphql'
 import { toGlobalId } from 'graphql-relay'
 
 import englishMessages from '../../../locale/en/messages'
@@ -12,11 +12,34 @@ import { loadUserByKey } from '../../../user/loaders'
 import { cleanseInput } from '../../../validators'
 import { createMutationSchema } from '../../../mutation'
 import { createQuerySchema } from '../../../query'
+import { AffiliationDataSource } from '../../data-source'
 import dbschema from '../../../../database.json'
 import { collectionNames } from '../../../collection-names'
 
 const { DB_PASS: rootPass, DB_URL: url, SIGN_IN_KEY } = process.env
 
+const withAffiliationDataSource = (contextValue = {}) => {
+  if (contextValue.dataSources?.affiliation) return contextValue
+
+  return {
+    ...contextValue,
+    dataSources: {
+      ...(contextValue.dataSources || {}),
+      affiliation: new AffiliationDataSource({
+        query: contextValue.query,
+        transaction: contextValue.transaction,
+        collections: contextValue.collections,
+        userKey: contextValue.userKey,
+        i18n: contextValue.i18n,
+        language: contextValue.request?.language,
+        cleanseInput: contextValue.validators?.cleanseInput,
+      }),
+    },
+  }
+}
+
+const graphql = (args) => executeGraphql({ ...args, contextValue: withAffiliationDataSource(args.contextValue) })
+
 describe('given a successful leave', () => {
   let query, drop, truncate, schema, collections, transaction, i18n, user, org, domain, domain2