schema.graphql

# This file was generated. Do not edit manually.

schema {
    query: Query
    mutation: Mutation
}

"Indicates an Input Object is a OneOf Input Object."
directive @oneOf on INPUT_OBJECT

interface AccessControlled {
    "The object's ACL, which includes its owner and any grants of access."
    acl: Acl!
    grants: [AccessControlEntry!]!
    owner: User!
}

interface CorePlanItem {
    childCount: NonNegativeInt!
    children: [PlanItem!]!
    descendantCount: NonNegativeInt!
    descendants: [PlanItem!]!
    id: ID!
    name: String!
    plan: Plan!
}

interface Ingredient {
    id: ID!
    labels: [String!]
    name: String!
}

interface Node {
    id: ID!
}

interface Owned {
    "The user who owns this object."
    owner: User!
}

type AccessControlEntry {
    "The level of access the user has been granted."
    level: AccessLevel!
    "The user who has been granted access to an AccessControlled object."
    user: User!
}

type Acl implements Owned {
    """

    Users granted access, by the owner. This is conceptually map, so a given
    user (the key) uniquely identifies their access level (the value).
    """
    grants: [AccessControlEntry!]!
    owner: User!
}

type Deletion {
    id: ID!
    name: String
}

type Favorite implements Node {
    id: ID!
    "The name/title of the object that is a favorite."
    name: String!
    "The ID of the object that is a favorite."
    objectId: ID!
    "The type of object that is a favorite."
    objectType: String!
    owner: User!
}

type FavoriteMutation {
    """

    Add the specified object to the current user's favorites, if not already
    present, and return the favorite.
    """
    markFavorite(objectId: ID!, objectType: String!): Favorite!
    """

    Remove the specified object from the current user's favorites, and return
    whether any action was taken to ensure this.
    """
    removeFavorite(objectId: ID!, objectType: String!): Boolean!
}

type FavoriteQuery {
    "Retrieve the current user's favorites, if any."
    all: [Favorite!]!
    "Retrieve the current user's favorite of the specified object, if exists."
    byObject(objectId: ID!, objectType: String!): Favorite
    "Retrieve the current user's favorites for the specified object type, if any."
    byType(objectType: String!): [Favorite!]!
}

type IngredientRef {
    ingredient: Ingredient
    preparation: String
    quantity: Quantity
    raw: String!
}

type Label implements Node {
    id: ID!
    "Unique label name."
    name: String!
}

type LabelsQuery {
    all: [Label!]!
}

type LibraryMutation {
    "Create a new recipe in your library, from the passed info."
    createRecipe(cookThis: Boolean, info: IngredientInfo!, photo: Upload): Recipe!
    """

    Create a new recipe in your library, from the passed info, which is based
    on the passed source recipe id.
    """
    createRecipeFrom(info: IngredientInfo!, photo: Upload, sourceRecipeId: ID!): Recipe!
    "Delete a recipe from your library."
    deleteRecipe(id: ID!): Deletion!
    history(recipeId: ID!): RecipeHistoryMutation
    """

    Set the photo for a recipe in your library, without changing any other
    info about the recipe. A photo may be set during create and/or update.
    """
    setRecipePhoto(id: ID!, photo: Upload!): Recipe!
    "Update a recipe in your library, from the passed info."
    updateRecipe(id: ID!, info: IngredientInfo!, photo: Upload): Recipe!
}

type LibraryQuery {
    getRecipeById(id: ID!): Recipe
    "Search the recipe library."
    recipes(
        """

        Cursor to find results after. This should be omitted to retrieve the
        first page.
        """
        after: Cursor,
        """

        How many recipes to return in the connection. If not specified, 10
        will be returned.
        """
        first: NonNegativeInt! = 10,
        "Ingredient(s) to include. Missing/empty means \"all\"."
        ingredients: [ID!]! = [],
        """

        The textual query to filter results by. Can include simple words, as
        well as quoted phrases.
        """
        query: String! = "",
        "The scope to search for recipes within."
        scope: LibrarySearchScope! = MINE
    ): RecipeConnection!
    """

    Recognize quantity, unit, and/or ingredient in a raw ingredient ref (aka
    item) string, and describe that structure. By default, also provide
    suggestions based on partial matches.
    """
    recognizeItem(
        """

        The position of the cursor in the raw string, used to make contextual
        suggestions. If not specified, the end of the raw string is assumed.
        """
        cursor: NonNegativeInt,
        "The raw string to recognize."
        raw: String!
    ): RecognizedItem
    suggestRecipesToCook(after: Cursor, first: NonNegativeInt! = 5): RecipeConnection!
}

type Mutation {
    favorite: FavoriteMutation
    library: LibraryMutation
    pantry: PantryMutation
    planner: PlannerMutation
}

type PageInfo {
    "The last cursor returned in this page's edges."
    endCursor: Cursor
    """

    Whether this connection has a next page, or null if included in the
    result of a backward paging operation.
    """
    hasNextPage: Boolean!
    """

    Whether this connection has a previous page, or null if included in the
    result of a forward paging operation.
    """
    hasPreviousPage: Boolean!
    "The first cursor returned in this page's edges."
    startCursor: Cursor
}

type PantryItem implements Ingredient & Node {
    """

    The number of auto-detected duplicates of this pantry item. Exactly what
    "duplicate" means is unspecified and subject to change, excepting that it
    will remain consistent with a 'duplicates:12345' search query.
    """
    duplicateCount: NonNegativeInt!
    "When this pantry item was first used."
    firstUse: DateTime!
    id: ID!
    labels: [String!]
    name: String!
    """

    The relative order this pantry item will be shown on the shopping view.
    The absolute value has no semantic, and may change arbitrarily.
    """
    storeOrder: Int
    """

    Other names this pantry item can be referred to as. E.g., an "apple" item
    may have synonym "pomme".
    """
    synonyms: [String!]
    """

    The number of times this pantry item is used, including synonyms, in both
    library recipes and on a plan.
    """
    useCount: NonNegativeInt!
}

type PantryItemConnection {
    edges: [PantryItemConnectionEdge!]!
    pageInfo: PageInfo!
}

type PantryItemConnectionEdge {
    cursor: Cursor!
    node: PantryItem!
}

type PantryMutation {
    addLabel(id: ID!, label: String!): PantryItem
    addSynonym(id: ID!, synonym: String!): PantryItem
    """

    Combine two or more pantry items, and return the result, after unifying
    synonyms, labels, and references.
    """
    combineItems(ids: [ID!]!): PantryItem
    "Delete a pantry item, which MUST be unreferenced."
    deleteItem(id: ID!): Deletion!
    removeLabel(id: ID!, label: String!): PantryItem
    removeSynonym(id: ID!, synonym: String!): PantryItem
    renameItem(id: ID!, name: String!): PantryItem
    setLabels(id: ID!, labels: [String!]!): PantryItem
    setSynonyms(id: ID!, synonyms: [String!]!): PantryItem
}

type PantryQuery {
    "Search available pantry items."
    search(
        """

        Cursor to find results after. This should be omitted to retrieve the
        first page.
        """
        after: Cursor,
        "How many items to return in the connection."
        first: NonNegativeInt = 25,
        """

        Textual query to filter items by. The exact query operation performed
        is unspecified, except that 'duplicates:12345' will return auto-detected
        duplicates of the item with id '12345'. Exactly what "duplicate" means
        is unspecified and subject to change, excepting that it will remain
        consistent with results' "duplicateCount".
        """
        query: String,
        """

        Field to sort the result by. If omitted, the sort will be stable, but
        is otherwise unspecified.
        """
        sortBy: String,
        "Direction to sort the result, ascending by default."
        sortDir: SortDir = ASC
    ): PantryItemConnection!
}

type Photo {
    focus: [Float!]
    url: String!
}

type Plan implements AccessControlled & CorePlanItem & Node & Owned {
    acl: Acl!
    bucketCount: NonNegativeInt!
    buckets: [PlanBucket!]!
    childCount: NonNegativeInt!
    children: [PlanItem!]!
    """

    The color associated with the plan, expressed as a number sign and six
    hex digits (e.g., '#F57F17').
    """
    color: String!
    descendantCount: NonNegativeInt!
    descendants: [PlanItem!]!
    grants: [AccessControlEntry!]!
    id: ID!
    name: String!
    "The plan's owner"
    owner: User!
    "A plan's plan is always itself."
    plan: Plan!
    share: ShareInfo
    """

    Retrieve all items which have been updated since the passed cutoff
    (expressed in milliseconds since the UNIX epoch). May include this plan!
    """
    updatedSince(cutoff: Long!): [CorePlanItem!]!
}

type PlanBucket {
    date: Date
    id: ID!
    name: String
    plan: Plan!
}

"Represents a single item on a plan"
type PlanItem implements CorePlanItem & Node {
    aggregate: PlanItem
    bucket: PlanBucket
    childCount: NonNegativeInt!
    children: [PlanItem!]!
    componentCount: NonNegativeInt!
    components: [PlanItem!]!
    descendantCount: NonNegativeInt!
    descendants: [PlanItem!]!
    id: ID!
    ingredient: Ingredient
    name: String!
    notes: String
    "This item's parent; follow enough and you'll always get to the plan."
    parent: CorePlanItem
    plan: Plan!
    preparation: String
    quantity: Quantity
    status: PlanItemStatus!
}

type PlannedRecipeHistory implements Node {
    doneAt: DateTime!
    id: ID!
    notes: String
    """

    The user who owns this history item, which may or may not be the recipe's
    owner.
    """
    owner: User!
    plannedAt: DateTime!
    rating: Rating
    ratingInt: PositiveInt
    "The recipe this history item is for."
    recipe: Recipe!
    status: PlanItemStatus!
}

type PlannerMutation {
    "Assign a plan item to a bucket (in the same plan)."
    assignBucket(bucketId: ID!, id: ID!): PlanItem!
    "Create a new bucket w/in a plan, with an optional name and date."
    createBucket(date: Date, name: String, planId: ID!): PlanBucket!
    """

    Create a new item under the specified parent (which may be a plan, for
    top-level items), after the specified peer item (null means 'at end'), and with
    the specified name.
    """
    createItem(afterId: ID, name: String!, parentId: ID!): PlanItem!
    "Create a new empty plan, optionally duplicating the specified source plan."
    createPlan(name: String!, sourcePlanId: ID): Plan!
    "Delete a bucket from a plan."
    deleteBucket(bucketId: ID!, planId: ID!): Deletion!
    "Delete multiple buckets from a single plan."
    deleteBuckets(bucketIds: [ID!]!, planId: ID!): [Deletion!]!
    "Deletes an item from a plan. This operation cascades."
    deleteItem(id: ID!): Deletion!
    "Deletes the given plan, and all its related data."
    deletePlan(id: ID!): Deletion!
    "Create a new plan by duplicating the specified source plan."
    duplicatePlan(name: String!, sourcePlanId: ID!): Plan!
    """

    Move the given items under the given parent, in order, optionally after a
    specific item already under that parent. The parent's info is returned.
    """
    mutateTree(afterId: ID, itemIds: [ID!]!, parentId: ID!): PlanItem!
    "Update the name of the given plan or plan item (but not bucket)."
    rename(id: ID!, name: String!): CorePlanItem!
    """

    Reorder the item/plan subitems in the same order as the passed list. If
    there are subitems not included in the list, they will not be reordered. If
    an item under a different parent is included in the list, it will be moved
    under this item.
    """
    reorderSubitems(itemIds: [ID!]!, parentId: ID!): PlanItem
    "Revokes the grant for a user w/in a plan, if one exists."
    revokeGrant(planId: ID!, userId: ID!): Plan!
    "Set the plan's color (e.g., '#F57F17'), or reset it with a null or empty string."
    setColor(color: String, planId: ID!): Plan!
    "Set the access level granted to a user w/in a plan."
    setGrant(accessLevel: AccessLevel, planId: ID!, userId: ID!): Plan!
    """

    Sets the status of the given item. This will always return the updated
    item, though it may immediately moved to the trash (in the background).
    """
    setStatus(doneAt: DateTime, id: ID!, status: PlanItemStatus!): PlanItem!
    "Update a bucket w/in a plan, by setting or clearing its name and date."
    updateBucket(bucketId: ID!, date: Date, name: String, planId: ID!): PlanBucket!
}

type PlannerQuery {
    plan(id: ID!): Plan!
    planItem(id: ID!): PlanItem!
    plans: [Plan!]!
    """

    Retrieve all items on the given plan which have been updated since the
    passed cutoff (expressed in milliseconds since the UNIX epoch). May include
    the plan itself!
    """
    updatedSince(cutoff: Long!, planId: ID!): [CorePlanItem!]!
}

type Quantity {
    quantity: Float!
    units: UnitOfMeasure
}

type Query {
    favorite: FavoriteQuery
    getCurrentUser: User
    labels: LabelsQuery
    library: LibraryQuery
    node(id: ID!): Node
    pantry: PantryQuery
    planner: PlannerQuery
}

type Recipe implements Ingredient & Node & Owned {
    calories: Int
    directions: String
    externalUrl: String
    favorite: Boolean!
    id: ID!
    ingredients(
        "Ingredient(s) to include. Missing/empty means \"all\"."
        ingredients: [ID!]! = []
    ): [IngredientRef!]!
    labels: [String!]
    name: String!
    owner: User!
    photo: Photo
    """

    Number of times this recipe has been sent to any plan, optionally
    filtered by the result status (only COMPLETED and DELETED make sense).
    """
    plannedCount(status: PlanItemStatus): Int!
    """

    History of this recipe being planned, in reverse-chronological order,
    optionally filtered by the result status (only COMPLETED and DELETED make
    sense). By default, only the five most recent records will be returned.
    """
    plannedHistory(last: NonNegativeInt = 5, status: PlanItemStatus): [PlannedRecipeHistory!]!
    """

    All subrecipes. Multiple layers of nested recipes are flattened, and the
    contextual recipe is not included.
    """
    subrecipes: [Recipe!]!
    totalTime(unit: ChronoUnit = MINUTES): Int
    yield: Int
}

type RecipeConnection {
    edges: [RecipeConnectionEdge!]!
    pageInfo: PageInfo!
}

type RecipeConnectionEdge {
    cursor: Cursor!
    node: Recipe!
}

type RecipeHistoryMutation {
    recipeId: ID!
    "Set/update the notes on this history item."
    setNotes(id: ID!, notes: String!): PlannedRecipeHistory!
    """

    Set/update the rating on this history item. Either rating OR ratingInt
    should be supplied, not both.
    """
    setRating(id: ID!, rating: Rating, ratingInt: PositiveInt): PlannedRecipeHistory!
}

"""

A suggestion for what might come next at the cursor position, along with the
target range of the raw string it would replace.
"""
type RecognitionSuggestion {
    name: String!
    target: RecognizedRange!
}

"The result of recognizing a raw ingredient ref item."
type RecognizedItem {
    "The position of the cursor in the raw string."
    cursor: NonNegativeInt!
    "Recognized ranges within the raw string."
    ranges: [RecognizedRange!]!
    "The raw string which was recognized."
    raw: String!
    """

    Suggestions of what the user might wish to insert at the current cursor
    position. If more than 'count' suggestions are available, the returned
    subset is unspecified, other than pantry items are preferred to recipes.
    """
    suggestions(count: PositiveInt! = 10): [RecognitionSuggestion!]!
}

"""

A recognized quantity in the raw string. The type indicates which of the id
or quantity fields will be non-null, if either.
"""
type RecognizedRange {
    end: NonNegativeInt!
    id: ID
    quantity: NonNegativeFloat
    start: NonNegativeInt!
    type: RecognizedRangeType!
}

type ShareInfo {
    id: ID!
    secret: String!
    slug: String!
}

type UnitOfMeasure implements Node {
    id: ID!
    name: String!
}

type User implements Node {
    email: String!
    id: ID!
    imageUrl: String
    name: String
    provider: String!
    roles: [String!]!
}

enum AccessLevel {
    ADMINISTER
    CHANGE
    VIEW
}

enum ChronoUnit {
    HOURS
    MILLIS
    MINUTES
    SECONDS
}

enum LibrarySearchScope {
    EVERYONE
    MINE
}

enum PlanItemStatus {
    ACQUIRED
    COMPLETED
    DELETED
    NEEDED
}

enum Rating {
    FIVE_STARS
    FOUR_STARS
    ONE_STAR
    THREE_STARS
    TWO_STARS
}

enum RecognizedRangeType {
    ITEM
    NEW_ITEM
    NEW_UNIT
    QUANTITY
    UNIT
    UNKNOWN
}

enum SortDir {
    ASC
    DESC
}

"The type of a cursor, an opaque string used for walking connections."
scalar Cursor

"An RFC-3339 compliant Full Date Scalar"
scalar Date

"An RFC-3339 compliant DateTime Scalar"
scalar DateTime

"A 64-bit signed integer"
scalar Long

"An Float scalar that must be greater than or equal to zero"
scalar NonNegativeFloat

"An Int scalar that must be greater than or equal to zero"
scalar NonNegativeInt

"An Int scalar that must be a positive value"
scalar PositiveInt

"A file part in a multipart request"
scalar Upload

input IngredientInfo {
    calories: Int
    directions: String
    externalUrl: String
    ingredients: [IngredientRefInfo!]
    labels: [String!]
    name: String!
    photoFocus: [Float!]
    storeOrder: Int
    totalTime: Int
    type: String!
    yield: Int
}

input IngredientRefInfo {
    ingredient: String
    ingredientId: Long
    preparation: String
    quantity: Float
    raw: String!
    units: String
    uomId: Long
}