schema.graphql

# @generated SignedSource<<a370140b207472efc35632c07ab034b3>>

enum PriceSortDirection {
  LOW_TO_HIGH
  HIGH_TO_LOW
}

type POSQuery {
  """
    Lists published products for POS. Requires admin permissions so it should be used only in
    POS after logging in.
  """
  listPublishedProducts: [Product]
  getTotalCheckoutStats: PosCheckoutTotalStats
}

input PosCheckoutProductInput {
  productKey: ID!
  productUnits: Int!
  productPriceUnitAmount: Int!
  productPriceUnitAmountCurrency: SupportedCurrency!
}

type DeauthorizePayload {
  success: Boolean!
}

enum SupportedCurrency {
  MXN
}

"Root mutation of the graph."
type Mutation {
  """
    This function accepts Google ID token (after receiving it from Google Sign-In in a webapp)
    and returns authorization payload. There is no concept of sign-in and sign-up: every
    whitelisted user with a valid JWT ID token will be authorized. Invalid tokens and users
    that are not whitelisted will be rejected.

    Repeated calls will result in a new session token and deauthorization of the previous
    token (if it exist). Original session token is returned back only once and cannot be
    retrieved later (it's irreversibly hashed in the database).
  """
  authorizeWebapp(googleIdToken: String!): AuthorizeWebappPayload!
  """
    The purpose of this `deauthorize` mutation is to remove the active sessions and effectively
    make the mobile application/webapp unsigned. Applications should remove the session token
    once de-authorized.

    Repeated calls will result in failure since it's not possible to deauthorize twice.
  """
  deauthorize(sessionToken: String!): DeauthorizePayload!
  commerce: CommerceMutation!
  pos: POSMutation!
}

type ProductMultilingualTranslations {
  locale: SupportedLocale!
  name: String!
  description: String
}

type CommerceMutation {
  """
    Creates a new product.

    Note on uploading product images: image names specified in the GraphQL input must correspond
    to the uploadables (multipart/form-data) and vice versa. Requests with invalid uploadables
    will be rejected.
  """
  productCreate(clientLocale: SupportedLocale!, productMultilingualInput: ProductMultilingualInput!): ProductOrError!
  """
    Updates already existing product with new values. It requires not only product KEY but also
    product REVISION to avoid lost update situations (when someone else tried to update the
    product and this update would overwrite the latest changes).

    Note on updating product images: already existing image names must be send to the server
    otherwise they will be deleted. You can optionally specify some extra (new) images to upload
    them via uploadables. This feature will eventually be used even for images re-ordering.
  """
  productUpdate(clientLocale: SupportedLocale!, productKey: ID!, productRevision: ID!, productMultilingualInput: ProductMultilingualInput!): ProductOrError!
  """
    Archives product based on the product KEY making it effectively inaccessible. From the user
    perspective it's like deleting the product, however, internally the product still exists in
    the archive and could potentially be restored.

    Note: the product cannot be searched for and cannot be retrieved in any way (other than via
    the archive). It can also be hard deleted without prior notice.
  """
  productArchive(productKey: ID!): ProductOrError!
  """
    Publishes product based on the product KEY. Various validation requirements must be met
    before the product can be published. Published product is available outside of backoffice.
  """
  productPublish(productKey: ID!): ProductOrError!
  """
    Unpublishes product based on the product KEY. Unpublished products are available only inside
    the backoffice.
  """
  productUnpublish(productKey: ID!): ProductOrError!
}

"""
  Specifies additional visibility of the product. Each product is always visible in the backoffice
  but can additionally be displayed in POS, eshop (public) or both.
"""
enum ProductMultilingualInputVisibility {
  "Visible in eshop only (therefore it's public)." ESHOP
  "Visible in POS only (accessible to authorized users)." POS
}

enum SupportedLocale {
  en_US
  es_MX
}

type Price {
  """
    The unit amount in centavo to be charged, represented as a whole integer.
    Centavo equals ¹⁄₁₀₀ of the basic monetary unit.
  """
  unitAmount: Int!
  "Three-letter [ISO currency code](https://www.iso.org/iso-4217-currency-codes.html)."
  unitAmountCurrency: SupportedCurrency!
}

union PosCheckoutPayloadOrError = PosCheckoutPayload | PosCheckoutError

"Root query of the graph."
type Query {
  "Returns information about the current user (can be authenticated or anonymous)."
  whoami: WhoamiPayload!
  listUsers: [AnyUser!]!
  commerce: CommerceQuery!
  menu: MenuQuery!
  pos: POSQuery!
}

type WhoamiPayload {
  id: ID
  """
    Human readable type should be used only for testing purposes. The format is not guaranteed
    and can change in the future completely.
  """
  humanReadableType: String
  """
    Debug assertions indicates that the Rust server runs in a development mode (compiled without
    optimizations). FOR DEVELOPMENT ONLY!
  """
  isDebugAssertionsEnabled: Boolean!
}

type MenuQuery {
  """
    Returns a specified section of our menu. This is to maintain one source of truth (in our
    database) about the prices, descriptions, translations and similar.
  """
  menu(clientLocale: SupportedLocale!, section: MenuSections!): [Product!]!
}

type POSMutation {
  """
    This is a simplified POS checkout. We simply record what the user bought for how much and
    so on. There is almost no validation - what the client sends is what we record. This is the
    main difference from eshop checkout where we would have to verify the prices for example.

    Why not to verify that the checkout price matches the product price? It's because when
    cashier accepts the money, the product is sold for the given price and there is not time for
    price adjustments (customers would be angry if we would say "oh, actually it just got more
    expensive").
  """
  checkout(input: PosCheckoutInput!): PosCheckoutPayloadOrError!
}

union ProductOrError = Product | ProductError

type AnyUser {
  id: String!
  isActive: Boolean!
  "Name is a full name of the user (\"John Doe\")."
  name: String
  "Given name is \"John\" in \"John Doe\"."
  givenName: String
  "Family name is \"Doe\" in \"John Doe\"."
  familyName: String
  hasEmailVerified: Boolean
}

type ProductCategory {
  id: ID!
  "The product category name, meant to be displayable to the customer."
  name: String!
}

type ProductError {
  message: String!
}

type CommerceQuery {
  """
    Searches all published (publicly accessible) products. Everyone can do it without any
    special permission so it should be used on FE.
  """
  searchPublishedProducts(clientLocale: SupportedLocale!, priceSortDirection: PriceSortDirection!, searchTerm: String): [Product]
  """
    Searches all products (published and unpublished). Requires admin permissions so it should
    be used only in backoffice to administer the products.
  """
  searchAllProducts(clientLocale: SupportedLocale!, priceSortDirection: PriceSortDirection!, searchTerm: String): [Product]!
  "Returns ALL available product categories that can be applied to any product."
  searchAllProductCategories(clientLocale: SupportedLocale!): [ProductCategory]!
  "Returns one publicly available product by its key. Anyone can call this resolver."
  getPublishedProductByKey(clientLocale: SupportedLocale!, productKey: ID!): Product!
  "Only admins can call this function! It returns published OR unpublished product by its key."
  getUnpublishedProductByKey(clientLocale: SupportedLocale!, productKey: ID!): Product!
}

input ProductMultilingualInput {
  images: [ProductImageUploadable!]!
  price: ProductPriceInput!
  translations: [ProductMultilingualInputTranslations!]!
  visibility: [ProductMultilingualInputVisibility!]!
  categories: [ID!]!
}

"""

        This type should be used together with GraphQL uploads and it should hold the file names
        being uploaded. It's used together with the actual uploaded files for validation purposes.
        Only files which are defined using this scalar will be processed.

"""
scalar ProductImageUploadable

input ProductPriceInput {
  """
    The unit amount in centavo to be charged, represented as a whole integer.
    Centavo equals ¹⁄₁₀₀ of the basic monetary unit.
  """ unitAmount: Int!
  "Three-letter [ISO currency code](https://www.iso.org/iso-4217-currency-codes.html)." unitAmountCurrency: SupportedCurrency!
}

input ProductMultilingualInputTranslations {
  locale: SupportedLocale!
  name: String!
  description: String
}

type Product {
  """
    Product ID is unique in our whole GraphQL universe. Please note however, that it's not URL
    friendly.
  """
  id: ID!
  """
    Product KEY is unique only amongst other products but can potentially conflict with other
    keys of other types. Use product ID if you want truly unique value.
  """
  key: ID!
  """
    The read-only `revision` value should be used as a pre-condition for mutations, to avoid
    "lost update" situations when editing the product. That is, if a client fetches a product
    from the server, modifies it locally (but with the `revision` value untouched) and sends it
    back to the server to update the product, but meanwhile the product was changed by another
    operation, then the revisions do not match anymore and the operation is cancelled by the
    server. Without this mechanism, the client would accidentally overwrite changes made
    to the product without knowing about it.

    When an existing product is updated or replaced successfully, our database will create a
    new revision value. From a user perspective, there is just one single product revision
    present per different `key` at every point in time. There is no built-in system to
    automatically keep a history of all changes done to a product and old versions of a
    product can not be restored via the `revision` value.

    For more information see: https://www.arangodb.com/docs/stable/data-modeling-documents-document-address.html#document-revision
  """
  revision: ID!
  "The product's name, meant to be displayable to the customer."
  name: String!
  """
    The product's description, meant to be displayable to the customer. Use this field to
    optionally store a long form explanation of the product being sold for your own rendering
    purposes.
  """
  description: String
  """
    A list of images for this product, meant to be displayable to the customer. You can get
    image cover via `imageCover` field.
  """
  images: [Image!]!
  """
    Returns the most important image which should be displayed as a product cover. Other images
    are available under field `images`.
  """
  imageCover: Image
  """
    A label that represents units of this product in Stripe and on customers’ receipts and
    invoices. When set, this will be included in associated invoice line item descriptions.
  """
  unitLabel: String!
  price: Price!
  isPublished: Boolean!
  visibility: [ProductMultilingualInputVisibility!]!
  """
    Same as `translations` except for one locale: it exposes the translated variant of the
    product with localized name, description etc.
  """
  translation(locale: SupportedLocale!): ProductMultilingualTranslations
  """
    Exposes all available product translations. What is the difference between `translations`
    and `name`/`description`? Name and description are localized based on the eshop locale,
    however, translations are all the available translations ignoring the locale.
  """
  translations: [ProductMultilingualTranslations!]!
  """
    Returns ALL available product categories that can be applied to this product. You might be
    also interested in `selected_categories` which are categories previously selected for this
    product.
  """
  availableCategories(clientLocale: SupportedLocale!): [ProductCategory]!
  """
    Returns categories that were assigned to the particular product. You might be also
    interested in `available_categories` which are ALL categories available for the assignment.
  """
  selectedCategories(clientLocale: SupportedLocale!): [ProductCategory]!
}

input PosCheckoutInput {
  selectedProducts: [PosCheckoutProductInput!]!
}

type PosCheckoutError {
  message: String!
}

type AuthorizeWebappPayload {
  success: Boolean!
  "Failure message is available only when success=false."
  failureMessage: String
  """
    Session token should be send with every GraphQL request which requires auth.
    Returns `None` if the request was not successful.
  """
  sessionToken: String
}

enum MenuSections {
  COFFEE
  TEA
  MILKSHAKES
  SPECIALITIES
  DUMPLING_SWEET
  DUMPLING_SAVORY
}

type PosCheckoutPayload {
  id: ID!
}

type PosCheckoutTotalStats {
  totalCheckouts: Int!
  totalSoldUnits: Int!
  totalSoldUnitAmount: Int!
}

type Image {
  name: String!
  blurhash: String!
  url: String!
}

schema {
  query: Query
  mutation: Mutation
}