@commitspark/graphql-api 0.9.0 → 0.9.2

package/tests/integration/mutation/create.test.ts

@@ -1,89 +0,0 @@
-import {
-  Commit,
-  CommitDraft,
-  ContentEntry,
-  GitAdapter,
-} from '@commitspark/git-adapter'
-import { Matcher, mock } from 'jest-mock-extended'
-import { getApiService } from '../../../src'
-
-describe('"Create" mutation resolvers', () => {
-  it('should create an entry', async () => {
-    const gitAdapter = mock<GitAdapter>()
-    const gitRef = 'myRef'
-    const commitHash = 'abcd'
-    const originalSchema = `directive @Entry on OBJECT
-
-type EntryA @Entry {
-    id: ID!
-    name: String
-}`
-
-    const commitMessage = 'My message'
-    const entryAId = 'A'
-    const postCommitHash = 'ef01'
-
-    const mutationData = {
-      name: 'My name',
-    }
-    const commitResult: Commit = {
-      ref: postCommitHash,
-    }
-    const newEntry: ContentEntry = {
-      id: entryAId,
-      metadata: {
-        type: 'EntryA',
-      },
-      data: {
-        name: mutationData.name,
-      },
-    }
-
-    const commitDraft: CommitDraft = {
-      ref: gitRef,
-      parentSha: commitHash,
-      contentEntries: [{ ...newEntry, deletion: false }],
-      message: commitMessage,
-    }
-
-    const commitDraftMatcher = new Matcher<CommitDraft>((actualValue) => {
-      return JSON.stringify(actualValue) === JSON.stringify(commitDraft)
-    }, '')
-
-    gitAdapter.getLatestCommitHash
-      .calledWith(gitRef)
-      .mockResolvedValue(commitHash)
-    gitAdapter.getSchema
-      .calledWith(commitHash)
-      .mockResolvedValue(originalSchema)
-    gitAdapter.getContentEntries.calledWith(commitHash).mockResolvedValue([])
-    gitAdapter.createCommit
-      .calledWith(commitDraftMatcher)
-      .mockResolvedValue(commitResult)
-    gitAdapter.getContentEntries
-      .calledWith(postCommitHash)
-      .mockResolvedValue([newEntry])
-
-    const apiService = await getApiService()
-    const result = await apiService.postGraphQL(gitAdapter, gitRef, {
-      query: `mutation ($id: ID!, $mutationData: EntryAInput!, $commitMessage: String!){
-        data: createEntryA(id: $id, data: $mutationData, message:$commitMessage) {
-          id
-        }
-      }`,
-      variables: {
-        id: entryAId,
-        mutationData: mutationData,
-        commitMessage: commitMessage,
-      },
-    })
-
-    expect(result.errors).toBeUndefined()
-    expect(result.data).toEqual({
-      data: {
-        id: entryAId,
-      },
-    })
-    expect(result.ref).toBe(postCommitHash)
-  })
-})

package/tests/integration/mutation/delete.test.ts

@@ -1,133 +0,0 @@
-import {
-  Commit,
-  CommitDraft,
-  ContentEntry,
-  GitAdapter,
-} from '@commitspark/git-adapter'
-import { Matcher, mock } from 'jest-mock-extended'
-import { getApiService } from '../../../src'
-
-describe('"Delete" mutation resolvers', () => {
-  it('should delete an entry', async () => {
-    const gitAdapter = mock<GitAdapter>()
-    const gitRef = 'myRef'
-    const commitHash = 'abcd'
-    const originalSchema = `directive @Entry on OBJECT
-
-type EntryA @Entry {
-    id: ID!
-    name: String
-}`
-
-    const commitMessage = 'My message'
-    const entryAId = 'A'
-    const postCommitHash = 'ef01'
-
-    const commitResult: Commit = {
-      ref: postCommitHash,
-    }
-    const entry: ContentEntry = {
-      id: entryAId,
-      metadata: {
-        type: 'EntryA',
-      },
-      data: {
-        name: 'My name',
-      },
-    }
-
-    const commitDraft: CommitDraft = {
-      ref: gitRef,
-      parentSha: commitHash,
-      contentEntries: [
-        {
-          id: entryAId,
-          metadata: { type: 'EntryA' },
-          data: {},
-          deletion: true,
-        },
-      ],
-      message: commitMessage,
-    }
-
-    const commitDraftMatcher = new Matcher<CommitDraft>((actualValue) => {
-      return JSON.stringify(actualValue) === JSON.stringify(commitDraft)
-    }, '')
-
-    gitAdapter.getLatestCommitHash
-      .calledWith(gitRef)
-      .mockResolvedValue(commitHash)
-    gitAdapter.getSchema
-      .calledWith(commitHash)
-      .mockResolvedValue(originalSchema)
-    gitAdapter.getContentEntries
-      .calledWith(commitHash)
-      .mockResolvedValue([entry])
-    gitAdapter.createCommit
-      .calledWith(commitDraftMatcher)
-      .mockResolvedValue(commitResult)
-
-    const apiService = await getApiService()
-    const result = await apiService.postGraphQL(gitAdapter, gitRef, {
-      query: `mutation ($id: ID!, $commitMessage: String!){
-        data: deleteEntryA(id: $id, message:$commitMessage) {
-          id
-        }
-      }`,
-      variables: {
-        id: entryAId,
-        commitMessage: commitMessage,
-      },
-    })
-
-    expect(result.errors).toBeUndefined()
-    expect(result.data).toEqual({
-      data: {
-        id: entryAId,
-      },
-    })
-    expect(result.ref).toBe(postCommitHash)
-  })
-
-  it('should return an error when trying to delete a non-existent entry', async () => {
-    const gitAdapter = mock<GitAdapter>()
-    const gitRef = 'myRef'
-    const commitHash = 'abcd'
-    const originalSchema = `directive @Entry on OBJECT
-
-type EntryA @Entry {
-    id: ID!
-    name: String
-}`
-
-    const commitMessage = 'My message'
-    const entryAId = 'A'
-
-    gitAdapter.getLatestCommitHash
-      .calledWith(gitRef)
-      .mockResolvedValue(commitHash)
-    gitAdapter.getSchema
-      .calledWith(commitHash)
-      .mockResolvedValue(originalSchema)
-    gitAdapter.getContentEntries.calledWith(commitHash).mockResolvedValue([])
-
-    const apiService = await getApiService()
-    const result = await apiService.postGraphQL(gitAdapter, gitRef, {
-      query: `mutation ($id: ID!, $commitMessage: String!){
-        data: deleteEntryA(id: $id, message:$commitMessage) {
-          id
-        }
-      }`,
-      variables: {
-        id: entryAId,
-        commitMessage: commitMessage,
-      },
-    })
-
-    expect(result.errors).toMatchObject([
-      { extensions: { argumentName: 'id', code: 'BAD_USER_INPUT' } },
-    ])
-    expect(result.data).toEqual({ data: null })
-    expect(result.ref).toBe(commitHash)
-  })
-})

package/tests/integration/mutation/update.test.ts

@@ -1,151 +0,0 @@
-import {
-  Commit,
-  CommitDraft,
-  ContentEntry,
-  GitAdapter,
-} from '@commitspark/git-adapter'
-import { Matcher, mock } from 'jest-mock-extended'
-import { getApiService } from '../../../src'
-
-describe('"Update" mutation resolvers', () => {
-  it('should update an entry', async () => {
-    const gitAdapter = mock<GitAdapter>()
-    const gitRef = 'myRef'
-    const commitHash = 'abcd'
-    const originalSchema = `directive @Entry on OBJECT
-
-type EntryA @Entry {
-    id: ID!
-    name: String
-}`
-
-    const commitMessage = 'My message'
-    const entryAId = 'A'
-    const postCommitHash = 'ef01'
-
-    const mutationData = {
-      name: 'My name',
-    }
-    const commitResult: Commit = {
-      ref: postCommitHash,
-    }
-    const originalEntry: ContentEntry = {
-      id: entryAId,
-      metadata: {
-        type: 'EntryA',
-      },
-      data: {
-        name: `${mutationData.name}1`,
-      },
-    }
-
-    const updatedEntry: ContentEntry = {
-      id: entryAId,
-      metadata: {
-        type: 'EntryA',
-      },
-      data: {
-        name: `${mutationData.name}2`,
-      },
-    }
-
-    const commitDraft: CommitDraft = {
-      ref: gitRef,
-      parentSha: commitHash,
-      contentEntries: [{ ...updatedEntry, deletion: false }],
-      message: commitMessage,
-    }
-
-    const commitDraftMatcher = new Matcher<CommitDraft>((actualValue) => {
-      return JSON.stringify(actualValue) === JSON.stringify(commitDraft)
-    }, '')
-
-    gitAdapter.getLatestCommitHash
-      .calledWith(gitRef)
-      .mockResolvedValue(commitHash)
-    gitAdapter.getSchema
-      .calledWith(commitHash)
-      .mockResolvedValue(originalSchema)
-    gitAdapter.getContentEntries
-      .calledWith(commitHash)
-      .mockResolvedValue([originalEntry])
-    gitAdapter.createCommit
-      .calledWith(commitDraftMatcher)
-      .mockResolvedValue(commitResult)
-    gitAdapter.getContentEntries
-      .calledWith(postCommitHash)
-      .mockResolvedValue([updatedEntry])
-
-    const apiService = await getApiService()
-    const result = await apiService.postGraphQL(gitAdapter, gitRef, {
-      query: `mutation ($id: ID!, $mutationData: EntryAInput!, $commitMessage: String!){
-        data: updateEntryA(id: $id, data: $mutationData, message:$commitMessage) {
-          id
-          name
-        }
-      }`,
-      variables: {
-        id: entryAId,
-        mutationData: {
-          name: `${mutationData.name}2`,
-        },
-        commitMessage: commitMessage,
-      },
-    })
-
-    expect(result.errors).toBeUndefined()
-    expect(result.data).toEqual({
-      data: {
-        id: entryAId,
-        name: `${mutationData.name}2`,
-      },
-    })
-    expect(result.ref).toBe(postCommitHash)
-  })
-
-  it('should return an error when trying to update a non-existent entry', async () => {
-    const gitAdapter = mock<GitAdapter>()
-    const gitRef = 'myRef'
-    const commitHash = 'abcd'
-    const originalSchema = `directive @Entry on OBJECT
-
-type EntryA @Entry {
-    id: ID!
-    name: String
-}`
-
-    const commitMessage = 'My message'
-    const entryAId = 'A'
-
-    gitAdapter.getLatestCommitHash
-      .calledWith(gitRef)
-      .mockResolvedValue(commitHash)
-    gitAdapter.getSchema
-      .calledWith(commitHash)
-      .mockResolvedValue(originalSchema)
-    gitAdapter.getContentEntries.calledWith(commitHash).mockResolvedValue([])
-
-    const apiService = await getApiService()
-    const result = await apiService.postGraphQL(gitAdapter, gitRef, {
-      query: `mutation ($id: ID!, $mutationData: EntryAInput!, $commitMessage: String!){
-        data: updateEntryA(id: $id, data: $mutationData, message:$commitMessage) {
-          id
-          name
-        }
-      }`,
-      variables: {
-        id: entryAId,
-        mutationData: {
-          name: '2',
-        },
-        commitMessage: commitMessage,
-      },
-    })
-
-    expect(result.errors).toMatchObject([
-      { extensions: { argumentName: 'id', code: 'BAD_USER_INPUT' } },
-    ])
-    expect(result.data).toEqual({ data: null })
-    expect(result.ref).toBe(commitHash)
-  })
-})

package/tests/integration/query/query.test.ts

@@ -1,253 +0,0 @@
-import { ContentEntry, GitAdapter } from '@commitspark/git-adapter'
-import { mock } from 'jest-mock-extended'
-import { getApiService } from '../../../src'
-
-describe('Query resolvers', () => {
-  it('should resolve reference to a second @Entry', async () => {
-    const gitAdapter = mock<GitAdapter>()
-    const gitRef = 'myRef'
-    const commitHash = 'abcd'
-    const originalSchema = `directive @Entry on OBJECT
-
-type EntryA @Entry {
-    id: ID!
-    name: String
-}
-
-type EntryB @Entry {
-    id: ID!
-    entryA: EntryA
-}`
-
-    const entryAId = 'A'
-    const entryBId = 'B'
-
-    const entries = [
-      {
-        id: entryAId,
-        metadata: {
-          type: 'EntryA',
-        },
-        data: {
-          name: 'My name',
-        },
-      } as ContentEntry,
-      {
-        id: entryBId,
-        metadata: {
-          type: 'EntryB',
-        },
-        data: {
-          entryA: {
-            id: entryAId,
-          },
-        },
-      } as ContentEntry,
-    ]
-
-    gitAdapter.getLatestCommitHash
-      .calledWith(gitRef)
-      .mockResolvedValue(commitHash)
-    gitAdapter.getSchema
-      .calledWith(commitHash)
-      .mockResolvedValue(originalSchema)
-    gitAdapter.getContentEntries
-      .calledWith(commitHash)
-      .mockResolvedValue(entries)
-
-    const apiService = await getApiService()
-    const result = await apiService.postGraphQL(gitAdapter, gitRef, {
-      query: `query {
-        data: EntryB(id:"${entryBId}") {
-          id
-          entryA {
-            id
-            name
-          }
-        }
-      }`,
-    })
-
-    expect(result.errors).toBeUndefined()
-    expect(result.data).toEqual({
-      data: {
-        id: entryBId,
-        entryA: {
-          id: entryAId,
-          name: 'My name',
-        },
-      },
-    })
-    expect(result.ref).toBe(commitHash)
-  })
-
-  it('should resolve a non-@Entry-based union', async () => {
-    const gitAdapter = mock<GitAdapter>()
-    const gitRef = 'myRef'
-    const commitHash = 'abcd'
-    const originalSchema = `directive @Entry on OBJECT
-
-type MyEntry @Entry {
-    id: ID!
-    union: MyUnion
-}
-
-union MyUnion =
-    | TypeA
-    | TypeB
-
-type TypeA {
-    field1: String
-}
-
-type TypeB {
-    field2: String
-}`
-
-    const entryId = 'A'
-    const field2Value = 'Field2 value'
-
-    const entries = [
-      {
-        id: entryId,
-        metadata: {
-          type: 'MyEntry',
-        },
-        data: {
-          union: {
-            typeB: {
-              field2: field2Value,
-            },
-          },
-        },
-      } as ContentEntry,
-    ]
-
-    gitAdapter.getLatestCommitHash
-      .calledWith(gitRef)
-      .mockResolvedValue(commitHash)
-    gitAdapter.getSchema
-      .calledWith(commitHash)
-      .mockResolvedValue(originalSchema)
-    gitAdapter.getContentEntries
-      .calledWith(commitHash)
-      .mockResolvedValue(entries)
-
-    const apiService = await getApiService()
-    const result = await apiService.postGraphQL(gitAdapter, gitRef, {
-      query: `query {
-        data: MyEntry(id:"${entryId}") {
-          id
-          union {
-            __typename
-            ... on TypeB {
-              field2
-            }
-          }
-        }
-      }`,
-    })
-
-    expect(result.errors).toBeUndefined()
-    expect(result.data).toEqual({
-      data: {
-        id: entryId,
-        union: {
-          __typename: 'TypeB',
-          field2: field2Value,
-        },
-      },
-    })
-    expect(result.ref).toBe(commitHash)
-  })
-
-  it('should resolve an @Entry-based union', async () => {
-    const gitAdapter = mock<GitAdapter>()
-    const gitRef = 'myRef'
-    const commitHash = 'abcd'
-    const originalSchema = `directive @Entry on OBJECT
-
-type MyEntry @Entry {
-    id: ID!
-    union: MyUnion
-}
-
-union MyUnion =
-    | EntryA
-    | EntryB
-
-type EntryA @Entry {
-    id: ID!
-    field1: String
-}
-
-type EntryB @Entry {
-    id: ID!
-    field2: String
-}`
-
-    const myEntryId = 'My'
-    const entryBId = 'B'
-    const field2Value = 'Field2 value'
-
-    const entries = [
-      {
-        id: myEntryId,
-        metadata: {
-          type: 'MyEntry',
-        },
-        data: {
-          union: {
-            id: entryBId,
-          },
-        },
-      } as ContentEntry,
-      {
-        id: entryBId,
-        metadata: {
-          type: 'EntryB',
-        },
-        data: {
-          field2: field2Value,
-        },
-      } as ContentEntry,
-    ]
-
-    gitAdapter.getLatestCommitHash
-      .calledWith(gitRef)
-      .mockResolvedValue(commitHash)
-    gitAdapter.getSchema
-      .calledWith(commitHash)
-      .mockResolvedValue(originalSchema)
-    gitAdapter.getContentEntries
-      .calledWith(commitHash)
-      .mockResolvedValue(entries)
-
-    const apiService = await getApiService()
-    const result = await apiService.postGraphQL(gitAdapter, gitRef, {
-      query: `query {
-        data: MyEntry(id:"${myEntryId}") {
-          id
-          union {
-            __typename
-            ... on EntryB {
-              field2
-            }
-          }
-        }
-      }`,
-    })
-
-    expect(result.errors).toBeUndefined()
-    expect(result.data).toEqual({
-      data: {
-        id: myEntryId,
-        union: {
-          __typename: 'EntryB',
-          field2: field2Value,
-        },
-      },
-    })
-    expect(result.ref).toBe(commitHash)
-  })
-})