@commitspark/graphql-api 1.0.0-beta.5 → 1.0.0-beta.7

package/package.json

@@ -9,11 +9,12 @@
     "gitops",
     "api"
   ],
-  "version": "1.0.0-beta.5",
+  "version": "1.0.0-beta.7",
   "license": "ISC",
   "private": false,
   "files": [
     "dist/**",
+    "!dist/**/*.tsbuildinfo",
     "src/**",
     "README.md",
     "LICENSE",
@@ -33,7 +34,7 @@
   "scripts": {
     "build": "npm run build:cjs && npm run build:esm && npm run build:types",
     "build:cjs": "tsc --project tsconfig.build.cjs.json",
-    "build:esm": "tsc --project tsconfig.build.esm.json",
+    "build:esm": "tsc --project tsconfig.build.esm.json && echo '{\"type\":\"module\"}' > dist/esm/package.json",
     "build:types": "tsc --project tsconfig.build.types.json",
     "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
     "lint": "eslint \"{src,tests}/**/*.ts\"",
@@ -42,7 +43,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@apollo/server": "~5.0.0",
+    "@apollo/server": "^5.2.0",
     "@commitspark/git-adapter": "^0.20.0",
     "@graphql-tools/schema": "^9.0.0",
     "@graphql-tools/utils": "^9.0.0"
@@ -54,6 +55,7 @@
     "@types/jest": "^29.5.2",
     "@types/node": "^22.14.0",
     "eslint": "^9.24.0",
+    "eslint-plugin-import": "^2.32.0",
     "globals": "^16.0.0",
     "jest": "^29.5.0",
     "jest-mock-extended": "^3.0.4",
@@ -61,7 +63,7 @@
     "prettier": "^2.4.1",
     "ts-jest": "^29.1.0",
     "ts-node": "^10.9.2",
-    "typescript": "^5.0.0",
+    "typescript": "^5.7.0",
     "typescript-eslint": "^8.29.0"
   }
 }

package/src/client.ts

@@ -1,5 +1,5 @@
-import { createApolloConfig } from './graphql/apollo-config-factory'
-import { generateSchema } from './graphql/schema-generator'
+import { createApolloConfig } from './graphql/apollo-config-factory.ts'
+import { generateSchema } from './graphql/schema-generator.ts'
 import {
   DocumentNode,
   GraphQLFormattedError,
@@ -11,7 +11,7 @@ import {
   ApolloServerOptions,
   GraphQLRequest,
 } from '@apollo/server'
-import { RepositoryCacheHandler } from './persistence/cache'
+import { RepositoryCacheHandler } from './persistence/cache.ts'
 
 export type VariableValues = { [name: string]: unknown }
 

package/src/graphql/apollo-config-factory.ts

@@ -1,6 +1,6 @@
 import { makeExecutableSchema } from '@graphql-tools/schema'
-import { generateSchema } from './schema-generator'
-import { ApolloContext } from '../client'
+import { generateSchema } from './schema-generator.ts'
+import { ApolloContext } from '../client.ts'
 import { ApolloServerOptions } from '@apollo/server'
 import { ApolloServerPluginUsageReportingDisabled } from '@apollo/server/plugin/disabled'
 

package/src/graphql/input-type-generator.ts

@@ -13,11 +13,11 @@ import {
   isScalarType,
   isUnionType,
 } from 'graphql'
-import { SchemaAnalyzerResult } from './schema-analyzer'
+import { SchemaAnalyzerResult } from './schema-analyzer.ts'
 import {
   buildsOnTypeWithEntryDirective,
   hasEntryDirective,
-} from './schema-utils/entry-type-util'
+} from './schema-utils/entry-type-util.ts'
 
 function generateFieldInputTypeString(type: GraphQLNullableType): string {
   if (isListType(type)) {

package/src/graphql/queries-mutations-generator.ts

@@ -1,13 +1,13 @@
 import { EntryData } from '@commitspark/git-adapter'
-import { ApolloContext } from '../client'
+import { ApolloContext } from '../client.ts'
 import { GraphQLFieldResolver, GraphQLObjectType } from 'graphql'
-import { queryEveryResolver } from './resolvers/query-mutation-resolvers/query-every-resolver'
-import { queryByIdResolver } from './resolvers/query-mutation-resolvers/query-by-id-resolver'
-import { mutationCreateResolver } from './resolvers/query-mutation-resolvers/mutation-create-resolver'
-import { mutationUpdateResolver } from './resolvers/query-mutation-resolvers/mutation-update-resolver'
-import { mutationDeleteResolver } from './resolvers/query-mutation-resolvers/mutation-delete-resolver'
-import { queryTypeByIdResolver } from './resolvers/query-mutation-resolvers/query-type-by-id-resolver'
-import { QueryMutationResolver } from './resolvers/types'
+import { queryEveryResolver } from './resolvers/query-mutation-resolvers/query-every-resolver.ts'
+import { queryByIdResolver } from './resolvers/query-mutation-resolvers/query-by-id-resolver.ts'
+import { mutationCreateResolver } from './resolvers/query-mutation-resolvers/mutation-create-resolver.ts'
+import { mutationUpdateResolver } from './resolvers/query-mutation-resolvers/mutation-update-resolver.ts'
+import { mutationDeleteResolver } from './resolvers/query-mutation-resolvers/mutation-delete-resolver.ts'
+import { queryTypeByIdResolver } from './resolvers/query-mutation-resolvers/query-type-by-id-resolver.ts'
+import { QueryMutationResolver } from './resolvers/types.ts'
 
 export function generateQueriesAndMutations(
   entryDirectiveTypes: GraphQLObjectType[],

package/src/graphql/resolvers/field-resolvers/entry-reference-resolver.ts

@@ -1,7 +1,7 @@
-import { FieldResolver, FieldResolverContext } from './types'
+import { FieldResolver, FieldResolverContext } from './types.ts'
 import { GraphQLResolveInfo, isNamedType } from 'graphql'
-import { findById } from '../../../persistence/persistence'
-import { createError, ErrorCode } from '../../errors'
+import { findById } from '../../../persistence/persistence.ts'
+import { createError, ErrorCode } from '../../errors.ts'
 
 export const resolveEntryReference: FieldResolver<any> = async (
   fieldValue: any,

package/src/graphql/resolvers/field-resolvers/field-default-value-resolver.ts

@@ -1,4 +1,4 @@
-import { FieldResolver, FieldResolverContext, ResolvedEntryData } from './types'
+import { FieldResolver, FieldResolverContext, ResolvedEntryData } from './types.ts'
 import { EntryData } from '@commitspark/git-adapter'
 import {
   GraphQLNonNull,
@@ -12,10 +12,10 @@ import {
 import {
   buildsOnTypeWithEntryDirective,
   hasEntryDirective,
-} from '../../schema-utils/entry-type-util'
-import { resolveEntryReference } from './entry-reference-resolver'
-import { resolveUnionValue } from './union-value-resolver'
-import { createError, ErrorCode } from '../../errors'
+} from '../../schema-utils/entry-type-util.ts'
+import { resolveEntryReference } from './entry-reference-resolver.ts'
+import { resolveUnionValue } from './union-value-resolver.ts'
+import { createError, ErrorCode } from '../../errors.ts'
 
 export const resolveFieldDefaultValue: FieldResolver<any> = async (
   fieldValue: any,

package/src/graphql/resolvers/field-resolvers/types.ts

@@ -1,7 +1,6 @@
-import { GraphQLFieldResolver } from 'graphql/type/definition'
+import { GraphQLFieldResolver, GraphQLOutputType } from 'graphql'
 import { EntryData } from '@commitspark/git-adapter'
-import { GraphQLOutputType } from 'graphql'
-import { ApolloContext } from '../../../client'
+import { ApolloContext } from '../../../client.ts'
 
 export interface FieldResolverContext extends ApolloContext {
   currentType: GraphQLOutputType

package/src/graphql/resolvers/field-resolvers/union-value-resolver.ts

@@ -1,9 +1,9 @@
 import { EntryData } from '@commitspark/git-adapter'
-import { FieldResolver, ResolvedEntryData } from './types'
+import { FieldResolver, ResolvedEntryData } from './types.ts'
 import {
   getUnionTypeNameFromFieldValue,
   getUnionValue,
-} from '../../schema-utils/union-type-util'
+} from '../../schema-utils/union-type-util.ts'
 
 export const resolveUnionValue: FieldResolver<any> = async (
   fieldValue: any,

package/src/graphql/resolvers/object-type-field-default-value-resolver-generator.ts

@@ -10,9 +10,9 @@ import {
   isUnionType,
 } from 'graphql'
 import { EntryData } from '@commitspark/git-adapter'
-import { ResolvedEntryData } from './field-resolvers/types'
-import { resolveFieldDefaultValue } from './field-resolvers/field-default-value-resolver'
-import { ApolloContext } from '../../client'
+import { ResolvedEntryData } from './field-resolvers/types.ts'
+import { resolveFieldDefaultValue } from './field-resolvers/field-default-value-resolver.ts'
+import { ApolloContext } from '../../client.ts'
 
 function requiresCustomDefaultValueResolver(type: GraphQLOutputType): boolean {
   if (isNonNullType(type)) {

package/src/graphql/resolvers/query-mutation-resolvers/mutation-create-resolver.ts

@@ -1,13 +1,13 @@
-import { findById, findByTypeId } from '../../../persistence/persistence'
+import { findById, findByTypeId } from '../../../persistence/persistence.ts'
 import { GraphQLFieldResolver, isObjectType } from 'graphql'
-import { getReferencedEntryIds } from '../../schema-utils/entry-reference-util'
+import { getReferencedEntryIds } from '../../schema-utils/entry-reference-util.ts'
 import {
   ENTRY_ID_INVALID_CHARACTERS,
   EntryData,
   EntryDraft,
 } from '@commitspark/git-adapter'
-import { QueryMutationResolverContext } from '../types'
-import { createError, ErrorCode } from '../../errors'
+import { QueryMutationResolverContext } from '../types.ts'
+import { createError, ErrorCode } from '../../errors.ts'
 
 export const mutationCreateResolver: GraphQLFieldResolver<
   any,

package/src/graphql/resolvers/query-mutation-resolvers/mutation-delete-resolver.ts

@@ -1,9 +1,9 @@
-import { findById, findByTypeId } from '../../../persistence/persistence'
+import { findById, findByTypeId } from '../../../persistence/persistence.ts'
 import { Entry, EntryData, EntryDraft } from '@commitspark/git-adapter'
-import { getReferencedEntryIds } from '../../schema-utils/entry-reference-util'
+import { getReferencedEntryIds } from '../../schema-utils/entry-reference-util.ts'
 import { GraphQLFieldResolver, isObjectType } from 'graphql'
-import { QueryMutationResolverContext } from '../types'
-import { createError, ErrorCode } from '../../errors'
+import { QueryMutationResolverContext } from '../types.ts'
+import { createError, ErrorCode } from '../../errors.ts'
 
 export const mutationDeleteResolver: GraphQLFieldResolver<
   any,

package/src/graphql/resolvers/query-mutation-resolvers/mutation-update-resolver.ts

@@ -1,9 +1,9 @@
-import { findById, findByTypeId } from '../../../persistence/persistence'
-import { getReferencedEntryIds } from '../../schema-utils/entry-reference-util'
+import { findById, findByTypeId } from '../../../persistence/persistence.ts'
+import { getReferencedEntryIds } from '../../schema-utils/entry-reference-util.ts'
 import { GraphQLFieldResolver, isObjectType } from 'graphql'
 import { EntryData, EntryDraft } from '@commitspark/git-adapter'
-import { QueryMutationResolverContext } from '../types'
-import { createError, ErrorCode } from '../../errors'
+import { QueryMutationResolverContext } from '../types.ts'
+import { createError, ErrorCode } from '../../errors.ts'
 
 function mergeData(
   existingEntryData: EntryData,

package/src/graphql/resolvers/query-mutation-resolvers/query-by-id-resolver.ts

@@ -1,7 +1,7 @@
 import { EntryData } from '@commitspark/git-adapter'
-import { findByTypeId } from '../../../persistence/persistence'
+import { findByTypeId } from '../../../persistence/persistence.ts'
 import { GraphQLFieldResolver } from 'graphql'
-import { QueryMutationResolverContext } from '../types'
+import { QueryMutationResolverContext } from '../types.ts'
 
 export const queryByIdResolver: GraphQLFieldResolver<
   any,

package/src/graphql/resolvers/query-mutation-resolvers/query-every-resolver.ts

@@ -1,7 +1,7 @@
 import { EntryData } from '@commitspark/git-adapter'
-import { findByType } from '../../../persistence/persistence'
+import { findByType } from '../../../persistence/persistence.ts'
 import { GraphQLFieldResolver } from 'graphql'
-import { QueryMutationResolverContext } from '../types'
+import { QueryMutationResolverContext } from '../types.ts'
 
 export const queryEveryResolver: GraphQLFieldResolver<
   any,

package/src/graphql/resolvers/query-mutation-resolvers/query-type-by-id-resolver.ts

@@ -1,6 +1,6 @@
-import { getTypeById } from '../../../persistence/persistence'
+import { getTypeById } from '../../../persistence/persistence.ts'
 import { GraphQLFieldResolver } from 'graphql'
-import { ApolloContext } from '../../../client'
+import { ApolloContext } from '../../../client.ts'
 
 export const queryTypeByIdResolver: GraphQLFieldResolver<
   any,

package/src/graphql/resolvers/query-mutation-resolvers/union-type-resolver.ts

@@ -1,7 +1,7 @@
-import { ApolloContext } from '../../../client'
-import { getTypeById } from '../../../persistence/persistence'
+import { ApolloContext } from '../../../client.ts'
+import { getTypeById } from '../../../persistence/persistence.ts'
 import { GraphQLTypeResolver } from 'graphql'
-import { buildsOnTypeWithEntryDirective } from '../../schema-utils/entry-type-util'
+import { buildsOnTypeWithEntryDirective } from '../../schema-utils/entry-type-util.ts'
 
 export const unionTypeResolver: GraphQLTypeResolver<
   any,

package/src/graphql/resolvers/types.ts

@@ -1,6 +1,5 @@
-import { ApolloContext } from '../../client'
-import { GraphQLNamedType } from 'graphql/type'
-import { GraphQLFieldResolver } from 'graphql'
+import { ApolloContext } from '../../client.ts'
+import { GraphQLFieldResolver, GraphQLNamedType } from 'graphql'
 
 export interface QueryMutationResolverContext extends ApolloContext {
   type: GraphQLNamedType

package/src/graphql/schema-generator.ts

@@ -1,26 +1,26 @@
 import {
   generateQueriesAndMutations,
   generateTypeNameQuery,
-} from './queries-mutations-generator'
+} from './queries-mutations-generator.ts'
 import {
   IExecutableSchemaDefinition,
   makeExecutableSchema,
 } from '@graphql-tools/schema'
-import { analyzeSchema } from './schema-analyzer'
+import { analyzeSchema } from './schema-analyzer.ts'
 import {
   generateIdInputTypeStrings,
   generateObjectInputTypeStrings,
   generateUnionInputTypeStrings,
-} from './input-type-generator'
-import { generateSchemaRootTypeStrings } from './schema-root-type-generator'
+} from './input-type-generator.ts'
+import { generateSchemaRootTypeStrings } from './schema-root-type-generator.ts'
 import { printSchemaWithDirectives } from '@graphql-tools/utils'
-import { unionTypeResolver } from './resolvers/query-mutation-resolvers/union-type-resolver'
-import { ApolloContext } from '../client'
+import { unionTypeResolver } from './resolvers/query-mutation-resolvers/union-type-resolver.ts'
+import { ApolloContext } from '../client.ts'
 import { GraphQLFieldResolver, GraphQLTypeResolver } from 'graphql'
-import { getValidationResult } from './schema-validator'
+import { getValidationResult } from './schema-validator.ts'
 import { EntryData } from '@commitspark/git-adapter'
-import { createObjectTypeFieldResolvers } from './resolvers/object-type-field-default-value-resolver-generator'
-import { createError, ErrorCode } from './errors'
+import { createObjectTypeFieldResolvers } from './resolvers/object-type-field-default-value-resolver-generator.ts'
+import { createError, ErrorCode } from './errors.ts'
 
 export async function generateSchema(
   context: ApolloContext,

package/src/graphql/schema-root-type-generator.ts

@@ -1,4 +1,4 @@
-import { GeneratedQuery, GeneratedSchema } from './queries-mutations-generator'
+import { GeneratedQuery, GeneratedSchema } from './queries-mutations-generator.ts'
 
 export function generateSchemaRootTypeStrings(
   generatedSchemas: GeneratedSchema[],

package/src/graphql/schema-utils/entry-reference-util.ts

@@ -6,14 +6,14 @@ import {
   isObjectType,
   isUnionType,
 } from 'graphql'
-import { ApolloContext } from '../../client'
-import { getTypeById } from '../../persistence/persistence'
+import { ApolloContext } from '../../client.ts'
+import { getTypeById } from '../../persistence/persistence.ts'
 import {
   getUnionTypeNameFromFieldValue,
   getUnionValue,
-} from './union-type-util'
-import { hasEntryDirective, isUnionOfEntryTypes } from './entry-type-util'
-import { createError, ErrorCode } from '../errors'
+} from './union-type-util.ts'
+import { hasEntryDirective, isUnionOfEntryTypes } from './entry-type-util.ts'
+import { createError, ErrorCode } from '../errors.ts'
 
 function isPermittedReferenceType(
   referencedTypeName: string,

package/src/graphql/schema-utils/union-type-util.ts

@@ -1,5 +1,5 @@
 import { EntryData } from '@commitspark/git-adapter'
-import { createError, ErrorCode } from '../errors'
+import { createError, ErrorCode } from '../errors.ts'
 
 export function getUnionTypeNameFromFieldValue(fieldValue: unknown): string {
   if (typeof fieldValue !== 'object' || fieldValue === null) {

package/src/index.ts

@@ -5,10 +5,10 @@ import {
   postGraphQL,
   SchemaResponse,
   VariableValues,
-} from './client'
+} from './client.ts'
 import { GitAdapter } from '@commitspark/git-adapter'
-import { ErrorCode, ErrorMetadata } from './graphql/errors'
-import { createCacheHandler } from './persistence/cache'
+import { ErrorCode, ErrorMetadata } from './graphql/errors.ts'
+import { createCacheHandler } from './persistence/cache.ts'
 
 interface Client {
   postGraphQL<

package/src/persistence/cache.ts

@@ -1,10 +1,11 @@
 import { Entry, GitAdapterError } from '@commitspark/git-adapter'
-import { ApolloContext } from '../client'
-import { createError } from '../graphql/errors'
+import { ApolloContext } from '../client.ts'
+import { createError, ErrorCode } from '../graphql/errors.ts'
 
 type Ref = string
 type EntriesCache = Map<Ref, EntriesRecord>
 type SchemaCache = Map<Ref, string>
+type InflightEntries = Map<Ref, Promise<EntriesRecord>>
 
 interface EntriesRecord {
   byId: Map<string, Entry>
@@ -21,8 +22,10 @@ export interface RepositoryCacheHandler {
 
 const MAX_CACHE_ENTRIES = 50
 
-const getEntriesRecordByRef = async (
+// intentionally not async so that the same in-flight promise is returned to all callers
+const getEntriesRecordByRef = (
   entriesCache: EntriesCache,
+  inflightEntries: InflightEntries,
   cacheSize: number,
   context: ApolloContext,
   ref: string,
@@ -33,9 +36,32 @@ const getEntriesRecordByRef = async (
     entriesCache.delete(ref)
     entriesCache.set(ref, cacheRecord)
 
-    return cacheRecord
+    return Promise.resolve(cacheRecord)
   }
 
+  const inflightPromise = inflightEntries.get(ref)
+  if (inflightPromise) {
+    return inflightPromise
+  }
+
+  const fetchPromise = fetchAndCacheEntries(
+    entriesCache,
+    cacheSize,
+    context,
+    ref,
+  ).finally(() => inflightEntries.delete(ref))
+
+  inflightEntries.set(ref, fetchPromise)
+
+  return fetchPromise
+}
+
+const fetchAndCacheEntries = async (
+  entriesCache: EntriesCache,
+  cacheSize: number,
+  context: ApolloContext,
+  ref: string,
+): Promise<EntriesRecord> => {
   let allEntries: Entry[]
   try {
     allEntries = await context.gitAdapter.getEntries(ref)
@@ -43,14 +69,16 @@ const getEntriesRecordByRef = async (
     if (err instanceof GitAdapterError) {
       throw createError(err.message, err.code, {})
     }
-    throw err
+    const message = err instanceof Error ? err.message : String(err)
+    throw createError(message, ErrorCode.INTERNAL_ERROR, {})
   }
+
   const entriesById = new Map(allEntries.map((entry) => [entry.id, entry]))
   const entriesByType = new Map<string, Entry[]>()
   for (const entry of allEntries) {
-    const arr = entriesByType.get(entry.metadata.type) || []
-    arr.push(entry)
-    entriesByType.set(entry.metadata.type, arr)
+    const existingEntriesOfType = entriesByType.get(entry.metadata.type) || []
+    existingEntriesOfType.push(entry)
+    entriesByType.set(entry.metadata.type, existingEntriesOfType)
   }
 
   const newCacheRecord = {
@@ -93,7 +121,8 @@ const getSchemaStringByRef = async (
     if (err instanceof GitAdapterError) {
       throw createError(err.message, err.code, {})
     }
-    throw err
+    const message = err instanceof Error ? err.message : String(err)
+    throw createError(message, ErrorCode.INTERNAL_ERROR, {})
   }
 
   schemaCache.set(ref, schemaString)
@@ -114,9 +143,13 @@ export const createCacheHandler = (
 ): RepositoryCacheHandler => {
   const entriesCache: EntriesCache = new Map<Ref, EntriesRecord>()
   const schemaCache: SchemaCache = new Map<Ref, string>()
+  const inflightEntries: InflightEntries = new Map<
+    Ref,
+    Promise<EntriesRecord>
+  >()
   return {
     getEntriesRecord: (...args) =>
-      getEntriesRecordByRef(entriesCache, cacheSize, ...args),
+      getEntriesRecordByRef(entriesCache, inflightEntries, cacheSize, ...args),
     getSchema: (...args) =>
       getSchemaStringByRef(schemaCache, cacheSize, ...args),
   }

package/src/persistence/persistence.ts

@@ -1,6 +1,6 @@
 import { Entry } from '@commitspark/git-adapter'
-import { createError, ErrorCode } from '../graphql/errors'
-import { ApolloContext } from '../client'
+import { createError, ErrorCode } from '../graphql/errors.ts'
+import { ApolloContext } from '../client.ts'
 
 export async function getTypeById(
   context: ApolloContext,