How to use the @graphback/core.GraphbackOperationType.UPDATE function in @graphback/core

for (const resolverElement of this.inputContext) {
      if (resolverElement.config.disableGen) {
        continue;
      }
      const objectName = resolverElement.name.toLowerCase();
      if (resolverElement.config.create) {
        const resolverCreateField = getFieldName(resolverElement.name, GraphbackOperationType.CREATE);
        // tslint:disable-next-line: no-any
        resolvers.Mutation[resolverCreateField] = (parent: any, args: any, context: any) => {
          return this.service.create(objectName, args.input, {
            publishEvent: resolverElement.config.subCreate
          }, context)
        }
      }
      if (resolverElement.config.update) {
        const updateField = getFieldName(resolverElement.name, GraphbackOperationType.UPDATE);
        // tslint:disable-next-line: no-any
        resolvers.Mutation[updateField] = (parent: any, args: any, context: any) => {
          return this.service.update(objectName, args.id, args.input, {
            publishEvent: resolverElement.config.subUpdate
          }, context)
        }
      }
      if (resolverElement.config.delete) {
        const deleteField = getFieldName(resolverElement.name, GraphbackOperationType.DELETE);
        // tslint:disable-next-line: no-any
        resolvers.Mutation[deleteField] = (parent: any, args: any, context: any) => {
          return this.service.delete(objectName, args.id, args.input, {
            publishEvent: resolverElement.config.subDelete
          }, context)
        }
      }

types.forEach((t: InputModelTypeContext) => {
    const imports = `import gql from "graphql-tag"
import { ${t.name}Fragment } from "../fragments/${t.name}"`

    if (t.config.create) {
      mutations.push({
        name: getFieldName(t.name, GraphbackOperationType.CREATE),
        implementation: createMutationTS(t, imports)
      })
    }

    if (t.config.update) {
      mutations.push({
        name: getFieldName(t.name, GraphbackOperationType.UPDATE),
        implementation: updateMutationTS(t, imports)
      })
    }

    if (t.config.delete) {
      mutations.push({
        name: getFieldName(t.name, GraphbackOperationType.DELETE),
        implementation: deleteMutationTS(t, imports)
      })
    }
  })

.map((t: InputModelTypeContext) => {
      const fieldName = getFieldName(t.name, GraphbackOperationType.UPDATE)

      return `${fieldName}(id: ID!, input: ${t.name}Input!): ${t.name}!`
    })
}

const updateMutationTS = (t: InputModelTypeContext, imports: string) => {
  const fieldName = getFieldName(t.name, GraphbackOperationType.UPDATE)

  return `${imports}

export const ${fieldName} = gql\`
  ${updateMutation(t)}

  \$\{${t.name}Fragment}
\`
`
}

types.forEach((t: InputModelTypeContext) => {
    if (t.config.create) {
      mutations.push({
        name: getFieldName(t.name, GraphbackOperationType.CREATE),
        implementation: createMutation(t)
      })
    }

    if (t.config.update) {
      mutations.push({
        name: getFieldName(t.name, GraphbackOperationType.UPDATE),
        implementation: updateMutation(t)
      })
    }

    if (t.config.delete) {
      mutations.push({
        name: getFieldName(t.name, GraphbackOperationType.DELETE),
        implementation: deleteMutation(t)
      })
    }
  })

const updateResolver = (t: InputModelTypeContext): string | undefined => {
  if (t.config.update) {
    return templates.updateTemplate(getFieldName(t.name, GraphbackOperationType.UPDATE), t.name, t.config.subUpdate)
  }

  return undefined
}

public subscribeToUpdate(name: string, context?: GraphbackRuntimeContext): AsyncIterator | undefined {
        if (!this.pubSub) {
            this.logger.log(`Cannot subscribe to events for ${name}`)

            throw Error(`Missing PubSub implementation in CRUDService`);
        }
        const updateSubKey = subscriptionTopicMapping(GraphbackOperationType.UPDATE, name);

        return this.pubSub.asyncIterator(updateSubKey)
    }

export const updateMutation = (t: InputModelTypeContext) => {
  const fieldName = getFieldName(t.name, GraphbackOperationType.UPDATE)

  return `mutation ${fieldName}($id: ID!, ${inputVariableFields(t)}) {
    ${fieldName}(id: $id, input: {${inputVariables(t)}}) {
      ...${t.name}Fields
    }
  }
`
}