@commitspark/graphql-api 2.0.0-beta.3 → 2.0.0-beta.4

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

@@ -1,6 +1,7 @@
 import {
   GraphQLNullableType,
   GraphQLObjectType,
+  GraphQLSchema,
   GraphQLUnionType,
   isListType,
   isNonNullType,
@@ -10,6 +11,7 @@ import {
 } from 'graphql'
 import { ApolloContext } from '../../client.ts'
 import { getTypeById } from '../../persistence/persistence.ts'
+import { EntriesRecord } from '../../persistence/cache.ts'
 import {
   getUnionTypeNameFromFieldValue,
   getUnionValue,
@@ -20,173 +22,172 @@ import { createError, ErrorCode } from '../errors.ts'
 import { EntryData } from '@commitspark/git-adapter'
 import { isEntryData } from '../util.ts'
 
-function isPermittedReferenceType(
-  referencedTypeName: string,
-  fieldType: GraphQLNullableType,
-): boolean {
-  if (isNonNullType(fieldType)) {
-    return isPermittedReferenceType(referencedTypeName, fieldType.ofType)
-  } else if (isListType(fieldType)) {
-    return isPermittedReferenceType(referencedTypeName, fieldType.ofType)
-  } else if (isUnionType(fieldType)) {
-    return fieldType
-      .getTypes()
-      .map((concreteType) => concreteType.name)
-      .includes(referencedTypeName)
-  } else if (isObjectType(fieldType)) {
-    return fieldType.name === referencedTypeName
-  }
-  return false
+interface EntryReference {
+  id: string
+  fieldName: string
+  fieldType: GraphQLObjectType | GraphQLUnionType
 }
 
-async function validateReference(
+type ReferencedByIndex = Map<string, string[]>
+
+// commits are immutable, so an index built from the cached entries of a commit stays valid for as long as these
+// entries remain cached
+const referencedByIndexes = new WeakMap<EntriesRecord, ReferencedByIndex>()
+
+export async function validateEntryReferences(
+  entryType: GraphQLObjectType,
   context: ApolloContext,
-  fieldName: string,
-  fieldType: GraphQLNullableType,
-  fieldValue: EntryData,
+  data: EntryData,
 ): Promise<void> {
-  if (isNonNullType(fieldType)) {
-    await validateReference(context, fieldName, fieldType.ofType, fieldValue)
-    return
-  }
-
-  if (isListType(fieldType)) {
-    if (!Array.isArray(fieldValue)) {
+  for (const reference of getEntryReferences(entryType, data)) {
+    let referencedTypeName
+    try {
+      referencedTypeName = await getTypeById(context, reference.id)
+    } catch {
       throw createError(
-        `Expected array while validation references for field "${fieldName}".`,
-        ErrorCode.BAD_REPOSITORY_DATA,
+        `Failed to resolve entry reference "${reference.id}".`,
+        ErrorCode.BAD_USER_INPUT,
         {
-          fieldName: fieldName,
-          fieldValue: fieldValue,
+          fieldName: reference.fieldName,
+          fieldValue: reference.id,
         },
       )
     }
-    for (const fieldListElement of fieldValue) {
-      await validateReference(
-        context,
-        fieldName,
-        fieldType.ofType,
-        fieldListElement,
+    if (!isPermittedReferenceType(referencedTypeName, reference.fieldType)) {
+      throw createError(
+        `Reference with ID "${reference.id}" points to entry of incompatible type "${referencedTypeName}".`,
+        ErrorCode.BAD_USER_INPUT,
+        {
+          fieldName: reference.fieldName,
+          fieldValue: reference.id,
+        },
       )
     }
-    return
   }
+}
 
-  if (isUnionType(fieldType) || isObjectType(fieldType)) {
+export async function getReferencingEntryIds(
+  context: ApolloContext,
+  schema: GraphQLSchema,
+  id: string,
+): Promise<string[]> {
+  const entriesRecord = await context.repositoryCache.getEntriesRecord(
+    context,
+    context.getCurrentHash(),
+  )
+  let referencedByIndex = referencedByIndexes.get(entriesRecord)
+  if (referencedByIndex === undefined) {
+    referencedByIndex = buildReferencedByIndex(schema, entriesRecord)
+    referencedByIndexes.set(entriesRecord, referencedByIndex)
+  }
+  return referencedByIndex.get(id) ?? []
+}
+
+function buildReferencedByIndex(
+  schema: GraphQLSchema,
+  entriesRecord: EntriesRecord,
+): ReferencedByIndex {
+  const referencedByIndex: ReferencedByIndex = new Map()
+  for (const entry of entriesRecord.byId.values()) {
+    const entryType = schema.getType(entry.metadata.type)
     if (
-      fieldValue === null ||
-      !('id' in fieldValue) ||
-      typeof fieldValue.id !== 'string'
+      !isObjectType(entryType) ||
+      !hasDirective(entryType, ENTRY_DIRECTIVE_NAME)
     ) {
       throw createError(
-        `Expected key "id" with value of type string in data while validating reference for field "${fieldName}".`,
+        `Entry "${entry.id}" is of type "${entry.metadata.type}", which is not a type with directive ` +
+          `@${ENTRY_DIRECTIVE_NAME} in the schema.`,
         ErrorCode.BAD_REPOSITORY_DATA,
         {
-          fieldName: fieldName,
-          fieldValue: fieldValue,
+          typeName: entry.metadata.type,
+          fieldValue: entry.id,
         },
       )
     }
 
-    const referencedId = fieldValue.id
-    let referencedTypeName
-    try {
-      referencedTypeName = await getTypeById(context, referencedId)
-    } catch {
-      throw createError(
-        `Failed to resolve entry reference "${referencedId}".`,
-        ErrorCode.BAD_USER_INPUT,
-        {
-          fieldName: fieldName,
-          fieldValue: referencedId,
-        },
-      )
-    }
-    if (!isPermittedReferenceType(referencedTypeName, fieldType)) {
-      throw createError(
-        `Reference with ID "${referencedId}" points to entry of incompatible type "${referencedTypeName}".`,
-        ErrorCode.BAD_USER_INPUT,
-        {
-          fieldName: fieldName,
-          fieldValue: referencedId,
-        },
-      )
+    const referencedIds = new Set(
+      getEntryReferences(entryType, entry.data ?? null).map(
+        (reference) => reference.id,
+      ),
+    )
+    for (const referencedId of referencedIds) {
+      const referencingIds = referencedByIndex.get(referencedId) ?? []
+      referencingIds.push(entry.id)
+      referencedByIndex.set(referencedId, referencingIds)
     }
   }
+
+  for (const referencingIds of referencedByIndex.values()) {
+    referencingIds.sort()
+  }
+  return referencedByIndex
 }
 
-export async function getReferencedEntryIds(
-  rootType: GraphQLObjectType,
-  context: ApolloContext,
-  fieldName: string | null,
+function getEntryReferences(
+  entryType: GraphQLObjectType,
+  data: EntryData,
+): EntryReference[] {
+  // the fields of the entry itself are traversed directly, so that any nested @Entry type is treated as reference,
+  // including references to entries of the same type
+  return getReferencesInObjectFields(entryType, data)
+}
+
+function getReferencesInObjectFields(
+  type: GraphQLObjectType,
+  data: unknown,
+): EntryReference[] {
+  if (data === null || data === undefined) {
+    return []
+  }
+  // expect our object type to hold EntryData (i.e. an object)
+  if (!isEntryData(data) || data === null) {
+    throw createError(
+      `Expected object as data for type "${type.name}".`,
+      ErrorCode.BAD_REPOSITORY_DATA,
+      {
+        typeName: type.name,
+        fieldValue: data,
+      },
+    )
+  }
+
+  return Object.entries(type.getFields()).flatMap(([fieldName, field]) =>
+    getReferencesInField(fieldName, field.type, data[fieldName]),
+  )
+}
+
+function getReferencesInField(
+  fieldName: string,
   type: GraphQLNullableType,
   data: unknown,
-): Promise<string[]> {
+): EntryReference[] {
   if (data === null || data === undefined || isScalarType(type)) {
     return []
   }
 
   if (isNonNullType(type)) {
-    return getReferencedEntryIds(
-      rootType,
-      context,
-      fieldName,
-      type.ofType,
-      data,
-    )
+    return getReferencesInField(fieldName, type.ofType, data)
   }
 
   if (isListType(type)) {
     if (!Array.isArray(data)) {
       throw createError(
-        `Expected array as data for field "${fieldName}". `,
+        `Expected array as data for field "${fieldName}".`,
         ErrorCode.BAD_REPOSITORY_DATA,
         {
-          fieldName: fieldName ? fieldName : undefined,
+          fieldName: fieldName,
           fieldValue: data,
         },
       )
     }
-
-    let referencedEntryIds: string[] = []
-    for (const element of data) {
-      referencedEntryIds = [
-        ...referencedEntryIds,
-        ...(await getReferencedEntryIds(
-          rootType,
-          context,
-          fieldName,
-          type.ofType,
-          element,
-        )),
-      ]
-    }
-    // deduplicate
-    referencedEntryIds = [...new Set(referencedEntryIds)]
-    return referencedEntryIds
+    return data.flatMap((element) =>
+      getReferencesInField(fieldName, type.ofType, element),
+    )
   }
 
   if (isUnionType(type)) {
-    if (!isEntryData(data)) {
-      throw createError(
-        `Expected object as data for type "${type.name}".`,
-        ErrorCode.BAD_REPOSITORY_DATA,
-        {
-          typeName: type.name,
-          fieldName: fieldName ? fieldName : undefined,
-          fieldValue: data,
-        },
-      )
-    }
-
     if (isUnionOfEntryTypes(type)) {
-      const referenceId = await getValidatedReferenceId(
-        context,
-        fieldName,
-        type,
-        data,
-      )
-      return [referenceId]
+      return [createEntryReference(fieldName, type, data)]
     }
 
     const requestedUnionTypeName = getUnionTypeNameFromFieldValue(data)
@@ -203,104 +204,59 @@ export async function getReferencedEntryIds(
         ErrorCode.BAD_REPOSITORY_DATA,
         {
           typeName: type.name,
-          fieldName: fieldName ? fieldName : undefined,
+          fieldName: fieldName,
           fieldValue: data,
         },
       )
     }
-    const unionValue = getUnionValue(data)
-    return getReferencedEntryIds(
-      rootType,
-      context,
-      fieldName,
+    return getReferencesInObjectFields(
       concreteFieldUnionType,
-      unionValue,
+      getUnionValue(data),
     )
   }
 
   if (isObjectType(type)) {
-    if (
-      type.name !== rootType.name &&
-      hasDirective(type, ENTRY_DIRECTIVE_NAME)
-    ) {
-      const referenceId = await getValidatedReferenceId(
-        context,
-        fieldName,
-        type,
-        data,
-      )
-      return [referenceId]
-    } else {
-      let referencedEntryIds: string[] = []
-      for (const [fieldsKey, field] of Object.entries(type.getFields())) {
-        // expect our object type to hold EntryData (i.e. an object)
-        if (Array.isArray(data) || !isEntryData(data)) {
-          throw createError(
-            `Expected object as data for type "${type.name}".`,
-            ErrorCode.BAD_REPOSITORY_DATA,
-            {
-              typeName: type.name,
-              fieldName: field.name ? field.name : undefined,
-            },
-          )
-        }
-
-        // recursively get referenced IDs in nested data
-        const nestedResult = await getReferencedEntryIds(
-          rootType,
-          context,
-          fieldsKey,
-          field.type,
-          data[fieldsKey],
-        )
-        referencedEntryIds = [...referencedEntryIds, ...nestedResult]
-      }
-      // deduplicate
-      referencedEntryIds = [...new Set(referencedEntryIds)]
-      return referencedEntryIds
+    if (hasDirective(type, ENTRY_DIRECTIVE_NAME)) {
+      return [createEntryReference(fieldName, type, data)]
     }
+    return getReferencesInObjectFields(type, data)
   }
 
   return []
 }
 
-async function getValidatedReferenceId(
-  context: ApolloContext,
-  fieldName: string | null,
-  type: GraphQLUnionType | GraphQLObjectType,
+function createEntryReference(
+  fieldName: string,
+  fieldType: GraphQLObjectType | GraphQLUnionType,
   data: unknown,
-): Promise<string> {
+): EntryReference {
   if (
+    typeof data !== 'object' ||
     data === null ||
-    data === undefined ||
-    !isEntryData(data) ||
-    Array.isArray(data)
+    !('id' in data) ||
+    typeof data.id !== 'string'
   ) {
     throw createError(
-      `Expected object as data for field "${fieldName}" of type "${type.name}".`,
+      `Expected key "id" with value of type string in data of field "${fieldName}" of type "${fieldType.name}".`,
       ErrorCode.BAD_REPOSITORY_DATA,
       {
-        typeName: type.name,
-        fieldName: fieldName ? fieldName : undefined,
+        typeName: fieldType.name,
+        fieldName: fieldName,
         fieldValue: data,
       },
     )
   }
-  await validateReference(context, fieldName ? fieldName : '', type, data)
+  return { id: data.id, fieldName, fieldType }
+}
 
-  let referencedId = null
-  if (typeof (referencedId = data.id) !== 'string') {
-    throw createError(
-      `Expected a key "id" with value of type string in data of field "${fieldName}" of type "${type.name}"` +
-        ` after this reference was just verified to be valid.`,
-      ErrorCode.INTERNAL_ERROR,
-      {
-        typeName: type.name,
-        fieldName: fieldName ? fieldName : undefined,
-        fieldValue: data,
-      },
-    )
+function isPermittedReferenceType(
+  referencedTypeName: string,
+  fieldType: GraphQLObjectType | GraphQLUnionType,
+): boolean {
+  if (isUnionType(fieldType)) {
+    return fieldType
+      .getTypes()
+      .some((concreteType) => concreteType.name === referencedTypeName)
   }
-
-  return referencedId
+  return fieldType.name === referencedTypeName
 }

package/src/persistence/cache.ts

@@ -11,7 +11,7 @@ type ContentCache = Map<ContentHash, EntryContent>
 type SchemaCache = Map<Ref, string>
 type InflightEntries = Map<Ref, Promise<EntriesRecord>>
 
-interface EntriesRecord {
+export interface EntriesRecord {
   byId: Map<string, Entry>
   byType: Map<string, Entry[]>
 }

package/dist/types/graphql/queries-mutations-generator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"queries-mutations-generator.d.ts","sourceRoot":"","sources":["../../../src/graphql/queries-mutations-generator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAQ3C,OAAO,EACL,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,sBAAsB,CAAA;AAE7B,wBAAgB,2BAA2B,CACzC,mBAAmB,EAAE,iBAAiB,EAAE,GACvC,eAAe,EAAE,CAmGnB;AAED,wBAAgB,qBAAqB,IAAI,cAAc,CAStD;AAED,wBAAgB,mBAAmB,IAAI,oBAAoB,CAiB1D;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,EAAE,MAAM,CAAA;IACpB,oBAAoB,EAAE,MAAM,CAAA;IAC5B,QAAQ,EAAE,mBAAmB,CAAA;CAC9B;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,cAAc,CAAA;IAC1B,SAAS,EAAE,cAAc,CAAA;IACzB,cAAc,EAAE,cAAc,CAAA;IAC9B,cAAc,EAAE,cAAc,CAAA;IAC9B,cAAc,EAAE,cAAc,CAAA;CAC/B;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,qBAAqB,CAAC,SAAS,GAAG,SAAS,EAAE,GAAG,MAAM,CAAC,CAAA;CAClE"}

package/dist/types/graphql/resolvers/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/graphql/resolvers/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EACL,oBAAoB,EACpB,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAA;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAE3D,MAAM,WAAW,4BAA6B,SAAQ,aAAa;IACjE,IAAI,EAAE,gBAAgB,CAAA;CACvB;AAED,MAAM,MAAM,qBAAqB,CAAC,UAAU,IAAI,oBAAoB,CAClE,OAAO,EACP,4BAA4B,EAC5B;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,SAAS,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,EACvD,OAAO,CAAC,UAAU,CAAC,CACpB,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG,mBAAmB,CACjD,2BAA2B,EAC3B,aAAa,CACd,CAAA;AAED,KAAK,2BAA2B,GAAG,SAAS,GAAG;IAC7C,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG,oBAAoB,CACpD,OAAO,EACP,aAAa,EACb;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EACjE,OAAO,CAAC,SAAS,EAAE,CAAC,CACrB,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG,oBAAoB,CACzD,SAAS,EACT,aAAa,EACb,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACvB,OAAO,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,CACnC,CAAA"}

package/dist/types/graphql/schema-generator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema-generator.d.ts","sourceRoot":"","sources":["../../../src/graphql/schema-generator.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,2BAA2B,EAE5B,MAAM,uBAAuB,CAAA;AAU9B,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAc5C,wBAAsB,cAAc,CAClC,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,2BAA2B,CAAC,CAqItC"}

package/dist/types/graphql/schema-utils/entry-reference-util.d.ts

@@ -1,4 +0,0 @@
-import { GraphQLNullableType, GraphQLObjectType } from 'graphql';
-import { ApolloContext } from '../../client.ts';
-export declare function getReferencedEntryIds(rootType: GraphQLObjectType, context: ApolloContext, fieldName: string | null, type: GraphQLNullableType, data: unknown): Promise<string[]>;
-//# sourceMappingURL=entry-reference-util.d.ts.map

package/dist/types/graphql/schema-utils/entry-reference-util.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"entry-reference-util.d.ts","sourceRoot":"","sources":["../../../../src/graphql/schema-utils/entry-reference-util.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EAOlB,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AA2G/C,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,EAAE,aAAa,EACtB,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,IAAI,EAAE,mBAAmB,EACzB,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC,MAAM,EAAE,CAAC,CA6InB"}

package/dist/types/persistence/cache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../src/persistence/cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAmB,MAAM,0BAA0B,CAAA;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAY5C,UAAU,aAAa;IACrB,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;IACxB,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC,CAAA;CAC7B;AAOD,MAAM,WAAW,sBAAsB;IACrC,gBAAgB,EAAE,CAChB,OAAO,EAAE,aAAa,EACtB,GAAG,EAAE,MAAM,KACR,OAAO,CAAC,aAAa,CAAC,CAAA;IAC3B,SAAS,EAAE,CAAC,OAAO,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;CACpE;AA+LD,eAAO,MAAM,kBAAkB,GAC7B,YAAW,MAA0B,KACpC,sBAoBF,CAAA"}