@sap/cds-dk 9.9.3 → 10.0.4

package/node_modules/@sap/xsenv/LICENSE

@@ -0,0 +1,37 @@
+SAP DEVELOPER LICENSE AGREEMENT
+
+Version 3.1
+
+Please scroll down and read the following Developer License Agreement carefully ("Developer Agreement").  By clicking "I Accept" or by attempting to download, or install, or use the SAP software and other materials that accompany this Developer Agreement ("SAP Materials"), You agree that this Developer Agreement forms a legally binding agreement between You ("You" or "Your") and SAP SE, for and on behalf of itself and its subsidiaries and affiliates (as defined in Section 15 of the German Stock Corporation Act) and You agree to be bound by all of the terms and conditions stated in this Developer Agreement. If You are trying to access or download the SAP Materials on behalf of Your employer or as a consultant or agent of a third party (either "Your Company"), You represent and warrant that You have the authority to act on behalf of and bind Your Company to the terms of this Developer Agreement and everywhere in this Developer Agreement that refers to 'You' or 'Your' shall also include Your Company. If You do not agree to these terms, do not click "I Accept", and do not attempt to access or use the SAP Materials.
+
+1.  LICENSE: SAP grants You a non-exclusive, non-transferable, non-sublicensable, revocable, limited use license to copy, reproduce and distribute the application programming interfaces ("API"), documentation, plug-ins, templates, scripts and sample code ("Tools") on a desktop, laptop, tablet, smart phone, or other appropriate computer device that You own or control (any, a "Computer") to create new applications ("Customer Applications"). You agree that the Customer Applications will not: (a) unreasonably impair, degrade or reduce the performance or security of any SAP software applications, services or related technology ("Software"); (b) enable the bypassing or circumventing of SAP's license restrictions and/or provide users with access to the Software to which such users are not licensed; (c) render or provide, without prior written consent from SAP, any information concerning SAP software license terms, Software, or any other information related to SAP products; or (d) permit mass data extraction from an SAP product to a non-SAP product, including use, modification, saving or other processing of such data in the non-SAP product. In exchange for the right to develop Customer Applications under this Agreement, You covenant not to assert any Intellectual Property Rights in Customer Applications created by You against any SAP product, service, or future SAP development.
+
+2.  INTELLECTUAL PROPERTY: (a) SAP or its licensors retain all ownership and intellectual property rights in the APIs, Tools and Software. You may not: a) remove or modify any marks or proprietary notices of SAP, b) provide or make the APIs, Tools or Software available to any third party, c) assign this Developer Agreement or give or transfer the APIs, Tools or Software or an interest in them to another individual or entity, d) decompile, disassemble or reverse engineer (except to the extent permitted by applicable law) the APIs Tools or Software, (e) create derivative works of or based on the APIs, Tools or Software, (f) use any SAP name, trademark or logo, or (g) use the APIs or Tools to modify existing Software or other SAP product functionality or to access the Software or other SAP products' source code or metadata.
+(b) Subject to SAP's underlying rights in any part of the APIs, Tools or Software, You retain all ownership and intellectual property rights in Your Customer Applications.
+
+3. FREE AND OPEN SOURCE COMPONENTS: The SAP Materials may include certain third party free or open source components ("FOSS Components"). You may have additional rights in such FOSS Components that are provided by the third party licensors of those components.
+
+4. THIRD PARTY DEPENDENCIES: The SAP Materials may require certain third party software dependencies ("Dependencies") for the use or operation of such SAP Materials. These dependencies may be identified by SAP in Maven POM files, product documentation or by other means. SAP does not grant You any rights in or to such Dependencies under this Developer Agreement. You are solely responsible for the acquisition, installation and use of Dependencies. SAP DOES NOT MAKE ANY REPRESENTATIONS OR WARRANTIES IN RESPECT OF DEPENDENCIES, INCLUDING BUT NOT LIMITED TO IMPLIED WARRANTIES OF MERCHANTABILITY AND OF FITNESS FOR A PARTICULAR PURPOSE. IN PARTICULAR, SAP DOES NOT WARRANT THAT DEPENDENCIES WILL BE AVAILABLE, ERROR FREE, INTEROPERABLE WITH THE SAP MATERIALS, SUITABLE FOR ANY PARTICULAR PURPOSE OR NON-INFRINGING.  YOU ASSUME ALL RISKS ASSOCIATED WITH THE USE OF DEPENDENCIES, INCLUDING WITHOUT LIMITATION RISKS RELATING TO QUALITY, AVAILABILITY, PERFORMANCE, DATA LOSS, UTILITY IN A PRODUCTION ENVIRONMENT, AND NON-INFRINGEMENT. IN NO EVENT WILL SAP BE LIABLE DIRECTLY OR INDIRECTLY IN RESPECT OF ANY USE OF DEPENDENCIES BY YOU.
+
+
+5.  WARRANTY:
+a)  If You are located outside the US or Canada: AS THE API AND TOOLS ARE PROVIDED TO YOU FREE OF CHARGE, SAP DOES NOT GUARANTEE OR WARRANT ANY FEATURES OR QUALITIES OF THE TOOLS OR API OR GIVE ANY UNDERTAKING WITH REGARD TO ANY OTHER QUALITY. NO SUCH WARRANTY OR UNDERTAKING SHALL BE IMPLIED BY YOU FROM ANY DESCRIPTION IN THE API OR TOOLS OR ANY AVAILABLE DOCUMENTATION OR ANY OTHER COMMUNICATION OR ADVERTISEMENT. IN PARTICULAR, SAP DOES NOT WARRANT THAT THE SOFTWARE WILL BE AVAILABLE UNINTERRUPTED, ERROR FREE, OR PERMANENTLY AVAILABLE.  FOR THE TOOLS AND API ALL WARRANTY CLAIMS ARE SUBJECT TO THE LIMITATION OF LIABILITY STIPULATED IN SECTION 4 BELOW.
+b)  If You are located in the US or Canada: THE API AND TOOLS ARE LICENSED TO YOU "AS IS", WITHOUT ANY WARRANTY, ESCROW, TRAINING, MAINTENANCE, OR SERVICE OBLIGATIONS WHATSOEVER ON THE PART OF SAP. SAP MAKES NO EXPRESS OR IMPLIED WARRANTIES OR CONDITIONS OF SALE OF ANY TYPE WHATSOEVER, INCLUDING BUT NOT LIMITED TO IMPLIED WARRANTIES OF MERCHANTABILITY AND OF FITNESS FOR A PARTICULAR PURPOSE. IN PARTICULAR, SAP DOES NOT WARRANT THAT THE SOFTWARE WILL BE AVAILABLE UNINTERRUPTED, ERROR FREE, OR PERMANENTLY AVAILABLE.  YOU ASSUME ALL RISKS ASSOCIATED WITH THE USE OF THE API AND TOOLS, INCLUDING WITHOUT LIMITATION RISKS RELATING TO QUALITY, AVAILABILITY, PERFORMANCE, DATA LOSS, AND UTILITY IN A PRODUCTION ENVIRONMENT.
+
+6.  LIMITATION OF LIABILITY:
+a)  If You are located outside the US or Canada: IRRESPECTIVE OF THE LEGAL REASONS, SAP SHALL ONLY BE LIABLE FOR DAMAGES UNDER THIS AGREEMENT IF SUCH DAMAGE (I) CAN BE CLAIMED UNDER THE GERMAN PRODUCT LIABILITY ACT OR (II) IS CAUSED BY INTENTIONAL MISCONDUCT OF SAP OR (III) CONSISTS OF PERSONAL INJURY. IN ALL OTHER CASES, NEITHER SAP NOR ITS EMPLOYEES, AGENTS AND SUBCONTRACTORS SHALL BE LIABLE FOR ANY KIND OF DAMAGE OR CLAIMS HEREUNDER.
+b)  If You are located in the US or Canada: IN NO EVENT SHALL SAP BE LIABLE TO YOU, YOUR COMPANY OR TO ANY THIRD PARTY FOR ANY DAMAGES IN AN AMOUNT IN EXCESS OF $100 ARISING IN CONNECTION WITH YOUR USE OF OR INABILITY TO USE THE TOOLS OR API OR IN CONNECTION WITH SAP'S PROVISION OF OR FAILURE TO PROVIDE SERVICES PERTAINING TO THE TOOLS OR API, OR AS A RESULT OF ANY DEFECT IN THE API OR TOOLS. THIS DISCLAIMER OF LIABILITY SHALL APPLY REGARDLESS OF THE FORM OF ACTION THAT MAY BE BROUGHT AGAINST SAP, WHETHER IN CONTRACT OR TORT, INCLUDING WITHOUT LIMITATION ANY ACTION FOR NEGLIGENCE. YOUR SOLE REMEDY IN THE EVENT OF BREACH OF THIS DEVELOPER AGREEMENT BY SAP OR FOR ANY OTHER CLAIM RELATED TO THE API OR TOOLS SHALL BE TERMINATION OF THIS AGREEMENT. NOTWITHSTANDING ANYTHING TO THE CONTRARY HEREIN, UNDER NO CIRCUMSTANCES SHALL SAP AND ITS LICENSORS BE LIABLE TO YOU OR ANY OTHER PERSON OR ENTITY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, OR INDIRECT DAMAGES, LOSS OF GOOD WILL OR BUSINESS PROFITS, WORK STOPPAGE, DATA LOSS, COMPUTER FAILURE OR MALFUNCTION, ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSS, OR EXEMPLARY OR PUNITIVE DAMAGES.
+
+7.  INDEMNITY: You will fully indemnify, hold harmless and defend SAP against law suits based on any claim: (a) that any Customer Application created by You infringes or misappropriates any patent, copyright, trademark, trade secrets, or other proprietary rights of a third party, or (b) related to Your alleged violation of the terms of this Developer Agreement.
+
+8.  EXPORT: The Tools and API are subject to German, EU and US export control regulations. You confirm that: a) You will not use the Tools or API for, and will not allow the Tools or API to be used for, any purposes prohibited by German, EU and US law, including, without limitation, for the development, design, manufacture or production of nuclear, chemical or biological weapons of mass destruction; b) You are not located in Cuba, Iran, Sudan, Iraq, North Korea, Syria, nor any other country to which the United States has prohibited export or that has been designated by the U.S. Government as a "terrorist supporting" country (any, an "US Embargoed Country"); c) You are not a citizen, national or resident of, and are not under the control of, a US Embargoed Country; d) You will not download or otherwise export or re-export the API or Tools, directly or indirectly, to a US Embargoed Country nor to citizens, nationals or residents of a US Embargoed Country; e) You are not listed on the United States Department of Treasury lists of Specially Designated Nationals, Specially Designated Terrorists, and Specially Designated Narcotic Traffickers, nor listed on the United States Department of Commerce Table of Denial Orders or any other U.S. government list of prohibited or restricted parties and f) You will not download or otherwise export or re-export the API or Tools , directly or indirectly, to persons on the above-mentioned lists.
+
+9.  SUPPORT: Other than what is made available on the SAP Community Website (SCN) by SAP at its sole discretion and by SCN members, SAP does not offer support for the API or Tools which are the subject of this Developer Agreement.
+
+10.  TERM AND TERMINATION: You may terminate this Developer Agreement by destroying all copies of the API and Tools on Your Computer(s). SAP may terminate Your license to use the API and Tools immediately if You fail to comply with any of the terms of this Developer Agreement, or, for SAP's convenience by providing you with ten (10) day's written notice of termination (including email). In case of termination or expiration of this Developer Agreement, You must destroy all copies of the API and Tools immediately.  In the event Your Company or any of the intellectual property you create using the API, Tools or Software are acquired (by merger, purchase of stock, assets or intellectual property or exclusive license), or You become employed, by a direct competitor of SAP, then this Development Agreement and all licenses granted in this Developer Agreement shall immediately terminate upon the date of such acquisition.
+
+11.  LAW/VENUE:
+a)  If You are located outside the US or Canada: This Developer Agreement is governed by and construed in accordance with the laws of the Germany. You and SAP agree to submit to the exclusive jurisdiction of, and venue in, the courts of Karlsruhe in Germany in any dispute arising out of or relating to this Developer Agreement.
+b)  If You are located in the US or Canada: This Developer Agreement shall be governed by and construed under the Commonwealth of Pennsylvania law without reference to its conflicts of law principles. In the event of any conflicts between foreign law, rules, and regulations, and United States of America law, rules, and regulations, United States of America law, rules, and regulations shall prevail and govern. The United Nations Convention on Contracts for the International Sale of Goods shall not apply to this Developer Agreement. The Uniform Computer Information Transactions Act as enacted shall not apply.
+
+12. MISCELLANEOUS: This Developer Agreement is the complete agreement for the API and Tools licensed (including reference to information/documentation contained in a URL). This Developer Agreement supersedes all prior or contemporaneous agreements or representations with regards to the subject matter of this Developer Agreement. If any term of this Developer Agreement is found to be invalid or unenforceable, the surviving provisions shall remain effective. SAP's failure to enforce any right or provisions stipulated in this Developer Agreement will not constitute a waiver of such provision, or any other provision of this Developer Agreement.

package/node_modules/@sap/xsenv/README.md

@@ -0,0 +1,548 @@
+# @sap/xsenv
+
+Utility for easily reading application configurations for bound services and certificates in the SAP Cloud Platform Cloud Foundry environment, SAP XS advanced model and Kubernetes (K8S).
+
+
+## Install
+
+```sh
+npm install --save @sap/xsenv
+```
+
+## Usage
+
+```js
+var xsenv = require('@sap/xsenv');
+
+// Read the configuration for all bound service instances
+var services = xsenv.readServices();
+console.log(services.serviceInstance); // prints { credentials: { user: ..., pass:... }, name: 'serviceInstance', tags: [...], label: ...
+
+// Read the credentials for all bound service instances matching a given service query
+var services = xsenv.filterServices({ label: 'hana' });
+console.log(services); // prints [ { credentials: { ... } }, { credentials: { ... } } ]
+
+// Read only the credentials portion of the configuration for a service instance matching a given service query
+var svc = xsenv.serviceCredentials({ tag: 'hana' });
+console.log(svc); // prints { host: '...', port: '...', user: '...', password: '...', ... }
+
+// Read configuration for a service instance matching a given service query
+var services = xsenv.getServices({ hana: { name: 'hanaInstance' }}); // returns { hana: { host: '...', port: '...', user: '...', password: '...', ... } }
+var hanaInstanceCredentials = services.hana;
+
+```
+For specifics in the usage in different environments, read below.
+
+## Usage in Cloud Foundry and SAP XS Advanced
+
+Cloud Foundry and SAP XS advanced both provide application configurations via environment variables.
+The properties of the bound services are in [VCAP_SERVICES](http://docs.cloudfoundry.org/devguide/deploy-apps/environment-variable.html#VCAP-SERVICES) environment variable in both cases.
+
+### Updates in `readCFServices`
+
+Added support for reading service bindings from a file defined by the [`VCAP_SERVICES_FILE_PATH`](https://docs.cloudfoundry.org/devguide/deploy-apps/environment-variable.html#VCAP_SERVICES_FILE_PATH) environment variable.
+Implemented fallback logic to ensure compatibility with `VCAP_SERVICES` when `VCAP_SERVICES_FILE_PATH` is not set.
+
+### Service Lookup
+
+Normally in Cloud Foundry you bind a service instance to your application with a command like this one:
+```sh
+cf bind-service my-app aservice
+```
+
+Here is how you can get this service configuration in your Node.js application if you don't know the instance name in advance:
+```js
+var xsenv = require('@sap/xsenv');
+
+var services = xsenv.readServices();
+var svc = services[process.env.SERVICE_NAME];
+```
+
+You can look up services based on their metadata:
+```js
+var svc = xsenv.serviceCredentials({ tag: 'hdb' });
+console.log(svc); // prints { host: '...', port: '...', user: '...', password: '...', ... }
+```
+This example finds a service binding with `hdb` in the tags.
+See [Service Query](#service-query) below for description of the supported query values.
+
+You can also look up multiple services in a single call:
+```js
+var xsenv = require('@sap/xsenv');
+
+var services = xsenv.getServices({
+  hana: { tag: 'hdb' },
+  scheduler: { label: 'jobs' }
+});
+
+var hanaCredentials = services.hana;
+var schedulerCredentials = services.scheduler;
+```
+This example finds two services - one with tag `hdb` and the other with label `jobs`.
+`getServices` function provides additional convenience that default service configuration can be provided in a JSON file.
+
+To test the above example locally, create a file called `default-services.json` in the working directory of your application.
+This file should contain something like this:
+```json
+{
+  "hana": {
+    "host": "localhost",
+    "port": "30015",
+    "user": "SYSTEM",
+    "password": "secret"
+  },
+  "scheduler": {
+    "host": "localhost",
+    "port": "4242",
+    "user": "my_user",
+    "password": "secret"
+  }
+}
+```
+**Note:** The result property names (`hana` and `scheduler`) are the same as those in the query object and also those in `default-services.json`.
+
+[Local environment setup](#local-environment-setup) describes an alternative approach to provide service configurations for local testing.
+
+### User-Provided Service Instances
+
+While this package can look up any kind of bound service instances, you should be aware that [User-Provided Service Instances](https://docs.cloudfoundry.org/devguide/services/user-provided.html) have less properties than managed service instances. Here is an example:
+```json
+  "VCAP_SERVICES": {
+    "user-provided": [
+      {
+        "name": "pubsub",
+        "label": "user-provided",
+        "tags": [],
+        "credentials": {
+          "binary": "pubsub.rb",
+          "host": "pubsub01.example.com",
+          "password": "p@29w0rd",
+          "port": "1234",
+          "username": "pubsubuser"
+        },
+        "syslog_drain_url": ""
+	  }
+    ]
+  }
+```
+As you can see the only usable property is the `name`. In particular, there are no tags for a user-provided services.
+
+
+## Usage in Kubernetes
+
+Kubernetes offers several ways of handling application configurations for bound services and certificates. @sap/xsenv expects that such configurations are handled as Kubernetes Secrets and mounted as files to the pod at a specific path. This path can be provided by the application developer, but the default is `/etc/secrets/sapcp`. From there, @sap/xsenv assumes that the directory structure is the following `/etc/secrets/sapcp/<service-name>/<instance-name>`. Here `<service-name>` and `<instance-name>` are both directories and the latter contains the credentials/configurations for the service instance as files, where the file name is the name of the configuration/credential and the content is respectively the value.
+
+For example, the following folder structure:
+```sh
+
+/etc/
+    /secrets/
+            /sapcp/
+                 /hana/
+                 |    /hanaInst1/
+                 |    |          /user1
+                 |    |          /pass1
+                 |    /hanaInst2/
+                 |               /user2
+                 |               /pass2
+                 /xsuaa/
+                       /xsuaaInst/
+                                  /user
+                                  /pass
+```
+resembles two instances of service `hana` - `hanaInst1` and `hanaInst2` each with their own credentials/configurations and one instance of service `xsuaa` called `xsuaaInst` with its credentials.
+
+In Kubernetes you can create and bind to a service instance in the following way using the Service Catalog:
+
+```sh
+svcat provision xsuaaInst --class xsuaa --plan application
+svcat bind xsuaaInst --name xsuaaBind
+```
+Upon creation of the binding, the Service Catalog will create a Kubernetes secret (by default with the same name as the binding) containing credentials, configurations and certificates. This secret can then be mounted to the pod as a volume.
+
+The following *deployment.yml* file would generate the file structure above, assuming we have bindings `hanaBind1`, `hanaBind2` and `xsuaaBind` for service instances `hanaInst1`, `hanaInst2` and `xsuaaInst` created with Service Catalog:
+```sh
+...
+     containers:
+      - name: app
+        image: app-image:1.0.0
+        ports:
+          - appPort: 8080
+        volumeMounts:
+        - name: hana-volume-1
+          mountPath: "/etc/secrets/sapcp/hana/hanaInst1"
+          readOnly: true
+        - name: hana-volume-2
+          mountPath: "/etc/secrets/sapcp/hana/hanaInst2"
+          readOnly: true
+        - name: xsuaa-volume
+          mountPath: "/etc/secrets/sapcp/xsuaa/xsuaaInst"
+          readOnly: true
+      volumes:
+      - name: hana-volume-1
+        secret:
+          secretName: hanaBind1
+      - name: hana-volume-2
+        secret:
+          secretName: hanaBind2
+      - name: xsuaa-volume
+        secret:
+          secretName: xsuaaBind
+
+```
+
+Of course, you can also create Kubernetes secrets directly with `kubectl` and  mount them to the pod. As long as the mount path follows the `<root-path>/<service-name>/<instance-name>` pattern, @sap/xsenv will be able to read and filter the bound services configurations.
+
+**Note**: The library attempts to parse property values which represent valid JSON objects.
+Property values representing arrays are not being parsed.
+
+The following service credentials:
+
+```
+/etc/
+    /secrets/
+            /sapcp/
+                 /some-service/
+                       /some-instance/
+                                  /url   - containing https://some-service
+                                  /uaa   - containing { "url": "https://uaa", "clientid": "client", "clientsecret": "secret" }
+                                  /other - containing [1, "two"]
+```
+
+Will be available to the application as:
+
+```js
+{
+  url: 'https://some-service',
+  uaa: {
+    url: 'https://uaa',
+    clientid: 'client',
+    clientsecret: 'secret'
+  },
+  other: '[1, "two"]'
+}
+```
+
+### Service Lookup
+
+Service look up in the Kubernetes environment looks the same way as it does in the Cloud Foundry one.
+
+Looking at the above example of bound services here is how you can get the service configuration of `hanaInst1` in your node application:
+
+```js
+var xsenv = require('@sap/xsenv');
+
+var services = xsenv.readServices();
+console.log(services.hanaInst1.credentials); // prints { user1: '...', pass1: '...', ... }
+```
+
+Here is how to lookup the service based on its metadata in Kubernetes:
+```js
+var svc = xsenv.serviceCredentials({ label: 'hana' });
+console.log(svc); // prints { host: '...', port: '...', user: '...', passwrod: '...', ... }
+```
+This example finds a service binding with `hana` as a label. Note that for Kubernetes lookup based on metadata is limited. See [Service Query](#service-query) below for description of the supported query values in Cloud Foundry and Kubernetes.
+
+
+If you have mounted your secrets to a different path, you can pass it to @sap/xsenv like so:
+
+```js
+var xsenv = require('@sap/xsenv');
+
+var services = xsenv.getServices('/some/user/path', {
+  hana: { name: 'hanaInst1' },
+  xsuaa: { label: 'xsuaa' }
+});
+
+var hanaCredentials = services.hana;
+var schedulerCredentials = services.xsuaa;
+```
+### SERVICE_BINDING_ROOT environment variable
+
+@sap/xsenv now supports the standard `SERVICE_BINDING_ROOT` environment variable for specifying the root path of Kubernetes service bindings. This is a well-known convention used by other SAP and Cloud Native buildpacks.
+
+When no explicit path is provided to the service lookup functions, @sap/xsenv will use the following path resolution order:
+1. The path explicitly passed by the application developer
+2. The `SERVICE_BINDING_ROOT` environment variable (if set)
+3. The default path `/etc/secrets/sapcp`
+
+This allows you to configure the bindings root path via environment variable, without any code changes, which is especially useful in containerized or operator-managed deployments:
+
+```sh
+SERVICE_BINDING_ROOT=/bindings
+```
+
+
+## Local Usage
+
+For local testing you can provide configurations by yourself. This package allows you to provide default configurations in a separate configuration file.
+* This reduces clutter by removing configuration data from the app code.
+* You don't have to set env vars manually each time you start your app.
+* Different developers can use their own configurations for their local tests without changing files under source control. Just add this configuration file to `.gitignore` and `.cfignore`.
+
+You can provide default configurations on two levels:
+* For bound services via `getServices()` and `default-services.json`
+* For any environment variable via `loadEnv()` and `default-env.json`
+
+## Service Query
+
+Both `getServices` and `filterServices` use the same service query values. Due to specifics of the environment the queries in Cloud Foundry can be richer - see property table below.
+
+Query value | Description
+------------|------------
+{string}    | Matches the service with the same service instance name (`name` property). Same as `{ name: '<string>' }`.
+{object}    | All properties of the given object should match corresponding service instance properties as they appear in VCAP_SERVICES or the Kubernetes secret. See below what is supported on each platform.
+{function}  | A function that takes a service object as argument and returns `true`, only if it is considered a match.
+
+If an object is given as a query value, it may have the following properties:
+
+Property | CF  | K8S | Description
+---------|-----|-----|------------
+`name`   | yes | yes |Service instance name - the name you use to bind the service
+`label`  | yes | yes |Service name - the name shown by `cf marketplace`
+`tag`    | yes | no  |Should match any of the service tags
+`plan`   | yes | no  |Service instance plan - the plan you use in `cf create-service`
+
+If multiple properties are given, _all_ of them must match.
+
+**Note:** Do not confuse the instance name (`name` property) with the service name (`label` property).
+Since you can have multiple instances of the same service bound to your app,
+instance name is unique while service name is not.
+
+Here are some examples.
+
+Find a service instance by name:
+```js
+xsenv.serviceCredentials('hana');
+```
+
+Look up a service by tag:
+```js
+xsenv.serviceCredentials({ tag: 'relational' });
+```
+
+Match several properties:
+```js
+xsenv.serviceCredentials({ label: 'hana', plan: 'shared' });
+```
+
+Pass a custom filter function:
+```js
+xsenv.serviceCredentials(function(service) {
+  return /shared/.test(service.plan) && /hdi/.test(service.label);
+});
+```
+Notice that the filter function is called with the full service object as it appears in VCAP_SERVICES, but `serviceCredentials` returns only the `credentials` property of the matching service. The behaviour is the same in Kubernetes - the function will return only the contents of the `credentials` portion of the mounted secret.
+
+## API
+
+### getServices([path], query, [servicesFile])
+
+Looks up bound service instances matching the given query.
+If a service is not found - returns default service configuration loaded from a JSON file. The order of lookup is VCAP_SERVICES -> mounted secrets path in K8S -> default service configuration.
+
+* `path` - (optional) A string containing the mount path where the secrets are located in Kubernetes. By default is "/etc/secrets/sapcp". For example, by default the credentials for an instance "inst-name" of service "service-name" would be located under "/etc/secrets/sapcp/service-name/inst-name".
+* `query` - An object describing requested services. Each property value is a filter as described in [Service Query](#service-query)
+* `servicesFile` - (optional) path to JSON file to load default service configuration (default is default-services.json).
+If `null`, do not load default service configuration.
+* _returns_ - An object with the same properties as in query argument where the value of each property is the respective service credentials object
+* _throws_ - An error, if for some of the requested services no or multiple instances are found
+
+### serviceCredentials([path], filter)
+
+Looks up a bound service instance matching the given filter works for both the Kubernetes and Cloud Foundry environments.
+
+**Note:** This function does not load default service configuration from default-services.json.
+
+* `path` - (optional) A string containing the mount path where the secrets are located in Kubernetes. By default is "/etc/secrets/sapcp".
+* `filter` - Service lookup criteria as described in [Service Query](#service-query)
+* _returns_ - Credentials object of found service
+* _throws_ - An error in case no or multiple matching services are found
+
+### filterServices([path], filter)
+
+Returns all bound services that match the given criteria. Works in Cloud Foundry and Kubernetes.
+
+* `path` - (optional) A string containing the mount path where the secrets are located in Kubernetes. By default is "/etc/secrets/sapcp".
+* `filter` - Service lookup criteria as described in [Service Query](#service-query)
+* _returns_ - An array of credentials objects of matching services. Empty array, if no matches found.
+
+### readServices([path], [options])
+
+* `path` - (optional) A string containing the mount path where the secrets are located in Kubernetes. By default is "/etc/secrets/sapcp".
+* `options` - (optional) An object with options to customize behavior. Only supports field `disableCache` to disable K8s secrets caching.
+* _returns_ Returns an object where each service instance is mapped to its name. Works in Kubernetes and Cloud Foundry.
+
+For example, given this VCAP_SERVICES:
+```
+  {
+    "hana" : [ {
+      "credentials" : {
+        ...
+      },
+      "label" : "hana",
+      "name" : "hana1",
+      "plan" : "shared",
+      "tags" : [ "hana", "relational" ]
+    },
+    {
+      "credentials" : {
+        ...
+      },
+      "label" : "hana",
+      "name" : "hana2",
+      "plan" : "shared",
+      "tags" : [ "hana", "relational", "SP09" ]
+    } ]
+  }
+```
+`readServices` would return:
+```
+{
+  hana1: {
+    "credentials" : {
+      ...
+    },
+    "label" : "hana",
+    "name" : "hana1",
+    "plan" : "shared",
+    "tags" : [ "hana", "relational" ]
+  },
+  hana2: {
+    "credentials" : {
+      ...
+    },
+    "label" : "hana",
+    "name" : "hana2",
+    "plan" : "shared",
+    "tags" : [ "hana", "relational", "SP09" ]
+  }
+}
+```
+
+
+### cfServiceCredentials(filter)
+
+Same as [serviceCredentials(filter)](#servicecredentialspath-filter) but works only in Cloud Foundry. It is recommended to use the generic function.
+
+### filterCFServices(filter)
+
+Same as [filterServices(filter)](#filterservicespath-filter) but works only in Cloud Foundry. It is recommended to use the generic function.
+
+### readCFServices()
+
+Same as [readServices()](#readservicespath) but works only in Cloud Foundry. It is recommended to use the generic function.
+
+## Local environment setup
+
+To test your application locally you often need to setup its environment so that resembles the environment in Cloud Foundry or Kubernetes.
+You can do this easily by defining the necessary environment variables in a JSON file.
+
+For example you can create file _default-env.json_ with the following content in the working directory of the application :
+```json
+{
+  "PORT": 3000,
+  "VCAP_SERVICES": {
+    "hana": [
+      {
+        "credentials": {
+          "host": "myhana",
+          "port": "30015",
+          "user": "SYSTEM",
+          "password": "secret"
+        },
+        "label": "hana",
+        "name": "hana-R90",
+        "tags": [
+          "hana",
+          "database",
+          "relational"
+        ]
+      }
+    ],
+    "scheduler": [
+      {
+        "credentials": {
+          "host": "localhost",
+          "port": "4242",
+          "user": "jobuser",
+          "password": "jobpassword"
+        },
+        "label": "scheduler",
+        "name": "jobscheduler",
+        "tags": [
+          "scheduler"
+        ]
+      }
+    ]
+  }
+}
+```
+Then load it in your application:
+```js
+xsenv.loadEnv();
+console.log(process.env.PORT); // prints 3000
+console.log(xsenv.cfServiceCredentials('hana-R90')); // prints { host: 'myhana, port: '30015', user: 'SYSTEM', password: 'secret' }
+```
+
+This way you don't need in your code conditional logic if it is running in Cloud Foundry or locally.
+
+You can also use a different file name:
+```js
+xsenv.loadEnv('myenv.json');
+```
+
+### loadEnv([file])
+
+Loads the environment from a JSON file.
+This function converts each top-level property to a string and sets it in the respective environment variable,
+unless it is already set. This function does not change existing environment variables. So the file content acts like default values for environment variables.
+
+This function does not complain if the file does not exist.
+
+* `file` - optional name of JSON file to load, `'default-env.json'` by default. Does nothing if the file does not exist.
+
+## Loading SSL Certificates
+
+If SSL is configured in XS advanced On-Premise Runtime, it will provide one or more
+trusted CA certificates that applications can use to make SSL connections.
+If present, the file paths of these certificates are listed in `XS_CACERT_PATH`
+environment variable separated by `path.delimiter` (`:` on LINUX and `;` on Windows).
+
+### loadCertificates([certPath])
+
+Loads the certificates listed in the given path.
+If this argument is not provided, it uses `XS_CACERT_PATH` environment variable instead.
+If that is not set either, the function returns `undefined`.
+The function returns an array even if a single certificate is provided.
+This function is synchronous.
+
+* `certPath` - optional string with certificate files to load. The file names are separated by `path.delimiter`. Default is `process.env.XS_CACERT_PATH`.
+* _returns_ - an array of loaded certificates or `undefined` if `certPath` argument is not provided
+* _throws_ - an error, if some of the files could not be loaded
+
+For example, this code loads the trusted CA certificates so they are used for all
+subsequent outgoing HTTPS connections:
+```js
+var https = require('https');
+var xsenv = require('@sap/xsenv');
+
+https.globalAgent.options.ca = xsenv.loadCertificates();
+```
+
+This function can be used also to load SSL certificates for HANA like this:
+```js
+var hdb = require('hdb');
+var xsenv = require('@sap/xsenv');
+
+var client = hdb.createClient({
+  host : 'hostname',
+  port : 30015,
+  ca   : xsenv.loadCertificates(),
+  ...
+});
+```
+
+## Debugging
+
+Set `DEBUG=xsenv` in the environment to enable debug traces. See [debug](https://www.npmjs.com/package/debug) package for details.

package/node_modules/@sap/xsenv/index.js

@@ -0,0 +1,17 @@
+
+var cfservice = require('./lib/cfservice');
+var xsservices = require('./lib/xsservices');
+var cacert = require('./lib/cacert');
+
+exports.loadCertificates = cacert.loadCertificates;
+exports.loadEnv = require('./lib/loadEnv');
+
+exports.getServices = xsservices.getServices;
+exports.filterServices = xsservices.filterServices;
+exports.serviceCredentials = xsservices.serviceCredentials;
+exports.readServices = xsservices.readServices;
+
+// CF specific
+exports.readCFServices = cfservice.readCFServices;
+exports.cfServiceCredentials = xsservices.serviceCredentials;
+exports.filterCFServices = cfservice.filterCFServices;

package/node_modules/@sap/xsenv/lib/cacert.js

@@ -0,0 +1,26 @@
+
+var debug = require('debug')('xsenv');
+var path = require('path');
+var fs = require('fs');
+var assert = require('assert');
+var VError = require('verror');
+
+exports.loadCertificates = loadCertificates;
+
+function loadCertificates(certPath) {
+  assert(!certPath || typeof certPath === 'string', 'certPath argument should be a string');
+
+  certPath = certPath || process.env.XS_CACERT_PATH;
+  if (certPath) {
+    debug('Loading certificate(s) %s', certPath);
+    try {
+      return certPath
+        .split(path.delimiter)
+        .map(function (f) {
+          return fs.readFileSync(f);
+        });
+    } catch (err) {
+      throw new VError(err, 'Could not load certificate(s) ' + certPath);
+    }
+  }
+}