AssetQuery

Use the AssetQuery class to fetch all or find assets. You obtain it from an initialized Stack via stack.asset().query().

Class Overview

Name	Type	Description
cachePolicy	CachePolicy	Defines the caching strategy for the AssetQuery request. While the Stack sets a default, you can manually override it using methods like .networkOnly to ensure the most recent data is retrieved.
stack	Stack	Identifies the parent Stack instance that owns and executes the query. This is automatically assigned by the system when you call stack.asset().query(), ensuring the request is correctly scoped to your environment.
parameters	[String: Any]	Contains URI-based metadata sent with the request. These are automatically populated by the system through method calls such as locale(), include(), skip(), and limit() to refine your API results.
queryParameter	[String: Any]	Defines the filtering logic (e.g., where) for the request. The system populates these values based on your method calls, allowing you to narrow down asset results to meet specific criteria.
headers	[String: String]	Manages custom HTTP headers for the request. You can manually add values via addValue(_:forHTTPHeaderField:) to meet unique security or transport requirements.

locale(_:)

The locale(_:) method sets the locale used when fetching assets, so the response is in the specified language/locale.

Name	Type	Description
locale (required)	String	Defines the locale code (e.g., "en-us") used to fetch assets in a specific language. It is set to ensure the API returns localized content. Default: None

The same AssetQuery instance, for chaining

let stack = Contentstack.stack(apiKey: apiKey,
                 deliveryToken: deliveryToken,
                 environment: environment)

     // To retrieve assets with a specific locale
     stack.asset().query().locale("en-us")
    .find { (result: Result<ContentstackResponse<AssetModel>, Error>, response: ResponseType) in
        switch result {
        case .success(let contentstackResponse): // Models retrieved from API
        case .failure(let error): // Error Message
        }
     }

Note If locale(_:) is not called, the SDK does not provide a default value. The request is sent without a locale parameter, and the Contentstack Delivery API applies the Stack's default locale to the results.

where(queryableCodingKey:_:)

Use this method to apply a filter on assets using a queryable field and a query operation (e.g., equals, includes).

Name	Type	Description
queryableCodingKey (required)	AssetModel.QueryableCodingKey	The member of your QueryableCodingKey that you are performing your select operation against.
operation (required)	Query.Operation	The query operation used in the query.

let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.asset().query()
.where(queryableCodingKey: .title, .equals("Asset Title"))
.find { (result: Result<ContentstackResponse<AssetModel>, Error>, response: ResponseType) in
    switch result {
    case .success(let contentstackResponse):
    case .failure(let error):
    }
}

include(params:)

The include(params:) method adds optional response options (count, relative URLs, dimensions, fallback, metadata) to the asset query.

Name	Type	Description
params (required)	AssetQuery.Include	Defines optional data you manually set in .include() to return assets with metadata or relative URLs. Default: None

AssetQuery.Include options:

Option	Description
.count	Include the total count of assets in the response.
.relativeURL	Include relative URLs for assets.
.dimension	Include image dimensions (height/width). Supported types: JPG, GIF, PNG, WebP, BMP, TIFF, SVG, PSD.
.fallback	Return fallback locale content when the requested locale is not available.
.metadata	Include metadata in the response.
.all	Equivalent to [.count, .relativeURL, .dimension, .fallback, .metadata].

Examples

Include all options (.all):

let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.asset().query().include(params: [.all])
.find { (result: Result<ContentstackResponse<AssetModel>, Error>, response: ResponseType) in
    switch result {
    case .success(let contentstackResponse):
    case .failure(let error):        //Error Message
    }
}

Include count only (.count):

let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.asset().query().include(params: [.count]) 
.find { (result: Result<ContentstackResponse<AssetModel>, Error>, response: ResponseType) in 
  switch result { 
  case .success(let contentstackResponse): 
  case .failure(let error): 
  }
}

Include relative URLs (.relativeURL):

let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.asset().query().include(params: [.relativeURL])
.find { (result: Result<ContentstackResponse<AssetModel>, Error>, response: ResponseType) in
    switch result {
    case .success(let contentstackResponse):
    case .failure(let error):
    }
}

Include image dimensions (.dimension):

let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.asset().query().include(params: [.dimension]) 
.find { (result: Result<ContentstackResponse<AssetModel>, Error>, response: ResponseType) in 
  switch result { 
  case .success(let contentstackResponse): 
  case .failure(let error): 
  }
}

Include fallback locale (.fallback):

let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.asset().query().include(params: [.fallback]) 
.find { (result: Result<ContentstackResponse<AssetModel>, Error>, response: ResponseType) in 
  switch result { 
  case .success(let contentstackResponse): 
  case .failure(let error): 
  }
}