Documentation de référence de l'API

Vous trouverez ci-dessous un aperçu des spécifications de l'API Bundle Builder, y compris des définitions et des descriptions détaillées en TypeScript.

Interface BundleDocument

Spécification d'un seul document de la collection configurée:

type BundleDocument = {
  // A list of document IDs to serve in the bundle.
  docs?: Array<string>;
  // A map containing individual named queries and their definitions.
  queries?: Map<string, QueryDefinition[]>;
  // A map of parameters and their definitions, which can be provided to a query definition.
  params?: Map<string, ParamDefinition>;
  // Specifies how long to keep the bundle in the client's cache, in seconds. If not defined, client-side cache is disabled.
  clientCache?: string;
  // Only used in combination with Firebase Hosting. Specifies how long to keep the bundle in Firebase Hosting CDN cache, in seconds.
  serverCache: string;
  // Specifies how long (in seconds) to keep the bundle in a Cloud Storage bucket, in seconds. If not defined, Cloud Storage bucket is not accessed.
  fileCache?: string;
  // If a 'File Cache' is specified, bundles created before this timestamp will not be file cached.
  notBefore?: Timestamp;
};

Interface de définition de paramètres

Spécification d'un paramètre unique défini dans un BundleDocument.

type ParamDefinition = {
  // Whether this parameter is required. If not provided as a query string, an error will be thrown.
  required: boolean;
  // The type of value which will be parsed, defaults to 'string'.
  type?:
    | "string"
    | "integer"
    | "float"
    | "boolean"
    | "string-array"
    | "integer-array"
    | "float-array";
};

Prenons l'exemple du paramètre suivant:

params: {
  name: {
    required: true,
    type: 'string',
  }
}

Lorsque vous envoyez une requête au point de terminaison HTTP du bundle, le paramètre peut être fourni via un paramètre de requête, par exemple ?name=david. Le paramètre peut être utilisé dans une valeur QueryDefinition (voir ci-dessous) ($name) pour créer dynamiquement des bundles.

Interface de définition de requête

Une définition de requête permet de créer des requêtes nommées sur le bundle. Chaque objet du mappage queries créera une requête nommée en utilisant la clé d'objet comme nom. Chaque requête doit spécifier une collection et éventuellement une liste de conditions à exécuter.

type QueryDefinition = {
  // The collection to perform the query on.
  collection: string;
  // An optional list of conditions to perform on the specified collection.
  conditions?: QueryCondition[];
};

Le paramètre conditions peut contenir un tableau d'interfaces QueryCondition. Chaque élément du tableau ne doit inclure qu'une seule condition.

type QueryCondition = {
  // Performs a `where` filter on the collection on a given FieldPath, operator and value.
  where?: [
    string,
    (
      | "<"
      | "<="
      | "=="
      | ">="
      | ">"
      | "!="
      | "array-contains"
      | "in"
      | "not-in"
      | "array-contains-any"
    ),
    any
  ];
  orderBy?: [string, ("asc" | "desc")?];
  limit?: number;
  limitToLast?: number;
  offset?: number;
  startAt?: string;
  startAfter?: string;
  endAt?: string;
  endBefore?: string;
};

Par exemple, pour créer une requête nommée "products" sur une collection products avec une condition WHERE et limit, le résultat de la structure de données doit correspondre à ce qui suit:

queries: {
  products: {
    collection: 'products',
    conditions: [
      { where: ['type', '==', 'featured'] },
      { limit: 10 },
    ],
  }
}

Lorsque vous fournissez des valeurs de tableau aux filtres in, not-in ou array-contains-any, vous devez fournir une valeur séparée par une virgule, car les valeurs de tableau imbriquées ne sont pas compatibles avec Firestore. Exemple :

{ where: ['category', 'in', 'womens,shorts'] }, // ['womens', 'shorts']

Toute valeur numérique sera analysée en tant que nombre. Toutefois, si une valeur numérique sous forme de chaîne est requise, elle doit être placée entre parenthèses:

{ where: ['price', 'in', '1,2.5'] }, // [1, 2.5]
{ where: ['price', 'in', '"1","2.5"'] }, // ['1', '2.5']

Vous pouvez également utiliser des conditions avec des paramètres. Par exemple, si un paramètre type est défini (voir ci-dessus), il peut être fourni à une valeur de condition pour fournir des bundles de données dynamiques via la syntaxe $:

// ?type=featured


    conditions: [
      { where: ['type', '==', '$type'] },