ogcopenapis 1.1.0 → 1.2.0

package/src/OgcOpenApiFeatureStore.ts

@@ -25,6 +25,22 @@ export interface OgcOpenApiFeatureStoreConstructorOptions {
   extent?: { spatial: { bbox: any[] } };
   crs: string;
   proxify?: ProxifyFunction
+  // Called once for each query that succeeds, with what the response says about its size
+  onQueryResult?: (result: OgcOpenApiFeatureQueryResult) => void;
+}
+
+// What the response to a query says about its size (OGC API Features Part 1)
+export interface OgcOpenApiFeatureQueryResult {
+  // The request, and the query it was made from
+  url: string;
+  query: OgcOpenApiFeatureStoreQueryOptions;
+  // The number of features that match the query, left out when the server gives none (it is optional, PDOK)
+  numberMatched?: number;
+  // The number of features in the response. Servers cap limit: it can be less than limit (pygeoapi gives 10)
+  numberReturned?: number;
+  // The response links a next page. Left out when the response has no links to tell: a GML response whose Link
+  // header the browser may not read (CORS)
+  hasNext?: boolean;
 }
 
 export interface OgcOpenApiFeatureStoreQueryOptions {
@@ -86,11 +102,13 @@ export class OgcOpenApiFeatureStore extends Store {
   private credentials: boolean;
   private serverOptions: { proxy: (url: string, fetchOptions) => { fetchOptions: any; url: string }; hostname: string; complete: (url: string) => string };
   private swapAxes: string[] | undefined;
+  private onQueryResult: ((result: OgcOpenApiFeatureQueryResult) => void) | undefined;
 
   constructor(options: OgcOpenApiFeatureStoreConstructorOptions) {
     super();
     // console.log(options);
     this.swapAxes = options.swapAxes;
+    this.onQueryResult = options.onQueryResult;
     this.useCrs84Bounds = typeof options.useCrs84Bounds !== "undefined" ? options.useCrs84Bounds : false;
     this.dataUrl = options.dataUrl;
     this.outputFormat = options.outputFormat;
@@ -152,7 +170,7 @@ export class OgcOpenApiFeatureStore extends Store {
     query.f = query.f ? query.f : this.dataFormat;
     query.crs = query.crs ? query.crs : this.customCrs;
     query.limit = query.limit ? query.limit : undefined;
-    return this.fetchFeatures(this.withQuery(this.baseUrl, query), options?.abortSignal);
+    return this.fetchFeatures(this.withQuery(this.baseUrl, query), options?.abortSignal, query);
   }
 
   // The parameters of the items link, then those of the request, which replace a link parameter of the same name.
@@ -169,7 +187,8 @@ export class OgcOpenApiFeatureStore extends Store {
 
   // Fetches and decodes features. The promise always settles: it rejects with the reason when the request,
   // the response or the decoding fails, and when LuciadRIA aborts the request through abortSignal.
-  private fetchFeatures(request: string, abortSignal?: AbortSignal): Promise<Cursor> {
+  // A query is reported to onQueryResult once its features are decoded, unless it was aborted
+  private fetchFeatures(request: string, abortSignal?: AbortSignal, query?: OgcOpenApiFeatureStoreQueryOptions): Promise<Cursor> {
     // Mod starta
     const itemsAccept =
       typeof this.requestHeaders.accept !== 'undefined'
@@ -203,10 +222,13 @@ export class OgcOpenApiFeatureStore extends Store {
         const codecOptions: OgcOpenApiFeaturesCodecDecodeOptions = {
           content, contentType, contentCrs, contentLength
         };
-        if (this.codec instanceof GeoJsonCodec || this.codec instanceof GMLCodec) {
-          return this.codec.decode({...codecOptions, reference: getReference(OgcOpenApiCrsTools.getReferenceName(contentCrs))});
+        const cursor = this.codec instanceof GeoJsonCodec || this.codec instanceof GMLCodec ?
+            this.codec.decode({...codecOptions, reference: getReference(OgcOpenApiCrsTools.getReferenceName(contentCrs))}) :
+            this.codec.decode(codecOptions);
+        if (query && this.onQueryResult && !abortSignal?.aborted) {
+          this.onQueryResult({url: request, query, ...OgcOpenApiFeatureStore.getResultSize(content, contentType, response.headers.get('Link'))});
         }
-        return this.codec.decode(codecOptions);
+        return cursor;
       });
     });
   }
@@ -251,6 +273,47 @@ export class OgcOpenApiFeatureStore extends Store {
     return this.query(query, options);
   }
 
+  // The size of a response: the members of a JSON response, or the attributes of the root element of GML, and the
+  // next link of the response or of its Link header
+  private static getResultSize(content: string, contentType: string, linkHeader: string | null) {
+    const size: { numberMatched?: number, numberReturned?: number, hasNext?: boolean } = {};
+    const count = (value: any) => {
+      const n = typeof value === "string" ? (/^\d+$/.test(value) ? Number(value) : undefined) : value;
+      return typeof n === "number" && isFinite(n) && n >= 0 ? n : undefined;
+    };
+    if (/json/i.test(contentType)) {
+      let data: any;
+      try {
+        data = JSON.parse(content);
+      } catch (e) {
+        data = undefined;
+      }
+      if (data && typeof data === "object") {
+        size.numberMatched = count(data.numberMatched);
+        size.numberReturned = count(data.numberReturned);
+        if (Array.isArray(data.links)) size.hasNext = data.links.some(l => l && l.rel === "next");
+      }
+    } else if (/xml/i.test(contentType)) {
+      // WFS 2.0 allows numberMatched="unknown"
+      const root = /<(?:[\w.-]+:)?FeatureCollection\b([^>]*)>/.exec(content);
+      const attribute = (name: string) => {
+        const match = root ? new RegExp("\\s" + name + "=[\"']([^\"']*)[\"']").exec(root[1]) : null;
+        return match ? count(match[1]) : undefined;
+      };
+      size.numberMatched = attribute("numberMatched");
+      size.numberReturned = attribute("numberReturned");
+    }
+    if (linkHeader) {
+      const next = linkHeader.split(/,\s*(?=<)/).some(link => {
+        const rel = /;\s*rel\s*=\s*"?([^";]*)"?/i.exec(link);
+        return rel !== null && rel[1].split(/\s+/).indexOf("next") > -1;
+      });
+      size.hasNext = size.hasNext || next;
+    }
+    for (const key of Object.keys(size)) if (typeof size[key] === "undefined") delete size[key];
+    return size;
+  }
+
   private static getCRS84BoundingBox(shape: Bounds) {
     const WGS84 = getReference("CRS:84");
     const bounds = shape.bounds;

package/src/OgcOpenApiGetCapabilities.ts

@@ -22,6 +22,36 @@ export const COLLECTIONS_SELECTION_CONFORMANCE = "http://www.opengis.net/spec/og
 // collections parameter as the standard requires. To be removed once ldproxy declares the class of the standard
 export const COLLECTIONS_SELECTION_CONFORMANCE_VARIANTS = ["http://www.opengis.net/spec/ogcapi-tiles-1/1.0/conf/collection-selection"];
 
+// The conformance class of OGC API Features Part 3 for the filter parameter of the items of a collection
+export const FEATURES_FILTER_CONFORMANCE = "http://www.opengis.net/spec/ogcapi-features-3/1.0/conf/features-filter";
+// The conformance classes of CQL2 1.0 (OGC 21-065) share this prefix, the encodings and the levels of the language
+export const CQL2_CONFORMANCE_PREFIX = "http://www.opengis.net/spec/cql2/1.0/conf/";
+// The CQL2 encodings, as conformance classes name them. They are also the values of the filter-lang parameter
+export const CQL2_ENCODINGS = ["cql2-text", "cql2-json"];
+
+export interface OgcOpenApiFilterSupport {
+  // The server declares the Features Filter class of OGC API Features Part 3: the items of its collections take a filter
+  filter: boolean;
+  // The CQL2 encodings the server declares, cql2-text or cql2-json
+  encodings: string[];
+  // The other CQL2 classes the server declares, such as basic-cql2, advanced-comparison-operators or spatial-functions
+  levels: string[];
+}
+
+// The queryables of a collection (OGC API Features Part 3): a JSON Schema, as the server sends it. Each property has
+// a JSON Schema of its own, with type, format, title, enum or x-ogc-role among others
+export interface OgcOpenApiQueryables {
+  $schema?: string;
+  $id?: string;
+  type?: string;
+  title?: string;
+  properties?: { [name: string]: { [keyword: string]: any } };
+  [keyword: string]: any;
+}
+
+// The media types of a queryables document, in the order they are preferred
+const QUERYABLES_MEDIA_TYPES = ["application/schema+json", "application/json"];
+
 export interface TileMatrix {
   id: string,
   scaleDenominator: number;
@@ -187,155 +217,97 @@ export interface OgcOpenApiGetCapabilitiesFromURL {
 
 export class OgcOpenApiGetCapabilities {
 
-  public static fromURL(inputRequest: string, fromUrlOptions?: OgcOpenApiGetCapabilitiesFromURL) {
+  /**
+   * Reads the landing page of a server, its collections, the API document and the conformance classes, asking for
+   * JSON. Rejects with an Error when the landing page or the collections cannot be read, and with the error of the
+   * request as it is when it fails, an AbortError included. The API document and the conformance classes are
+   * optional: without them the capabilities have no version and declare no conformance classes.
+   */
+  public static async fromURL(inputRequest: string, fromUrlOptions?: OgcOpenApiGetCapabilitiesFromURL): Promise<OgcOpenApiCapabilitiesObject> {
     const options: OgcOpenApiGetCapabilitiesFromURL = fromUrlOptions ? fromUrlOptions : {};
-    return new Promise<OgcOpenApiCapabilitiesObject>((resolve, reject) => {
-      // The landing page, with the query it was given, such as an api key. baseUrl is without it
-      const baseUrl = OgcOpenApiFetchTools.cleanUrl(inputRequest);
-      const requestUrl = OgcOpenApiFetchTools.appendPath(inputRequest, "");
-      const serverOptions = OgcOpenApiFetchTools.createFetchOptions({originalUrl: requestUrl, proxify: options?.proxify});
-
-      OgcOpenApiFetchTools.fetch(requestUrl, {
-        method: 'GET',
-        credentials: options?.credentials ? "same-origin" : "omit",
-        headers: options? options.requestHeaders: {},
-      }, serverOptions).then(
-        (response) => {
-          if (response.status === 200) {
-            response.json().then((jsonObject) => {
-              if (!jsonObject.links) {
-                reject("Invalid format: (property 'links' is missing)")
-                return;
-              }
-              let linkToData = jsonObject.links.find(
-                (link: OgcOpenApiCapabilitiesCollectionServiceLinkType) =>
-                  link.rel === 'data' && link.type === 'application/json'
-              );
-              if (!linkToData)  {
-                linkToData = jsonObject.links.find((link) => link.rel === 'data' );
-              }
-              const linkToApi = jsonObject.links.find(
-                (link: OgcOpenApiCapabilitiesCollectionServiceLinkType) => {
-                  return (
-                    (link.rel === 'service-desc' || link.rel === 'service') &&
-                    link.type.indexOf('openapi+json') > -1
-                  );
-                }
-              );
-              const tilingSchemes = jsonObject.links.filter((link) => isRel(link, 'tiling-schemes'));
-              const linkToTileMatrixSets = tilingSchemes.find((link) => link.type === 'application/json') || tilingSchemes.find((link) => !link.type);
-              // The links of the landing page are relative to it, the links of the collections to /collections
-              const resolveLink = (link: OgcOpenApiCapabilitiesCollectionServiceLinkType, documentUrl: string) =>
-                  ({...link, href: OgcOpenApiFetchTools.resolveUrl(link.href, documentUrl, serverOptions)});
-              // The conformance classes, read with the collections. A server without them declares no classes
-              const conformance = jsonObject.links.find((link) => isRel(link, 'conformance'));
-              const conformancePromise: Promise<string[]> = conformance ?
-                  OgcOpenApiGetCapabilities.fetchJson({serverOptions} as OgcOpenApiCapabilitiesObject, resolveLink(conformance, requestUrl).href, options)
-                      .then(data => Array.isArray(data.conformsTo) ? data.conformsTo : [], () => []) :
-                  Promise.resolve([]);
-              const promiseArray = [];
-              if (linkToData) {
-                const collectionsLink = resolveLink(linkToData, requestUrl);
-                const collectionsPromise = OgcOpenApiGetCapabilities.fetchLinkContentAsJSON(
-                    collectionsLink,
-                    {credentials: options.credentials, requestHeaders: options.requestHeaders},
-                    serverOptions
-                );
-                promiseArray.push(collectionsPromise);
-                if (linkToApi) {
-                  const apiPromise = OgcOpenApiGetCapabilities.fetchLinkContentAsJSON(
-                      resolveLink(linkToApi, requestUrl),
-                      {credentials: options.credentials, requestHeaders: options.requestHeaders},
-                      serverOptions
-                  );
-                  promiseArray.push(apiPromise);
-                }
-                Promise.all(promiseArray).then((responses: any) => {
-                  const responseDataLink = responses[0];
-                  const responseOpenApi =
-                    responses.length >= 1 ? responses[1] : undefined;
-                  const crsArray = typeof responseDataLink.crs !== "undefined" ? { crs: responseDataLink.crs } : {};
-                  const foundCollections = responseDataLink.collections.filter( c =>
-                          options && options.filterCollectionsByLinkType ?
-                              OgcOpenApiGetCapabilities.filterCollectionLinks(c.links,options.filterCollectionsByLinkType).length > 0 : true
-                  )
-                      .map(
-                    (collection: any) => {
-                      const name =
-                        typeof collection.id !== 'undefined'
-                          ? collection.id
-                          : collection.name;
-                      const collectionCrsObject = {} as any;
-                      if (typeof collection.crs !== "undefined") collectionCrsObject.crs = collection.crs;
-                      if (typeof collection.storageCrs !== "undefined") collectionCrsObject.storageCrs = collection.storageCrs;
-                      const layer: OgcOpenApiCapabilitiesCollection = {
-                        description: collection.description,
-                        id: name,
-                        name,
-                        title: collection.title,
-                        keywords: collection.keywords
-                          ? collection.keywords
-                          : [],
-                        defaultReference: 'CRS:84',
-                        links: collection.links,
-                        outputFormats: options.filterCollectionsByLinkType ?
-                            this.filterCollectionLinks(collection.links, options.filterCollectionsByLinkType).map(link => this.detectTypeFormat(link))
-                            :
-                            collection.links.map(link => this.detectTypeFormat(link))
-                        ,
-                        extent: collection.extent,
-                        ...collectionCrsObject
-                      };
-                      return layer;
-                    }
-                  );
-                  // console.log(featureTypes);
-                  const o: OgcOpenApiCapabilitiesObject = {
-                    name: '',
-                    collections: foundCollections.map(col=>({...col, crs: col.crs ? col.crs : [], links: col.links.map(l => resolveLink(l, collectionsLink.href))})),
-                    version: responseOpenApi ? responseOpenApi.openapi : '',
-                    service: '',
-                    info: responseOpenApi ? responseOpenApi.info : {},
-                    ...crsArray,
-                    serverOptions: serverOptions,
-                    links: jsonObject.links.map(l => resolveLink(l, requestUrl)),
-                    baseUrl,
-                    tileMatrixSetsUrl: linkToTileMatrixSets ? resolveLink(linkToTileMatrixSets, requestUrl).href : undefined
-                  };
-                  conformancePromise.then(conformsTo => resolve({...o, conformsTo}));
-                });
-              } else {
-                reject("Invalid format: (property 'links' contains no links with rel=data");
-              }
-            }, ()=>{
-              reject("Not JSON")
-            });
-          } else {
-            reject(response.status);
-          }
-        },
-        (err) => {
-          reject(err);
-        }
-      );
-    });
+    // The landing page, with the query it was given, such as an api key. baseUrl is without it
+    const baseUrl = OgcOpenApiFetchTools.cleanUrl(inputRequest);
+    const requestUrl = OgcOpenApiFetchTools.appendPath(inputRequest, "");
+    const serverOptions = OgcOpenApiFetchTools.createFetchOptions({originalUrl: requestUrl, proxify: options.proxify});
+    // The requests before the capabilities exist
+    const server = {serverOptions} as OgcOpenApiCapabilitiesObject;
+    const getJson = (href: string, accept?: string) =>
+        OgcOpenApiGetCapabilities.fetchJson(server, href, options, accept).catch(e => {
+          throw OgcOpenApiGetCapabilities.toError(e, href);
+        });
+
+    const landing = await getJson(requestUrl);
+    if (!landing || !Array.isArray(landing.links)) throw new Error("Invalid format: (property 'links' is missing) in " + requestUrl);
+    const links: OgcOpenApiCapabilitiesCollectionServiceLinkType[] = landing.links;
+    const linkToData = links.find(link => link.rel === 'data' && link.type === 'application/json') || links.find(link => link.rel === 'data');
+    if (!linkToData) throw new Error("Invalid format: (property 'links' contains no links with rel=data) in " + requestUrl);
+    const linkToApi = links.find(link => (link.rel === 'service-desc' || link.rel === 'service') && (link.type || "").indexOf('openapi+json') > -1);
+    const tilingSchemes = links.filter(link => isRel(link, 'tiling-schemes'));
+    const linkToTileMatrixSets = tilingSchemes.find(link => link.type === 'application/json') || tilingSchemes.find(link => !link.type);
+    const conformance = links.find(link => isRel(link, 'conformance'));
+    // The links of the landing page are relative to it, the links of the collections to /collections
+    const resolveLink = (link: OgcOpenApiCapabilitiesCollectionServiceLinkType, documentUrl: string) =>
+        ({...link, href: OgcOpenApiFetchTools.resolveUrl(link.href, documentUrl, serverOptions)});
+    const collectionsLink = resolveLink(linkToData, requestUrl);
+
+    // The collections are required, the API document (in its own media type) and the conformance classes are not
+    const [collectionsDocument, api, conformsTo] = await Promise.all([
+      getJson(collectionsLink.href),
+      linkToApi ? getJson(resolveLink(linkToApi, requestUrl).href, linkToApi.type).catch(() => undefined) : Promise.resolve(undefined),
+      conformance ?
+          getJson(resolveLink(conformance, requestUrl).href).then(data => Array.isArray(data.conformsTo) ? data.conformsTo as string[] : [], () => [] as string[]) :
+          Promise.resolve([] as string[]),
+    ]);
+    if (!collectionsDocument || !Array.isArray(collectionsDocument.collections)) {
+      throw new Error("Invalid format: (property 'collections' is missing) in " + collectionsLink.href);
+    }
+
+    const crsArray = typeof collectionsDocument.crs !== "undefined" ? {crs: collectionsDocument.crs} : {};
+    const foundCollections = collectionsDocument.collections
+        .filter(c => options.filterCollectionsByLinkType ?
+            OgcOpenApiGetCapabilities.filterCollectionLinks(c.links, options.filterCollectionsByLinkType).length > 0 : true)
+        .map((collection: any) => {
+          const name = typeof collection.id !== 'undefined' ? collection.id : collection.name;
+          const collectionCrsObject = {} as any;
+          if (typeof collection.crs !== "undefined") collectionCrsObject.crs = collection.crs;
+          if (typeof collection.storageCrs !== "undefined") collectionCrsObject.storageCrs = collection.storageCrs;
+          const layer: OgcOpenApiCapabilitiesCollection = {
+            description: collection.description,
+            id: name,
+            name,
+            title: collection.title,
+            keywords: collection.keywords ? collection.keywords : [],
+            defaultReference: 'CRS:84',
+            links: collection.links,
+            outputFormats: options.filterCollectionsByLinkType ?
+                this.filterCollectionLinks(collection.links, options.filterCollectionsByLinkType).map(link => this.detectTypeFormat(link)) :
+                collection.links.map(link => this.detectTypeFormat(link)),
+            extent: collection.extent,
+            ...collectionCrsObject
+          };
+          return layer;
+        });
+    return {
+      name: '',
+      collections: foundCollections.map(col => ({...col, crs: col.crs ? col.crs : [], links: col.links.map(l => resolveLink(l, collectionsLink.href))})),
+      version: api ? api.openapi : '',
+      service: '',
+      info: api ? api.info : {},
+      ...crsArray,
+      serverOptions: serverOptions,
+      links: links.map(l => resolveLink(l, requestUrl)),
+      baseUrl,
+      tileMatrixSetsUrl: linkToTileMatrixSets ? resolveLink(linkToTileMatrixSets, requestUrl).href : undefined,
+      conformsTo,
+    };
   }
 
-  private static fetchLinkContentAsJSON(link: OgcOpenApiCapabilitiesCollectionServiceLinkType, options: {credentials: boolean, requestHeaders: RequestHeaders}, serverOptions?: FetchServerOptions) {
-    return new Promise((resolve) => {
-      OgcOpenApiFetchTools.fetch(link.href, {method: "GET", credentials: options.credentials ? "same-origin":"omit", headers: options.requestHeaders}, serverOptions).then(
-        (result) => {
-          if (result.status === 200) {
-            result.json().then((json) => resolve(json));
-          } else {
-            resolve(undefined);
-          }
-        },
-        () => {
-          resolve(undefined);
-        }
-      );
-    });
+  // An Error for a failed request of fromURL: the error of fetch as it is, such as an AbortError, otherwise its message
+  // and the URL. An error of fetch can come from another realm (a DOMException of jsdom is not instanceof Error), so
+  // anything with a name and a message is kept; the {error, message} of fetchJson has no name
+  private static toError(e: any, href: string): Error {
+    if (e instanceof Error || (e && typeof e.name === "string" && typeof e.message === "string")) return e;
+    return new Error((e && e.message ? e.message : String(e)) + " for " + href);
   }
 
   static filterCollectionLinks(
@@ -451,17 +423,15 @@ export class OgcOpenApiGetCapabilities {
   }
 
   // GETs a JSON document. Servers answer JSON for the Accept header, or for the f parameter that their links carry.
-  private static async fetchJson(capabilities: OgcOpenApiCapabilitiesObject, href: string, options?: {credentials?: boolean, requestHeaders?: RequestHeaders}) {
-    let result: Response;
-    try {
-      result = await OgcOpenApiFetchTools.fetch(href, {
-        method: "GET",
-        credentials: options?.credentials ? "same-origin" : "omit",
-        headers: {Accept: "application/json", ...(options?.requestHeaders ? options.requestHeaders : {})}
-      }, capabilities.serverOptions);
-    } catch (err) {
-      throw {error: true, message: err.message};
-    }
+  // accept is the media type to ask for, application/json by default; requestHeaders can replace it. A failed request
+  // rejects with the error of fetch as it is, such as an AbortError
+  private static async fetchJson(capabilities: OgcOpenApiCapabilitiesObject, href: string, options?: {credentials?: boolean, requestHeaders?: RequestHeaders},
+                                 accept = "application/json") {
+    const result = await OgcOpenApiFetchTools.fetch(href, {
+      method: "GET",
+      credentials: options?.credentials ? "same-origin" : "omit",
+      headers: {Accept: accept, ...(options?.requestHeaders ? options.requestHeaders : {})}
+    }, capabilities.serverOptions);
     if (result.status !== 200) throw {error: true, message: "Invalid response: " + result.status};
     try {
       return await result.json();
@@ -510,6 +480,76 @@ export class OgcOpenApiGetCapabilities {
         COLLECTIONS_SELECTION_CONFORMANCE_VARIANTS.some(variant => conformsTo.indexOf(variant) > -1);
   }
 
+  /**
+   * Whether, and how, the server filters features, as its conformance classes declare: the Features Filter class of
+   * OGC API Features Part 3, and the CQL2 1.0 classes by their names, in the order the server lists them. Each is
+   * reported as declared, a CQL2 encoding without the Features Filter class gives filter false. Pre-standard CQL
+   * classes (ogcapi-features-3/1.0/conf/cql-text) are not CQL2 and are left out.
+   */
+  public static getFilterSupport(capabilities: OgcOpenApiCapabilitiesObject | null): OgcOpenApiFilterSupport {
+    const conformsTo = capabilities && capabilities.conformsTo ? capabilities.conformsTo : [];
+    const cql2 = conformsTo
+        .filter(uri => uri.indexOf(CQL2_CONFORMANCE_PREFIX) === 0)
+        .map(uri => uri.substring(CQL2_CONFORMANCE_PREFIX.length));
+    return {
+      filter: conformsTo.indexOf(FEATURES_FILTER_CONFORMANCE) > -1,
+      encodings: cql2.filter(name => CQL2_ENCODINGS.indexOf(name) > -1),
+      levels: cql2.filter(name => CQL2_ENCODINGS.indexOf(name) === -1),
+    };
+  }
+
+  /**
+   * Fetches the queryables of a collection (OGC API Features Part 3), the properties a filter can use: a JSON Schema,
+   * as the server sends it. Resolves null for a collection that has none: a collection without features, or a
+   * queryables request that answers 404. Rejects with an Error otherwise, and with the error of the request as it is
+   * when it fails, an AbortError included.
+   */
+  public static async fetchQueryables(
+      capabilities: OgcOpenApiCapabilitiesObject | null,
+      collection: OgcOpenApiCapabilitiesCollection,
+      options?: {credentials?: boolean, requestHeaders?: RequestHeaders}
+  ): Promise<OgcOpenApiQueryables | null> {
+    if (capabilities === null) throw new Error("No capabilities to fetch the queryables of " + collection.id);
+    const href = OgcOpenApiGetCapabilities.getQueryablesHref(capabilities, collection);
+    if (!href) return null;
+    let response: Response;
+    try {
+      response = await OgcOpenApiFetchTools.fetch(href, {
+        method: "GET",
+        credentials: options?.credentials ? "same-origin" : "omit",
+        headers: {Accept: QUERYABLES_MEDIA_TYPES.join(", "), ...(options?.requestHeaders ? options.requestHeaders : {})}
+      }, capabilities.serverOptions);
+    } catch (e) {
+      throw OgcOpenApiGetCapabilities.toError(e, href);
+    }
+    if (response.status === 404) return null;
+    if (response.status !== 200) throw new Error("Invalid response: " + response.status + " for " + href);
+    let data: any;
+    try {
+      data = await response.json();
+    } catch (e) {
+      throw new Error("Not JSON data for " + href);
+    }
+    if (!data || typeof data !== "object" || Array.isArray(data)) throw new Error("Invalid format: (not a JSON Schema) in " + href);
+    return data;
+  }
+
+  // The queryables link of the collection, in JSON. Some servers (ldproxy, PDOK) list it only in the collection
+  // document, not in /collections: then the path of the standard, /collections/{collectionId}/queryables, for a
+  // collection with features. Other collections have no queryables, '' then
+  private static getQueryablesHref(capabilities: OgcOpenApiCapabilitiesObject, collection: OgcOpenApiCapabilitiesCollection) {
+    const links = collection.links ? collection.links : [];
+    const queryables = links.filter(l => isRel(l, "queryables"));
+    const link = QUERYABLES_MEDIA_TYPES.map(type => queryables.find(l => l.type === type)).find(l => l) ||
+        queryables.find(l => !l.type);
+    if (link) return link.href;
+    if (OgcOpenApiGetCapabilities.filterCollectionLinks(links, CollectionLinkType.Items).length === 0) return '';
+    // The self link keeps its query, such as f=json (PDOK)
+    const self = links.find(l => l.rel === "self" && (!l.type || l.type === "application/json"));
+    const collectionHref = self ? self.href : capabilities.baseUrl + "collections/" + encodeURIComponent(collection.id);
+    return OgcOpenApiFetchTools.appendPath(collectionHref, "queryables");
+  }
+
   /**
    * Whether the server tiles the dataset as a whole, all its collections in each tile, for linkType Tiles or VectorTiles
    */

package/src/OgcOpenApiMapsModel.ts

@@ -21,6 +21,8 @@ interface OgcOpenApiMapsModelConstructorOptions {
     samplingMode?: RasterSamplingMode;
     credentials?: boolean;
     requestHeaders?: { [p: string]: string };
+    // The f value of the requests, as the server names its formats (pygeoapi: png), not a media type (image/png), unlike
+    // the format of OgcOpenApiTilesModel. Best left out: the f value of the map link, in baseURL, is then used
     format?: string;
     reverseAxis?: boolean;
     datetime?: string;

package/src/OgcOpenApiTilesModel.ts

@@ -31,7 +31,8 @@ export interface OgcOpenApiTilesModelCreateOptions extends OgcOpenApiTilesModelO
     tileMatrixSetLimits?: TileMatrixLimits[];
     // The data extent in CRS:84, [minX, minY, maxX, maxY], such as the extent of the collection
     extent?: number[];
-    // The media type of the tiles, image/png by default
+    // The media type of the tiles, image/png by default, such as the type of the tile link. Unlike the format of
+    // OgcOpenApiMapsModel, which is an f value
     format?: string;
 }