open-index/open-npm huggingface dataset:
npm package: @koopjs/cache-apache-ignite
Description: [![npm version][npm-img]][npm-url] ![coverage](./coverage.svg)
Latest version: 1.0.1

# koop-cache-apache-ignite

[![npm version][npm-img]][npm-url]
![coverage](./coverage.svg)

This is a "cache" plugin for the Koop Web Server.  It adheres to Koop's [plugin specification](https://koopjs.github.io/docs/development/cache).  Registering this plugin with Koop will cause it to replace its in-memory cache with a cache backed by Apache Ignite.

An important fact about Koop cache plugins -  registering a cache does not necessarily mean data from provider plugins will be cached.  The provider must set a `ttl` (in seconds) on its data payload for it to be cached by any cache-plugin. This gives the provider developer ultimate control over data caching.

## Why use the Apache-Ignite plugin?
Koop's default cache uses a simple key/value store to cache data in-memory.  This means you are using a chunk of your deployment machine's memory for the cache.  The size of cache entries  isn't limited by the in-memory cache-plugin (though the number of entries is limited), which makes it hard to plan for how much memory you need. In contrast, using a backing store like Apache Ignite is a much more scalable solution as you can provision the Ignite instance independently and it's memory consumption has no impact on the web-server.

Using a plugin like the Apache-Ignite cache also benefits deployments that leverage horizontal scaling of the web-server.  Imagine you are using the default in-memory cache and that you are deploying multiple Koop server instances with traffic routed to each by a load balancer.  In this architecture, each Koop server has its own cache. Caching is therefore inefficient; a cache entry on server (A) is not accessible to server (B). Rather, each server instance has to build up its own cache.  Alternatively, if you use the Apache-Ignite plugin with an independently deployed Apache-Ignite backing store, each Koop server instance will share a single cache; entries cached by server (A) can be retrieved by server (B).

## Usage
### As a Koop cache plugin

#### With registration options:
```js
const Koop = require('koop')
const koop = new Koop()
const { Cache } = require('@koopjs/cache-apache-ignite')
koop.register(Cache, {
  connStr: '127.0.0.1:10800', // connection string for the Ignite deployment,
  cacheName: 'koop-ignite-cache' // a name to use for the cache; will be created if not found
})
```

#### With options set in "node-config" module:

Create a configuration json file (see [node-config](https://www.npmjs.com/package/config) for details).
```json
{
  "apacheIgnite": {
    "connStr": "127.0.0.1:10800",
    "cacheName": "koop-ignite-cache"
  }
}
```

Then register the cache plugin without options.
```js
const Koop = require('koop')
const koop = new Koop()
const { Cache } = require('@koopjs/cache-apache-ignite')
koop.register(Cache)
```

[npm-img]: https://img.shields.io/npm/v/@koopjs/cache-apache-ignite.svg?style=flat-square
[npm-url]: https://www.npmjs.com/package/@koopjs/cache-apache-ignite
npm package: @koopjs/cache-memory
Description: An in-memory cache for KOop
Latest version: 6.0.0

# Koop Memory Cache
[![npm version][npm-img]][npm-url]
![coverage](https://raw.githubusercontent.com/koopjs/koop/master/packages/cache-memory/coverage.svg)

This is a LRU cache with ttl (time to live) expiry. It expects cache items to be GeoJSON feature collections. It is based on [quick-lru](https://github.com/sindresorhus/quick-lru). 

Cache eviction occurs in two ways:
1. if the cache grows to a number of items greater than the cache's defined size, the least recently inserted or accessed item is evicted
2. if a item is accessed and it has gone past its ttl period, it is evicted
## Usage

### Stand-alone instantiation:

```js
const Cache = require('@koopjs/cache-memory');
const cache = new Cache({ size: 1000 });
```

### As a Koop cache plugin
This is the default cache for [Koop](https://github.com/koopjs/koop) so you won't need to instantiate it yourself. If you really wanted to, it would look like this:

```js
const Koop = require('koop')
const koop = new Koop()
const cache = require('@koopjs/cache-memory')
koop.register(cache, { size: 1000 })
```
#### Options
`size`: the maximum number of items to store in the queue before evicting the least recently used item.

## Cache API
The cache is a JavaScript object that lives in-memory. It is used to store geojson features.

### `insert`
Insert geojson into the cache.


```js
const geojson = {
  type: 'FeatureCollection',
  features: [],
  metadata: { 
    name: 'Example GeoJSON',
    description: 'This is geojson that will be stored in the cache'
  }
}

const options = {
  ttl: 1000 // The TTL option is measured in seconds, it will be used to set the `maxAge` property in the LRU cache
}

cache.insert('key', geojson, options, err => {
  // This function will call back with an error if one occurs
})
```

### `retrieve`
Retrieve a cached feature collection.

```js
const options = {
  pick: [] // an array of keys used to return a subset of the feature collections root level properties
  omit
} 

cache.retrieve('key', options, (err, geojson) => {
  /* This function will callback with an error or the data cached with the passed key. It will return undefined if not found or expired.
  {
    type: 'FeatureCollection',
    features: [],
    metadata: {}
  }
  */
})
```

### `delete`
Remove a feature collection from the cache

```js
cache.delete('key', err => {
  // This function will call back with an error if one occurs
})
```

[npm-img]: https://img.shields.io/npm/v/@koopjs/cache-memory.svg?style=flat-square
[npm-url]: https://www.npmjs.com/package/@koopjs/cache-memory
npm package: @koopjs/cli
Description: CLI tool to build Koop projects
Author: Haoliang Yu
Latest version: 1.1.10

# @koopjs/cli

[![npm package](https://img.shields.io/npm/v/@koopjs/cli.svg)](https://www.npmjs.com/package/@koopjs/cli) [![Build Status](https://travis-ci.org/koopjs/koop-cli.svg?branch=master)](https://travis-ci.org/koopjs/koop-cli)

An easy-to-use CLI tool to quickly build [Koop](https://github.com/koopjs/koop) applications and plugins

## Features

* follow [Koop specification](https://koopjs.github.io/docs/usage/koop-core)
* minimal project templates
* full development cycle support
* console commands + Node.js APIs
* cross-platform

## Install

Use npm

```
npm install -g @koopjs/cli
```

Use yarn

```
yarn global add @koopjs/cli
```

Once installed the `koop` command is available at the console.

## Example

Create a new Koop application with the name `my-koop-app`

``` bash
# create a project folder and initialize it
koop new app my-koop-app

# cd in the folder
cd my-koop-app
```

Add a provider [@koopjs/filesystem-s3](https://github.com/koopjs/koop-filesystem-s3) from npm

``` bash
# install the provider and register it to the koop app
koop add provider @koopjs/filesystem-s3
```

Add a custom provider that connects to a local database

``` bash
# add boilerplate provider files at src/providers/local-db and register it to
# the koop app (though you still need to implement the provider)
koop add provider --local providers/local-db
```

Test out your work

``` bash
# run the koop server
koop serve
```

## Commands

```
koop <command>

Commands:
  koop new <type> <name>  create a new koop project
  koop add <type> <name>  add a new plugin to the current app
  koop remove <name>      remove an existing plugin from the current app
  koop list [type]        list plugins added to the current app
  koop test               run tests in the current project
  koop serve [path]       run a Koop server for the current project
  koop validate           validte the current plugin

Options:
  --quiet    supress all console messages except errors
                                                      [boolean] [default: false]
```

Each command comes with the corresponding node.js API and this CLI can be used as a library. For detail information, please read the [command documentations](/docs/commands).
npm package: @koopjs/filesystem-s3
Description: An AWS S3-backed filesystem plugin for Koop
Author: Daniel Fenton
Latest version: 1.2.5

# Koop-FileSystem-S3

[![Greenkeeper badge](https://badges.greenkeeper.io/koopjs/koop-filesystem-s3.svg)](https://greenkeeper.io/)
[![Build Status](https://travis-ci.org/koopjs/koop-filesystem-s3.svg?branch=master)](https://travis-ci.org/koopjs/koop-filesystem-s3)


Koop integration with Amazon S3

## Install

koop-s3fs should be installed as a dependency in a Node.js project like so:

```
npm install koop-s3fs --save
```

## Config

koop-s3fs requires a json config file like so:

```
{
  "filesystem": {
    "s3": {
      "bucket": $S3_BUCKET,
      "endpoint" $S3-ENDPOINT //optional https://forums.aws.amazon.com/ann.jspa?annID=3112
    }
  }
}
```

Additionally you will need to supply your:

```
AWS_ACCESS_KEY_ID
AWS_SECRET_ACCESS_KEY
```
or configure the AWS CLI with keys.


## Methods

```js
const Filesystem = require('koop-s3fs')
const s3fs = new Filesystem()
const fs = require('fs')

/**
 * createWriteStream writes to AWS S3 as a Highland stream
 *
 * @param {string} name - filename
 * @param {object} options - optional metadata to attach to file
 * @returns {stream} stream
 */

const stream = fs.createReadStream('path/to/file')
  .pipe(s3fs.createWriteStream('filename'))


/**
 * createReadStream reads file from AWS s3 as highland stream
 *
 * @param {string} file - filename
 * @returns {stream}
 */

s3fs.createReadStream('filename').toArray(arr => {
  const txt = arr.toString()
  console.log(txt)
})


/**
 * stat accesses file metadata
 *
 * @param {string} file - filename
 * @param {function} callback
 * @returns {promise} returns resolved promise
 */

s3fs.stat('filename', (err, data) => {
  console.log(data)
  /*  Stats {
      getEntry: [Function],
      dev: 0,
      mode: 0,
      nlink: 0,
      uid: 0,
      gid: 0,
      rdev: 0,
      blksize: undefined,
      ino: 0,
      size: 37,
      blocks: undefined,
      atime: Wed Apr 13 2016 13:15:14 GMT-0400 (EDT),
      mtime: Wed Apr 13 2016 13:15:14 GMT-0400 (EDT),
      ctime: Wed Apr 13 2016 13:15:14 GMT-0400 (EDT),
      birthtime: Invalid Date,
      acceptRanges: 'bytes',
      ETag: '"b3b285a1749957f3e3a627a8e92b65bc"',
      ContentType: 'application/octet-stream',
      Metadata: { test: 'this is a test' } }
  */
})
```
npm package: @koopjs/geoservice-utils
Description: A set of utilities for working with Geoservice requests and parameters.
Latest version: 3.0.1

# GeoService Utilities

This is the home of some functional utilities for working with request data from GeoService clients.

### 1. [combineObjectIdsAndWhere](src/combine-objectids-and-where/README.md)
### 1. [standardizeGeometryFilter](src/standardize-geometry-filter/README.md)
npm package: @koopjs/koop-provider-hub-search-ogc
Description: A Koop provider plugin to use the Hub Search OGC API as a data source
Latest version: 1.4.0

# Koop Provider Hub Search OGC

![Coverage](./coverage.svg)

This is a Koop provider that extracts datasets from the ArcGIS Hub Search OGC API.

## Use - Streaming All Datasets
This provider plugin currently only supports [streaming](https://nodejs.org/api/stream.html#stream_readable_streams) ALL datasets matching a given search query. 

### Define Search Parameters
To perform a search from an output plugin, attach onto the response.
```js
req.res.locals.siteIdentifier = 'https://my-site.hub.arcgis.com'
```


### Pull the Readable Stream
Then pass the request object to `this.model.pullStream`.
```js
const docStream = await this.model.pullStream(req);
```

### Full Example
What you have now is a Node.js `Readable` stream. You can pipe the datasets from the readable through a transform stream in order to format them into some other type of output before sending them back to the browser by piping them to the Express.js response. The following simple example also uses the [`through2`](https://www.npmjs.com/package/through2) library to conveniently define a transform stream.

```js
async handleRequest (req, res) {
  req.res.locals.siteIdentifier = 'my-site.hub.arcgis.com'

  const docStream = await this.model.pullStream(req);

  docStream
    .pipe(through2.obj(function (dataset, enc, callback) {
      const transformed = someTranformFunc(dataset);

      // the Express.js "res" Writable only accepts strings or Buffers
      this.push(JSON.stringify(transformed));
      callback();
    }))
    .pipe(res);
}
```

## Develop
```sh
# clone and install dependencies
git clone https://github.com/koopjs/koop-provider-hub-search-ogc 
cd koop-provider-hub-search-ogc 
npm i

# starts the example Koop app found in ./example-app.
npm run dev
```

## Test
Run the `npm t` commmand to spin up the automated tests.
npm package: @koopjs/logger
Description: A shared logger for Koop
Latest version: 5.0.0

# Koop-Logger

## Usage
`npm install @koopjs/logger`
```javascript
const Logger = require('@koopjs/logger')
const config = require('config')
const log = new Logger(config)

log.info('foo')
log.debug('bar')
log.error('baz')
log.warn('bing')
```
npm package: @koopjs/output-ogcapi-features
Description: Experimental KoopJS output plugin for OGC API - Feature
Latest version: 0.2.2

# @koopjs/output-ogcapi-features

[![npm](https://img.shields.io/npm/v/@koopjs/output-ogcapi-features)](https://www.npmjs.com/package/@koopjs/output-ogcapi-features) [![Build Status](https://www.travis-ci.org/koopjs/output-ogcapi-features.svg?branch=master)](https://www.travis-ci.org/koopjs/output-ogcapi-features)

Experimental output plugin for [OGC API - Feature](https://github.com/opengeospatial/ogcapi-features) (AKA WFS 3.0). This output turns the dataset from any provider into a single-collection service.

Implemented specs:

- http://www.opengis.net/spec/wfs-1/3.0/req/core

Implemented routes:

- [x] `/conformance`
- [x] `/collections`
- [x] `/collections/:collectionId`
- [x] `/collections/:collectionId/items`
- [x] `/collections/:collectionId/items/:featureId`

## Installation

```
npm install @koopjs/output-ogcapi-features
```

## Usage

This provider can be registered in a Koop app.

```javascript
const Koop = require("koop");
const ogcOutput = require("@koopjs/output-ogcapi-features");

Koop.register(ogcOutput);
```

If the app is developed using the Koop CLI, it can be auto-registered with

```bash
koop add @koopjs/provider-ogcapi-features
```
npm package: @koopjs/provider-agol
Description: Provider for AGOL CSV items
Author: Rich Gwozdz
Latest version: 4.1.0

# koop-agol

[![Greenkeeper badge](https://badges.greenkeeper.io/koopjs/koop-provider-agol.svg)](https://greenkeeper.io/)

> ArcGIS Online provider for [Koop](https://github.com/Esri/koop).  Current support for CSV-type items only.  Support for other item types is forth-coming.

[![npm version][npm-img]][npm-url]
[![build status][travis-img]][travis-url]

[npm-img]: https://img.shields.io/npm/v/@koopjs/provider-agol.svg?style=flat-square
[npm-url]: https://www.npmjs.com/package/@koopjs/provider-agol
[travis-img]: https://img.shields.io/travis/koopjs/koop-provider-agol.svg?style=flat-square
[travis-url]: https://travis-ci.org/koopjs/koop-provider-agol

## Install

Koop providers require that you first install Koop. For information on using Koop, see https://koopjs.github.io.

You can add `koop-agol` to your Koop server's dependencies by installing it with npm and adding it to your package.json like so:

```
npm install @koopjs/provider-agol --save
```

## Usage
Koop will register a set of output-plugin endpoints for this provider, e.g., `/agol/:host/:id/FeatureServer`. These routes contain two provider-source route parameters to be aware of:

### `host`
This parameter should be a key representing the AGOL host you want as the source of your item data.  The provider ships with four supported keys: `devext` (https://devext.arcgis.com), `qaext` (https://qaext.arcgis.com), `arcgis` (https://arcgis.com), and finally, `_env`, which can only be use if a `host` value is set the provider's configuration object (see below).

### `id`
This parameter should be the AGOL item id.


## Configure
Koop plugins use the node-config module for setting configuration settings.  See the node-config documentation for usage details.  The Koop AGOL provider current has the following configuration settings:
```json
{
  "koopProviderAgol": {
    "host": "https://my-agol-host",
    "maxCsvSize": 1000000
  }
}
```

### `host`
The `host` configuration setting allows you to match a value to requests that arrive with a `_env` route-parameter.  For example, with configuration file shown above and a request like: `http://localhost:1338/agol/_env/abcdef0123456789abcdef0123456789/FeatureServer`, the provider will look for the item on https://my-agol-host)


### maxCsvSize
The maximum number of bytes a CSV item can be in order to be processed by Koop.  Default value is 5000000.


## Resources

* [Koop Documentation](https://koopjs.github.io)
* [ArcGIS for Developers](http://developers.arcgis.com)
* [ArcGIS REST Documentation](http://resources.arcgis.com/en/help/arcgis-rest-api/)
* [@esri](http://twitter.com/esri)

## Issues

Find a bug or want to request a new feature? Please let us know by submitting an issue.

## Contributing

Esri welcomes contributions from anyone and everyone. Please see our [guidelines for contributing](https://github.com/esri/contributing).

## License

[Apache 2.0](LICENSE)

<!-- [](Esri Tags: ArcGIS Web Mapping GeoJson FeatureServices) -->
<!-- [](Esri Language: JavaScript) -->
npm package: @koopjs/provider-arcgis-search
Description: Koop provider for ArcGIS Search
Author: Andrew Turner
Latest version: 2.0.9

# Koop Provider for ArcGIS Search
![Coverage](./coverage.svg)

Provides a GeoService API to ArcGIS Search for Online and Portal

Build your own Koop provider using [koop-provider-sample](https://github.com/koopjs/koop-provider-sample) or [docs](https://koopjs.github.io/docs/specs/provider/).

## Test it out
Run server:
- `npm install`
- `npm start`

Example API Query:
- `curl localhost:8080/arcgis-search/FeatureServer/0/query?returnCountOnly=true`

Tests:
- `npm test`

### Development output callstack logs

During development you can output error callstack with

- `NODE_ENV=test npm start`


## Deploy to AWS Lambda

Koop providers can be quickly deployed and scaled with AWS Lambda. To first create the service:

- `npm run lambda-create`

To deploy code updates

- `npm run lambda-update`

### AWS Lambda configuration

By default, AWS Lambda has a 3 second timeout and only 128MB memory. If your Koop provider uses a slower service, then you should change the AWS Lambda timeout to a higher time limit (e.g. 60 seconds) as well as add more memory (e.g. 512MB).

## With Docker

- `docker build -t koop-provider-arcgis-search .`
- `docker run -it -p 8080:8080 koop-provider-arcgis-search`

## Publish to npm
- run `npm init` and update the fields
  - Choose a name like `koop-provider-foo`
- run `npm publish`
npm package: @koopjs/provider-file-geojson
Description: Simple provider for serving file-based GeoJSON
Author: Rich Gwozdz
Latest version: 2.2.0


# koop-provider-file-geojson

Serve local GeoJSON files as [Koop](https://github.com/koopjs/koop) services.  Use as a standalone Koop instance or add to an existing Koop implementation.

## Getting Started

Add the provider to your koop instance

``sh
$ npm install @koopjs/provider-file-geojson
``

Then register the provider with Koop in your server file.

```js
const Koop = require('koop')
const koop = new Koop()

const provider = require('@koopjs/provider-file-geojson')
koop.register(provider)
```

### Usage
The provider will look for requested geojson files in a `/data` directory in the koop application root. For example, the following request will serve data from the file `data/polygon-sample.geojson` :
```
$ curl http://localhost:8080/file-geojson/rest/services/polygon-sample/FeatureServer/0/query
```

## Usage
### Setting the data directory
The provider needs to know where to locate the GeoJSON files it should serve. A directory can be assign in several ways.
By default, the provider looks for files in the `/data` directory in the koop application root. For example, the following request will serve data from the file `data/polygon-sample.geojson`:

```
$ curl http://localhost:8080/file-geojson/rest/services/polygon-sample/FeatureServer/0/query
```

You can override where the provider looks by adding a `dataDir` field to the provider's registration options:

```js
const Koop = require('koop')
const koop = new Koop()

const provider = require('@koopjs/provider-file-geojson')
koop.register(provider, { dataDir: 'path-to-data-directory'})
```

You can also achieve the same by setting an environment variable `KOOP_DATA_DIR=<path-to-directory>`.  Paths should be relative to the koop server file.

### Files
All valid GeoJSON files can be served.  Place them in the data directory and ensure they have a `.geojson` file extension.

### Request parameters
Request a particular file by using the (extension-less) file name as the `:id` parameter in the URL.  For example, when requesting data from the file `point-fc.geojson`:
`http://localhost:8080/file-geojson/rest/services/:id/FeatureServer/0/query`

becomes:

`http://localhost:8080/file-geojson/rest/services/point-fc/FeatureServer/0/query` 

## Contributing

Esri welcomes contributions from anyone and everyone. Please see our [guidelines for contributing](https://github.com/Esri/contributing).

## License

[Apache 2.0](LICENSE)
npm package: @koopjs/provider-github
Description: Github provider for Koop
Author: Chris Helm
Latest version: 3.0.0

# koop-github

> Github provider for [Koop](https://github.com/koopjs/koop)

[![npm][npm-image]][npm-url]
[![travis][travis-image]][travis-url]

[npm-image]: https://img.shields.io/npm/v/koop-github.svg?style=flat-square
[npm-url]: https://www.npmjs.com/package/koop-github
[travis-image]: https://travis-ci.org/koopjs/koop-provider-github.svg?branch=master
[travis-url]: https://travis-ci.org/koopjs/koop-provider-github

Take GeoJSON from a Github repository and serve it as an ArcGIS Feature Service, CSV, KML, or Shapefile.

## Install

Koop providers require that you first install Koop. For information on using Koop, see https://github.com/koopjs/koop.

You can add `koop-github` to your Koop server's dependencies by installing it with npm and adding it to your package.json like so:

```
npm install koop-github --save
```

## Usage

Make sure your koop configuration includes a github access token (`ghtoken` in the config object passed to koop or `KOOP_GITHUB_TOKEN` as an environmental variable). Your Github API requests will be rate limited and you will not have access private gists if you don't include a token.

```js
var koop = require('koop')({
  'ghtoken': 'XXXXXX' // defaults to `process.env.KOOP_GITHUB_TOKEN`
})
var koopGithub = require('koop-github')

koop.register(koopGithub)

koop.server.listen(1338, function () {
  console.log('Listening at http://%s:%d/', this.address().address, this.address().port)
})
```

Once `koop-github` is registered as provider and you've started your Koop server, you can request GeoJSON files in Github repositories using this pattern.  Note that the path within the repo uses `::` as a directory separator:

```
/github/{organization name}::{repository name}::{folder::path::to::geojson}/FeatureServer/0/query
```

so for example:

```
http://localhost:1338/github/koopjs::geodata::countries::mexico/FeatureServer/0/query
```

## Test

`koop-github` uses [tape](https://github.com/substack/tape) for testing.

```
npm test
```

## Contributing

Esri welcomes contributions from anyone and everyone. Please see our [guidelines for contributing](https://github.com/Esri/contributing).

## License

[Apache 2.0](LICENSE)
npm package: @koopjs/provider-ogcapi-features
Description: An opinionated provider template for koop-cli
Latest version: 0.3.0

# @koopjs/provider-ogcapi-features

[![npm](https://img.shields.io/npm/v/@koopjs/provider-ogcapi-features)](https://www.npmjs.com/package/@koopjs/provider-ogcapi-features) [![Build Status](https://www.travis-ci.org/koopjs/provider-ogcapi-features.svg?branch=master)](https://www.travis-ci.org/koopjs/provider-ogcapi-features)

Experimental Koop provider for [OGC API - Features](https://github.com/opengeospatial/ogcapi-features)

## Installation

```bash
npm install @koopjs/provider-ogcapi-features
```

## Configuration

The configuration of this provider is defined under the `provider-ogcapi-features` namespace. You can update the configuration file for the Koop app to configure this plugin.

```javascript
{
  "provider-ogcapi-features": {
    // the "hosts" object defines a list of hosts that exposes OGC Features API
    "hosts": {
      // each host has a unique id, which will be used in the request URL
      "host_id": {
        // host URL
        "url": "https://server-url.com",
        // optional, the name of ID field in the feature properties
        "idField": "id_field_name"
      }
    }
  }
}
```

For example, the following configuration specifies that a host `cubeserv` with the host URL.

```json
{
  "provider-ogcapi-features": {
    "hosts": {
      "cubeserv": {
        "url": "http://www.pvretano.com/cubewerx/cubeserv/default/wfs/3.0.0/framework"
      }
    }
  }
}
```

This provider uses the `:host` and `:id` parameter in the URL to identify the target collection.

The `:host` parameter is the host id defined in the configuration file. In the above example, the user can construct the request URL with the host `cubeserv`.

The `:id` parameter is a collection id from the selected host service. According to the OGCAPI spec, the user can get a list of all collections from the `/collections` request. In the above example, the collection id can be found in

```
http://www.pvretano.com/cubewerx/cubeserv/default/wfs/3.0.0/framework/collections?f=json
```

and `JURISDICTIONAL` is a valid colleciton id.

Then the user is able to fetch the features from this collection with the following URL:

```
/ogcapi-features/cubeserv/JURISDICTIONAL/FeatureServer/0/query
```

The actual data comes from the service request

```
https://eratosthenes.pvretano.com/cubewerx/cubeserv/default/wfs/3.0.0/framework/collections/JURISDICTIONAL/items?f=json
```

## Usage

This provider can be registered in a Koop app.

```javascript
const Koop = require("koop");
const ogcProvider = require("@koopjs/provider-ogcapi-features");

Koop.register(ogcProvider);
```

If the app is developed using the [Koop CLI](https://github.com/koopjs/koop-cli), it can be auto-registered with

```bash
koop add @koopjs/provider-ogcapi-features
```

## Roadmap

- [ ] Support pagination using the `limit` parameter or prev/next link
- [ ] Support property filtering