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

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/graphql/schema-validator.ts

@@ -2,6 +2,7 @@ import {
   getNamedType,
   GraphQLSchema,
   GraphQLUnionType,
+  isNonNullType,
   isObjectType,
   isScalarType,
   Kind,
@@ -59,8 +60,28 @@ function checkSearchableDirectiveOnlyOnStringFields(
   return ''
 }
 
+function checkEntryTypesHaveIdField(schema: GraphQLSchema): string {
+  for (const type of Object.values(schema.getTypeMap())) {
+    if (!isObjectType(type) || !hasDirective(type, ENTRY_DIRECTIVE_NAME)) {
+      continue
+    }
+    const idField = type.getFields()['id']
+    if (
+      idField === undefined ||
+      !isNonNullType(idField.type) ||
+      !isScalarType(idField.type.ofType) ||
+      idField.type.ofType.name !== 'ID'
+    ) {
+      return `Type "${type.name}" must have a field "id" of type "ID!" to use "@${ENTRY_DIRECTIVE_NAME}" directive.`
+    }
+  }
+
+  return ''
+}
+
 export function getValidationResult(schema: GraphQLSchema): string[] {
   const results = []
+  results.push(checkEntryTypesHaveIdField(schema))
   results.push(checkUnionMembersConsistentUseOfEntryDirective(schema))
   results.push(checkSearchableDirectiveOnlyOnStringFields(schema))
   return results.filter((result) => result !== '')

package/src/persistence/cache.ts

@@ -1,6 +1,7 @@
-import { Entry, GitAdapterError } from '@commitspark/git-adapter'
+import { Entry } from '@commitspark/git-adapter'
 import { ApolloContext } from '../client.ts'
 import { createError, ErrorCode } from '../graphql/errors.ts'
+import { callGitAdapter } from './git-adapter-call.ts'
 
 type Ref = string
 type ContentHash = string
@@ -11,9 +12,11 @@ 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[]>
+  // content hash of each entry as reported by the Git adapter, exposed to callers as entry version
+  hashById: Map<string, ContentHash>
 }
 
 interface CommitCacheRecord {
@@ -113,7 +116,9 @@ const fetchAndCacheEntries = async (
 
   const entriesById = new Map<string, Entry>()
   const entriesByType = new Map<string, Entry[]>()
+  const hashesById = new Map<string, ContentHash>()
   for (const { id, hash } of entryHashes) {
+    hashesById.set(id, hash)
     const entry: Entry = {
       id: id,
       ...(contentByHash.get(hash) as EntryContent),
@@ -128,6 +133,7 @@ const fetchAndCacheEntries = async (
     entriesRecord: {
       byType: entriesByType,
       byId: entriesById,
+      hashById: hashesById,
     },
     contentHashes: [...contentByHash.keys()],
   }
@@ -174,18 +180,6 @@ const removeUnreferencedContent = (
   }
 }
 
-const callGitAdapter = async <T>(operation: () => Promise<T>): Promise<T> => {
-  try {
-    return await operation()
-  } catch (err) {
-    if (err instanceof GitAdapterError) {
-      throw createError(err.message, err.code, {})
-    }
-    const message = err instanceof Error ? err.message : String(err)
-    throw createError(message, ErrorCode.INTERNAL_ERROR, {})
-  }
-}
-
 const getSchemaStringByRef = async (
   schemaCache: SchemaCache,
   cacheSize: number,

package/src/persistence/commit-with-retry.ts

@@ -0,0 +1,47 @@
+import {
+  CommitDraft,
+  ErrorCode as GitAdapterErrorCode,
+  GitAdapterError,
+} from '@commitspark/git-adapter'
+import { ApolloContext } from '../client.ts'
+import { callGitAdapter, toGraphQLError } from './git-adapter-call.ts'
+
+const MAX_COMMIT_ATTEMPTS = 3
+
+/**
+ * Commits a draft that `createDraft` validates against the current commit of the request, guaranteeing that the
+ * draft is only committed on top of the exact commit it was validated against.
+ *
+ * Git adapters only move a branch if it still points to `parentSha` and otherwise throw `CONFLICT`. As most adapters
+ * can only check this for the branch as a whole, any concurrent commit to the branch between reading and committing
+ * leads to `CONFLICT`, even if it changed unrelated entries. In this case, the current commit of the request is moved
+ * to the new branch head and the draft is created and validated again, including expected entry versions and
+ * references, so that only actual conflicts are reported to the caller.
+ *
+ * Errors thrown by `createDraft` are not retried, as the draft was validated against the latest known state.
+ */
+export const commitWithRetry = async (
+  context: ApolloContext,
+  createDraft: () => Promise<CommitDraft>,
+): Promise<void> => {
+  for (let attempt = 1; ; attempt++) {
+    const commitDraft = await createDraft()
+    try {
+      const commit = await context.gitAdapter.createCommit(commitDraft)
+      context.setCurrentHash(commit.commitHash)
+      return
+    } catch (err) {
+      const isConflict =
+        err instanceof GitAdapterError &&
+        err.code === GitAdapterErrorCode.CONFLICT
+      if (!isConflict || attempt >= MAX_COMMIT_ATTEMPTS) {
+        throw toGraphQLError(err)
+      }
+    }
+
+    const headCommitHash = await callGitAdapter(() =>
+      context.gitAdapter.getLatestCommitHash(context.branch),
+    )
+    context.setCurrentHash(headCommitHash)
+  }
+}

package/src/persistence/git-adapter-call.ts

@@ -0,0 +1,27 @@
+import { GitAdapterError } from '@commitspark/git-adapter'
+import { GraphQLError } from 'graphql'
+import { createError, ErrorCode } from '../graphql/errors.ts'
+
+/**
+ * Converts an error thrown by a Git adapter to a GraphQL error, keeping the error code of a `GitAdapterError`.
+ */
+export const toGraphQLError = (err: unknown): GraphQLError => {
+  if (err instanceof GitAdapterError) {
+    return createError(err.message, err.code, {})
+  }
+  const message = err instanceof Error ? err.message : String(err)
+  return createError(message, ErrorCode.INTERNAL_ERROR, {})
+}
+
+/**
+ * Runs a Git adapter operation and converts thrown errors to GraphQL errors.
+ */
+export const callGitAdapter = async <T>(
+  operation: () => Promise<T>,
+): Promise<T> => {
+  try {
+    return await operation()
+  } catch (err) {
+    throw toGraphQLError(err)
+  }
+}

package/src/persistence/persistence.ts

@@ -60,3 +60,53 @@ export async function findByTypeId(
 
   return entryById
 }
+
+/**
+ * Returns the version of an entry, which is the content hash of the entry reported by the Git adapter. It changes
+ * whenever the stored entry changes.
+ */
+export async function getEntryVersion(
+  context: ApolloContext,
+  id: string,
+): Promise<string> {
+  const entriesRecord = await context.repositoryCache.getEntriesRecord(
+    context,
+    context.getCurrentHash(),
+  )
+  const version = entriesRecord.hashById.get(id)
+  if (version === undefined) {
+    throw createError(`No entry with ID "${id}" exists.`, ErrorCode.NOT_FOUND, {
+      argumentName: 'id',
+      argumentValue: id,
+    })
+  }
+
+  return version
+}
+
+/**
+ * Throws `CONFLICT` if an expected version is given and the entry has a different version at the current commit of
+ * the request. This lets callers detect that an entry was changed by someone else since they read it, e.g. while a
+ * user was editing the entry, instead of overwriting these changes.
+ */
+export async function assertExpectedVersion(
+  context: ApolloContext,
+  id: string,
+  expectedVersion: string | null | undefined,
+): Promise<void> {
+  if (expectedVersion === undefined || expectedVersion === null) {
+    return
+  }
+  const currentVersion = await getEntryVersion(context, id)
+  if (currentVersion !== expectedVersion) {
+    throw createError(
+      `Entry with ID "${id}" has been changed: expected version "${expectedVersion}" but current version is ` +
+        `"${currentVersion}".`,
+      ErrorCode.CONFLICT,
+      {
+        argumentName: 'expectedVersion',
+        argumentValue: expectedVersion,
+      },
+    )
+  }
+}

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

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/graphql/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AACtC,OAAO,EAAE,SAAS,IAAI,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAC3E,OAAO,EAAE,SAAS,IAAI,sBAAsB,EAAE,MAAM,6BAA6B,CAAA;AAEjF,0BAAkB,SAAS;IACzB,cAAc,mBAAmB;IACjC,SAAS,cAAc;IACvB,mBAAmB,wBAAwB;IAC3C,UAAU,eAAe;IACzB,cAAc,mBAAmB;IACjC,MAAM,WAAW;CAClB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,eAAO,MAAM,WAAW,GACtB,SAAS,MAAM,EACf,MAAM,SAAS,GAAG,mBAAmB,GAAG,sBAAsB,EAC9D,UAAU,aAAa,KACtB,YAiBF,CAAA"}

package/dist/types/graphql/input-type-generator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"input-type-generator.d.ts","sourceRoot":"","sources":["../../../src/graphql/input-type-generator.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,iBAAiB,EAEjB,gBAAgB,EAOjB,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAA;AAkC3D,wBAAgB,0BAA0B,CACxC,oBAAoB,EAAE,oBAAoB,GACzC,MAAM,EAAE,CAiBV;AAED,wBAAgB,8BAA8B,CAC5C,WAAW,EAAE,iBAAiB,EAAE,GAC/B,MAAM,EAAE,CA8BV;AAED,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,gBAAgB,EAAE,GAC7B,MAAM,EAAE,CAoBV"}

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"}