Product Store

Overview

Product Stores represent sales channels or marketplaces where products are sold. They define the context for product availability, pricing, and visibility - essentially, which products are offered on which sales channels and under what terms. This supports multi-channel selling where the same product might be available on your website, Amazon, eBay, and retail stores with different prices or availability on each channel.

Each product store represents a distinct sales channel. Your Shopify website is one store, your Amazon seller account is another, your physical retail location is a third. By creating separate product store records for each channel, you can manage channel-specific settings and track sales by channel. This channel tracking supports profitability analysis and marketing ROI calculation.

Product visibility by store controls where products appear. A product might be enabled for your website store but disabled for Amazon. This selective availability supports different product mixes by channel - perhaps some products are exclusive to your website, others are available everywhere. The store settings control this visibility without needing duplicate product records.

Pricing can vary by product store. A product might have a retail price of $29.99 on your website but sell for $24.99 on Amazon due to competitive pressure. Price levels and special pricing rules can be assigned to stores, letting you optimize pricing for each channel's market dynamics. This pricing flexibility is essential for competitive multi-channel selling.

Inventory allocation by store supports channel-specific stock management. You might allocate 100 units to Amazon FBA, 50 units to your Shopify store, and keep 200 units unallocated for general fulfillment. These allocations help prevent overselling when inventory is committed to specific channels that have their own fulfillment requirements.

Integration connections often tie to product stores. When you integrate with Shopify, that integration connects to your Shopify product store record. Product data flows from Finale to that specific store based on the store's settings. Order data flows from that store back to Finale, tagged with the store as the source. This store-level integration organization keeps multi-channel data flows manageable.

Sales analysis by product store answers critical business questions. Which channels are most profitable? Which products sell best on each channel? How does average order value compare across channels? By tagging transactions with their source store, the system enables this channel-level analysis that drives strategic decisions about where to invest in growth.

GraphQL API

The productStore collection provides access to productStore data via the GraphQL API. All queries use the Relay connection specification with cursor-based pagination.

Query Name: productStoreViewConnection

Available Features:

Cursor-based pagination (first/last/after/before)
4 filter options

Query Examples

Basic Query

The productStore collection is accessed via the productStoreViewConnection query, which returns a Relay-style connection with pagination support.

query {
  productStoreViewConnection(first: 10) {
    edges {
      node {
        name
        productStoreUrl
        status
      }
    }
    pageInfo {
      hasNextPage
      endCursor
    }
  }
}

Pagination

Use cursor-based pagination to retrieve large datasets:

# First page
query {
  productStoreViewConnection(first: 50) {
    edges {
      node { name }
    }
    pageInfo {
      hasNextPage
      endCursor
    }
  }
}

# Subsequent pages
query {
  productStoreViewConnection(first: 50, after: "cursor-from-previous-page") {
    edges {
      node { name }
    }
    pageInfo {
      hasNextPage
      endCursor
    }
  }
}

Filtering

Apply filters to narrow results (see Filters section for all available options):

query {
  productStoreViewConnection(
    first: 10
    productStoreUrl: "/finaleengineer/api/productstore/100000"
  ) {
    edges {
      node { name }
    }
  }
}

Summary and Aggregation

This collection supports metrics aggregation through the summary field. You can calculate totals, averages, counts, and other aggregate values across filtered data.

Note: This collection does not support groupBy dimensions. For dimensional analysis, use collections like product, order, or invoice.

For a comprehensive guide to using aggregations, see the Aggregation Concept Guide.

Query Structure

productStoreViewConnection(filters...) {
  summary {
    errorCode
    errorMessage
    metrics {
      # Calculated metrics (see table below)
    }
  }
}

Available Metrics

This collection provides 1 metric that can be aggregated:

Metric	Parameters	Description
`count`	None	Count of items in the result set

Common Parameters:

operator - Aggregation function: sum, mean, min, max
transform - Mathematical transformation: abs
dateRange - Filter to specific date range
facilityUrlList - Filter to specific facilities

Examples

Example 1: Total productStore Metrics

Calculate aggregate metrics across all productStore records:

query {
  productStoreViewConnection(first: 1) {
    summary {
      errorCode
      errorMessage
      metrics {
        totalCount: count
      }
    }
  }
}

Expected result structure:

{
  "data": {
    "productStoreViewConnection": {
      "summary": {
        "errorCode": null,
        "errorMessage": null,
        "metrics": {
          "totalCount": [1523]
        }
      }
    }
  }
}

Fields

This collection has 3 fields:

2 simple fields
1 enum fields (with predefined values)
0 parameterized fields (accept query options)

Note on Field Formatting: All scalar fields support the formatter argument to control output format. Available options: "html", "none", "abbreviated", "blank-zero". Some fields have a default formatter (shown below). See the Formatting guide for details.

Note on Sorting: Field sortability may vary depending on the UI context and query parameters used. Some parameter options explicitly disable sorting (marked with ⚠️ not sortable).

Simple Fields

These fields return values directly without additional options.

`name`

The user-defined display name for a product store, providing a human-readable label to identify the store in the user interface and reports. This field is commonly set to descriptive names like "teslaparts", "caddilacparts", "EBAY SANDBOX", "Square1 CA", or integration platform names like "ShipStation (CAN)", "Amazon CAN", or "QuickBooks Online". The name appears in various contexts including field labels in pivot tables, dropdown option lists for filtering, and dimension labels where it's combined with other field names to create compound labels. When used in comma-separated input parsing, the system strips whitespace from the name for matching purposes. The name is also searchable via the GraphQL API search parameter, allowing users to filter product stores by partial name matches. Product store names help users distinguish between multiple active stores representing different sales channels, geographic regions, or business entities.

Label: Name
Sortable: No

`productStoreUrl`

The unique identifier for a product store. This field is automatically generated by the server and serves as the primary key for the productStore collection, used throughout the system to reference and link to specific store configurations. Product stores represent sales channels or integrations (such as Shopify, BigCommerce, Etsy, QuickBooks) where products are listed and sold.

The productStoreUrl is used extensively to associate products with specific stores through the productStoreList field on products and scan lookups. It also links stores to integration connections and their task configurations, which control how inventory quantities are calculated and pushed to each store. When calculating stock levels for a store, the system looks up the store's configuration using this URL to determine which facilities, quantity sources, and supplier settings apply.

IMPORTANT: Treat URL values as opaque strings supplied by the server. Do not attempt to parse, interpret, or construct URL values manually:

ID values embedded in URLs may differ from entity ID values
The URL structure is an internal implementation detail subject to change
Manually constructing URLs can lead to bugs and system errors
Always use URL values exactly as provided by the API

Label: Product store url
Sortable: No

Enum Fields

These fields return one of a predefined set of values.

`status`

Indicates whether the product store is active or inactive.

A product store's status is derived from its statusId field, which can be either PROD_STORE_ACTIVE or PROD_STORE_INACTIVE. By default, if no status is explicitly set, the store is considered active.

The effective status can also be influenced by the associated connection: if a connection linked to this product store (via integrationOptions.productStoreUrl or task-specific integrationOptions.productStoreUrl) has a status of CONNECTION_INACTIVE, the product store will be treated as inactive regardless of its own statusId value.

Active product stores are available for use in operations and integrations, while inactive stores are filtered out from most active store lists and selection options.

Label: Status
Sortable: No

Possible Values:

PROD_STORE_ACTIVE - Active
PROD_STORE_INACTIVE - Inactive

Relations

No relations available.

Filters

productStoreUrl

Label: Store
Type: List|String
Enabled: Yes

Filter Type: Text value

This filter accepts freeform text values.

Usage Example:

query {
  productStoreViewConnection(
    first: 10
    productStoreUrl: "/finaleengineer/api/productstore/100000"
  ) {
    edges {
      node {
        name
        productStoreUrl
      }
    }
  }
}

search

Label: Not specified
Type: SearchString
Enabled: Yes

Filter Type: Search text

This filter performs a text search across multiple fields.

Usage Example:

query {
  productStoreViewConnection(
    first: 10
    search: "search term"
  ) {
    edges {
      node {
        name
      }
    }
  }
}

searchCustom

Label: Not specified
Type: searchCustomFilter
Enabled: Yes

Filter Type: Advanced search with result expansion

See the Advanced Search guide for complete documentation on how this filter works.

Collection-Specific Examples:

Example 1: Basic search:

query {
  productStoreViewConnection(
    first: 10
    searchCustom: {
      terms: "red widget"
    }
  ) {
    edges {
      node {
        name
      }
    }
  }
}

Example 2: Include additional fields in search:

# Searches defaults PLUS custom fields
query {
  productStoreViewConnection(
    first: 10
    searchCustom: {
      terms: "acme"
      include: ["customField1", "customField2"]
    }
  ) {
    edges {
      node {
        name
      }
    }
  }
}

Example 3: Expand results to include related records:

# For each match, also return the related record
query {
  productStoreViewConnection(
    first: 10
    searchCustom: {
      terms: "urgent"
      extend: ["relatedRecordUrl"]
    }
  ) {
    edges {
      node {
        name
      }
    }
  }
}

Example 4: Combine include and extend:

# Search in defaults + additional fields, then expand to related records
query {
  productStoreViewConnection(
    first: 10
    searchCustom: {
      terms: "acme corp"
      include: ["customField1"]
      extend: ["relatedRecordUrl"]
    }
  ) {
    edges {
      node {
        name
      }
    }
  }
}

status

Label: Status
Type: List|String
Enabled: Yes
Options:
- Active (PROD_STORE_ACTIVE)
- Inactive (PROD_STORE_INACTIVE)

Filter Type: Predefined options

Get Current Options:

These options may vary by account configuration. To get the current list:

query {
  dataSetMeta(purpose: "uiProductStore") {
    dataSets(name: "productStore") {
      filters {
        name
        optionList {
          value
          label
        }
      }
    }
  }
}

Usage Example:

query {
  productStoreViewConnection(
    first: 10
    status: ["PROD_STORE_ACTIVE", "PROD_STORE_INACTIVE"]
  ) {
    edges {
      node {
        name
        status
      }
    }
  }
}