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

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

      if (resolverElement.config.findAll) {
        const findAllField = getFieldName(resolverElement.name, GraphbackOperationType.FIND_ALL, 's');
        // tslint:disable-next-line: no-any
        resolvers.Query[findAllField] = (parent: any, args: any, context: any) => {
          return this.service.findAll(objectName, context)
        }
      }
      if (resolverElement.config.find) {
        const findField = getFieldName(resolverElement.name, GraphbackOperationType.FIND, 's');
        // tslint:disable-next-line: no-any
        resolvers.Query[findField] = (parent: any, args: any, context: any) => {
          return this.service.findBy(objectName, args.fields, context)
        }
      }

      this.createSubscriptions(resolverElement, resolvers, objectName)
    }

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

    if (t.config.find) {
      queries.push({
        name: getFieldName(t.name, GraphbackOperationType.FIND, 's'),
        implementation: findQueryTS(t, imports)
      })
    }

    if (t.config.findAll) {
      queries.push({
        name: getFieldName(t.name, GraphbackOperationType.FIND_ALL, 's'),
        implementation: findAllQueryTS(t, imports)
      })
    }
  })

export const findAllQuery = (t: InputModelTypeContext) => {
  const fieldName = getFieldName(t.name, GraphbackOperationType.FIND_ALL, 's')

  return `query ${fieldName} {
    ${fieldName} {
      ...${t.name}Fields
    }
  }`
}

types.forEach((t: InputModelTypeContext) => {

    if (t.config.find) {
      queries.push({
        name: getFieldName(t.name, GraphbackOperationType.FIND),
        implementation: findQuery(t)
      })
    }

    if (t.config.findAll) {
      queries.push({
        name: getFieldName(t.name, GraphbackOperationType.FIND_ALL, 's'),
        implementation: findAllQuery(t)
      })
    }
  })

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

      return `${fieldName}: [${t.name}!]!`
    })
}

const findAllResolver = (t: InputModelTypeContext): string | undefined => {
  if (t.config.findAll) {
    return templates.findAllTemplate(getFieldName(t.name, GraphbackOperationType.FIND_ALL, 's'), t.name)
  }

  return undefined
}

const findAllQueryTS = (t: InputModelTypeContext, imports: string) => {
  const fieldName = getFieldName(t.name, GraphbackOperationType.FIND_ALL, 's')

  return `${imports}

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

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