@juit/pgproxy-client-node 1.0.0

package/README.md

@@ -0,0 +1,33 @@
+# PostgreSQL Proxy Client (NodeJS Implementation)
+
+This package provides a NodeJS specific client for PGProxy Servers.
+
+* [Usage with PGClient](#usage-with-pgclient)
+* [Direct Usage](#direct-usage)
+* [PGProxy](https://github.com/juitnow/juit-pgproxy/blob/main/README.md)
+* [Copyright Notice](https://github.com/juitnow/juit-pgproxy/blob/main/NOTICE.md)
+* [License](https://github.com/juitnow/juit-pgproxy/blob/main/NOTICE.md)
+
+### Usage with PGClient
+
+Simply register the client by importing it, and ensure that the `PGURL`
+environment variable is set to the HTTP/HTTPS url of the server (or specify
+the URL in the constructor):
+
+```ts
+import '@juit/pgproxy-client-node'
+import { PGClient } from '@juit/pgproxy-client'
+
+const client = new PGClient('https://my-secret@my-pgproxy-server:54321/')
+```
+
+### Direct usage
+
+The NodeJS client can be used directly by simply importing the `NodeClient`
+class:
+
+```ts
+import { NodeClient } from '@juit/pgproxy-client-node'
+
+const client = new NodeClient('https://my-secret@my-pgproxy-server:54321/')
+```

package/dist/index.cjs

@@ -0,0 +1,139 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var src_exports = {};
+__export(src_exports, {
+  NodeClient: () => NodeClient,
+  NodeProvider: () => NodeProvider
+});
+module.exports = __toCommonJS(src_exports);
+var import_node_crypto = require("node:crypto");
+var import_node_http = require("node:http");
+var import_node_https = require("node:https");
+var import_pgproxy_client = require("@juit/pgproxy-client");
+var import_ws = __toESM(require("ws"));
+function getAuthenticationToken(secret) {
+  const buffer = (0, import_node_crypto.randomBytes)(48);
+  buffer.writeBigInt64LE(BigInt(Date.now()), 0);
+  (0, import_node_crypto.createHmac)("sha256", Buffer.from(secret, "utf8")).update(buffer.subarray(0, 16)).digest().copy(buffer, 16);
+  return buffer.toString("base64");
+}
+function makeQuery(url, secret) {
+  const protocol = url.protocol === "https:" ? import_node_https.request : url.protocol === "http:" ? import_node_http.request : void 0;
+  (0, import_pgproxy_client.assert)(protocol, `Unsupported protocol "${url.protocol}"`);
+  const href = url.href;
+  return function query(query, params) {
+    const id = (0, import_node_crypto.randomUUID)();
+    return new Promise((resolve, reject) => {
+      const token = getAuthenticationToken(secret);
+      const url2 = new URL(href);
+      url2.searchParams.set("auth", token);
+      const req = protocol(url2, {
+        method: "POST",
+        headers: { "content-type": "application/json" }
+      }, (res) => {
+        const buffers = [];
+        res.on(
+          "error",
+          /* coverage ignore next */
+          (error) => reject(error)
+        );
+        res.on("data", (buffer2) => buffers.push(buffer2));
+        res.on("end", () => {
+          if (res.headers["content-type"] !== "application/json") {
+            return reject(new Error(`Invalid response (status=${res.statusCode})`));
+          } else {
+            const data = Buffer.concat(buffers).toString("utf-8");
+            return resolve(data);
+          }
+        });
+      });
+      const body = { id, query, params };
+      const buffer = JSON.stringify(body);
+      req.write(buffer);
+      req.end();
+    }).then((data) => {
+      let payload;
+      try {
+        payload = JSON.parse(data);
+      } catch (error) {
+        throw new Error("Unable to parse JSON payload");
+      }
+      (0, import_pgproxy_client.assert)(payload && typeof payload === "object", "JSON payload is not an object");
+      (0, import_pgproxy_client.assert)(payload.id === id, "Invalid/uncorrelated ID in response");
+      if (payload.statusCode === 200)
+        return payload;
+      throw new Error(`${payload.error || /* coverage ignore next */
+      "Unknown error"} (${payload.statusCode})`);
+    });
+  };
+}
+var NodeProvider = class extends import_pgproxy_client.WebSocketProvider {
+  constructor(url) {
+    super();
+    url = new URL(url.href);
+    const secret = decodeURIComponent(url.password || url.username);
+    (0, import_pgproxy_client.assert)(secret, "No connection secret specified in URL");
+    url.password = "";
+    url.username = "";
+    const baseHttpUrl = new URL(url.href);
+    const baseWsUrl = new URL(url.href);
+    baseWsUrl.protocol = `ws${baseWsUrl.protocol.slice(4)}`;
+    this._getUniqueRequestId = () => (0, import_node_crypto.randomUUID)();
+    this._getWebSocket = async () => {
+      const token = await getAuthenticationToken(secret);
+      const wsUrl = new URL(baseWsUrl.href);
+      wsUrl.searchParams.set("auth", token);
+      return this._connectWebSocket(new import_ws.default(wsUrl));
+    };
+    this.query = makeQuery(baseHttpUrl, secret);
+  }
+  /* ======================================================================== *
+   * METHODS FROM CONSTRUCTOR                                                 *
+   * ======================================================================== */
+  query;
+  _getWebSocket;
+  _getUniqueRequestId;
+};
+var NodeClient = class extends import_pgproxy_client.PGClient {
+  constructor(url) {
+    url = url || process.env.PGURL;
+    (0, import_pgproxy_client.assert)(url, "No URL to connect to (PGURL environment variable missing?)");
+    super(new NodeProvider(typeof url === "string" ? new URL(url) : url));
+  }
+};
+(0, import_pgproxy_client.registerProvider)("http", NodeProvider);
+(0, import_pgproxy_client.registerProvider)("https", NodeProvider);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NodeClient,
+  NodeProvider
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yBAAoD;AACpD,uBAAgC;AAChC,wBAAiC;AAEjC,4BAAsE;AACtE,gBAAsB;AAOtB,SAAS,uBAAuB,QAAwB;AACtD,QAAM,aAAS,gCAAY,EAAE;AAE7B,SAAO,gBAAgB,OAAO,KAAK,IAAI,CAAC,GAAG,CAAC;AAE5C,qCAAW,UAAU,OAAO,KAAK,QAAQ,MAAM,CAAC,EAC3C,OAAO,OAAO,SAAS,GAAG,EAAE,CAAC,EAC7B,OAAO,EACP,KAAK,QAAQ,EAAE;AAEpB,SAAO,OAAO,SAAS,QAAQ;AACjC;AAEA,SAAS,UAAU,KAAU,QAGI;AAC/B,QAAM,WACF,IAAI,aAAa,WAAW,kBAAAA,UAC5B,IAAI,aAAa,UAAU,iBAAAC,UAC3B;AACJ,oCAAO,UAAU,yBAAyB,IAAI,QAAQ,GAAG;AACzD,QAAM,OAAO,IAAI;AAEjB,SAAO,SAAS,MACZ,OACA,QAC2B;AAC7B,UAAM,SAAK,+BAAW;AAEtB,WAAO,IAAI,QAAgB,CAAC,SAAS,WAAW;AAC9C,YAAM,QAAQ,uBAAuB,MAAM;AAC3C,YAAMC,OAAM,IAAI,IAAI,IAAI;AACxB,MAAAA,KAAI,aAAa,IAAI,QAAQ,KAAK;AAElC,YAAM,MAAM,SAASA,MAAK;AAAA,QACxB,QAAQ;AAAA,QACR,SAAS,EAAE,gBAAgB,mBAAmB;AAAA,MAChD,GAAG,CAAC,QAAQ;AACV,cAAM,UAAoB,CAAC;AAC3B,YAAI;AAAA,UAAG;AAAA;AAAA,UAAoC,CAAC,UAAU,OAAO,KAAK;AAAA,QAAC;AACnE,YAAI,GAAG,QAAQ,CAACC,YAAW,QAAQ,KAAKA,OAAM,CAAC;AAC/C,YAAI,GAAG,OAAO,MAAM;AAClB,cAAI,IAAI,QAAQ,cAAc,MAAM,oBAAoB;AACtD,mBAAO,OAAO,IAAI,MAAM,4BAA4B,IAAI,UAAU,GAAG,CAAC;AAAA,UACxE,OAAO;AACL,kBAAM,OAAO,OAAO,OAAO,OAAO,EAAE,SAAS,OAAO;AACpD,mBAAO,QAAQ,IAAI;AAAA,UACrB;AAAA,QACF,CAAC;AAAA,MACH,CAAC;AAED,YAAM,OAAgB,EAAE,IAAI,OAAO,OAAO;AAC1C,YAAM,SAAS,KAAK,UAAU,IAAI;AAClC,UAAI,MAAM,MAAM;AAChB,UAAI,IAAI;AAAA,IACV,CAAC,EAAE,KAAK,CAAC,SAAiB;AACxB,UAAI;AAEJ,UAAI;AACF,kBAAU,KAAK,MAAM,IAAI;AAAA,MAC3B,SAAS,OAAO;AACd,cAAM,IAAI,MAAM,8BAA8B;AAAA,MAChD;AAGA,wCAAO,WAAY,OAAO,YAAY,UAAW,+BAA+B;AAChF,wCAAO,QAAQ,OAAO,IAAI,qCAAqC;AAG/D,UAAI,QAAQ,eAAe;AAAK,eAAO;AACvC,YAAM,IAAI,MAAM,GAAG,QAAQ;AAAA,MAAoC,eAAe,KAAK,QAAQ,UAAU,GAAG;AAAA,IAC1G,CAAC;AAAA,EACH;AACF;AAMO,IAAM,eAAN,cAA2B,wCAAkB;AAAA,EAClD,YAAY,KAAU;AACpB,UAAM;AAGN,UAAM,IAAI,IAAI,IAAI,IAAI;AAItB,UAAM,SAAS,mBAAmB,IAAI,YAAY,IAAI,QAAQ;AAC9D,sCAAO,QAAQ,uCAAuC;AACtD,QAAI,WAAW;AACf,QAAI,WAAW;AAGf,UAAM,cAAc,IAAI,IAAI,IAAI,IAAI;AACpC,UAAM,YAAY,IAAI,IAAI,IAAI,IAAI;AAClC,cAAU,WAAW,KAAK,UAAU,SAAS,MAAM,CAAC,CAAC;AAGrD,SAAK,sBAAsB,UAAc,+BAAW;AAEpD,SAAK,gBAAgB,YAAgC;AACnD,YAAM,QAAQ,MAAM,uBAAuB,MAAM;AACjD,YAAM,QAAQ,IAAI,IAAI,UAAU,IAAI;AACpC,YAAM,aAAa,IAAI,QAAQ,KAAK;AACpC,aAAO,KAAK,kBAAkB,IAAI,UAAAC,QAAU,KAAK,CAAC;AAAA,IACpD;AAEA,SAAK,QAAQ,UAAU,aAAa,MAAM;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA,EAMA;AAAA,EACU;AAAA,EACA;AACZ;AAEO,IAAM,aAAN,cAAyB,+BAAS;AAAA,EACvC,YAAY,KAAoB;AAC9B,UAAM,OAAO,QAAQ,IAAI;AACzB,sCAAO,KAAK,4DAA4D;AACxE,UAAM,IAAI,aAAa,OAAO,QAAQ,WAAW,IAAI,IAAI,GAAG,IAAI,GAAG,CAAC;AAAA,EACtE;AACF;AAAA,IAEA,wCAAiB,QAAQ,YAAY;AAAA,IACrC,wCAAiB,SAAS,YAAY;",
+  "names": ["https", "http", "url", "buffer", "WebSocket"]
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { PGClient, WebSocketProvider } from '@juit/pgproxy-client';
+import WebSocket from 'ws';
+import type { PGConnectionResult } from '@juit/pgproxy-client';
+export declare class NodeProvider extends WebSocketProvider {
+    constructor(url: URL);
+    query: (query: string, params: (string | null)[]) => Promise<PGConnectionResult>;
+    protected _getWebSocket: () => Promise<WebSocket>;
+    protected _getUniqueRequestId: () => string;
+}
+export declare class NodeClient extends PGClient {
+    constructor(url?: URL | string);
+}

package/dist/index.mjs

@@ -0,0 +1,103 @@
+// index.ts
+import { createHmac, randomBytes, randomUUID } from "node:crypto";
+import { request as http } from "node:http";
+import { request as https } from "node:https";
+import { PGClient, WebSocketProvider, assert, registerProvider } from "@juit/pgproxy-client";
+import WebSocket from "ws";
+function getAuthenticationToken(secret) {
+  const buffer = randomBytes(48);
+  buffer.writeBigInt64LE(BigInt(Date.now()), 0);
+  createHmac("sha256", Buffer.from(secret, "utf8")).update(buffer.subarray(0, 16)).digest().copy(buffer, 16);
+  return buffer.toString("base64");
+}
+function makeQuery(url, secret) {
+  const protocol = url.protocol === "https:" ? https : url.protocol === "http:" ? http : void 0;
+  assert(protocol, `Unsupported protocol "${url.protocol}"`);
+  const href = url.href;
+  return function query(query, params) {
+    const id = randomUUID();
+    return new Promise((resolve, reject) => {
+      const token = getAuthenticationToken(secret);
+      const url2 = new URL(href);
+      url2.searchParams.set("auth", token);
+      const req = protocol(url2, {
+        method: "POST",
+        headers: { "content-type": "application/json" }
+      }, (res) => {
+        const buffers = [];
+        res.on(
+          "error",
+          /* coverage ignore next */
+          (error) => reject(error)
+        );
+        res.on("data", (buffer2) => buffers.push(buffer2));
+        res.on("end", () => {
+          if (res.headers["content-type"] !== "application/json") {
+            return reject(new Error(`Invalid response (status=${res.statusCode})`));
+          } else {
+            const data = Buffer.concat(buffers).toString("utf-8");
+            return resolve(data);
+          }
+        });
+      });
+      const body = { id, query, params };
+      const buffer = JSON.stringify(body);
+      req.write(buffer);
+      req.end();
+    }).then((data) => {
+      let payload;
+      try {
+        payload = JSON.parse(data);
+      } catch (error) {
+        throw new Error("Unable to parse JSON payload");
+      }
+      assert(payload && typeof payload === "object", "JSON payload is not an object");
+      assert(payload.id === id, "Invalid/uncorrelated ID in response");
+      if (payload.statusCode === 200)
+        return payload;
+      throw new Error(`${payload.error || /* coverage ignore next */
+      "Unknown error"} (${payload.statusCode})`);
+    });
+  };
+}
+var NodeProvider = class extends WebSocketProvider {
+  constructor(url) {
+    super();
+    url = new URL(url.href);
+    const secret = decodeURIComponent(url.password || url.username);
+    assert(secret, "No connection secret specified in URL");
+    url.password = "";
+    url.username = "";
+    const baseHttpUrl = new URL(url.href);
+    const baseWsUrl = new URL(url.href);
+    baseWsUrl.protocol = `ws${baseWsUrl.protocol.slice(4)}`;
+    this._getUniqueRequestId = () => randomUUID();
+    this._getWebSocket = async () => {
+      const token = await getAuthenticationToken(secret);
+      const wsUrl = new URL(baseWsUrl.href);
+      wsUrl.searchParams.set("auth", token);
+      return this._connectWebSocket(new WebSocket(wsUrl));
+    };
+    this.query = makeQuery(baseHttpUrl, secret);
+  }
+  /* ======================================================================== *
+   * METHODS FROM CONSTRUCTOR                                                 *
+   * ======================================================================== */
+  query;
+  _getWebSocket;
+  _getUniqueRequestId;
+};
+var NodeClient = class extends PGClient {
+  constructor(url) {
+    url = url || process.env.PGURL;
+    assert(url, "No URL to connect to (PGURL environment variable missing?)");
+    super(new NodeProvider(typeof url === "string" ? new URL(url) : url));
+  }
+};
+registerProvider("http", NodeProvider);
+registerProvider("https", NodeProvider);
+export {
+  NodeClient,
+  NodeProvider
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts"],
+  "mappings": "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",
+  "names": ["url", "buffer"]
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@juit/pgproxy-client-node",
+  "version": "1.0.0",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.cjs"
+      },
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.mjs"
+      }
+    }
+  },
+  "author": "Juit Developers <developers@juit.com>",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/juitnow/juit-pgproxy.git"
+  },
+  "keywords": [
+    "database",
+    "pg",
+    "pool",
+    "postgres",
+    "proxy"
+  ],
+  "bugs": {
+    "url": "https://github.com/juitnow/juit-pgproxy/issues"
+  },
+  "homepage": "https://github.com/juitnow/juit-pgproxy#readme",
+  "dependencies": {
+    "@juit/pgproxy-client": "1.0.0",
+    "@types/ws": "^8.5.10",
+    "ws": "^8.15.1"
+  },
+  "directories": {
+    "test": "test"
+  },
+  "files": [
+    "*.md",
+    "dist/",
+    "src/"
+  ]
+}

package/src/index.ts

@@ -0,0 +1,143 @@
+import { createHmac, randomBytes, randomUUID } from 'node:crypto'
+import { request as http } from 'node:http'
+import { request as https } from 'node:https'
+
+import { PGClient, WebSocketProvider, assert, registerProvider } from '@juit/pgproxy-client'
+import WebSocket from 'ws'
+
+import type { PGConnectionResult } from '@juit/pgproxy-client'
+import type { Request, Response } from '@juit/pgproxy-server'
+
+
+/** Create our authentication token */
+function getAuthenticationToken(secret: string): string {
+  const buffer = randomBytes(48)
+
+  buffer.writeBigInt64LE(BigInt(Date.now()), 0)
+
+  createHmac('sha256', Buffer.from(secret, 'utf8'))
+      .update(buffer.subarray(0, 16))
+      .digest()
+      .copy(buffer, 16)
+
+  return buffer.toString('base64')
+}
+
+function makeQuery(url: URL, secret: string): (
+  query: string,
+  params: (string | null)[],
+) => Promise<PGConnectionResult> {
+  const protocol =
+      url.protocol === 'https:' ? https :
+      url.protocol === 'http:' ? http :
+      undefined
+  assert(protocol, `Unsupported protocol "${url.protocol}"`)
+  const href = url.href
+
+  return function query(
+      query: string,
+      params: (string | null)[],
+  ): Promise<PGConnectionResult> {
+    const id = randomUUID()
+
+    return new Promise<string>((resolve, reject) => {
+      const token = getAuthenticationToken(secret)
+      const url = new URL(href)
+      url.searchParams.set('auth', token)
+
+      const req = protocol(url, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+      }, (res) => {
+        const buffers: Buffer[] = []
+        res.on('error', /* coverage ignore next */ (error) => reject(error))
+        res.on('data', (buffer) => buffers.push(buffer))
+        res.on('end', () => {
+          if (res.headers['content-type'] !== 'application/json') {
+            return reject(new Error(`Invalid response (status=${res.statusCode})`))
+          } else {
+            const data = Buffer.concat(buffers).toString('utf-8')
+            return resolve(data)
+          }
+        })
+      })
+
+      const body: Request = { id, query, params }
+      const buffer = JSON.stringify(body)
+      req.write(buffer)
+      req.end()
+    }).then((data: string) => {
+      let payload: Response
+      /* coverage ignore catch */
+      try {
+        payload = JSON.parse(data)
+      } catch (error) {
+        throw new Error('Unable to parse JSON payload')
+      }
+
+      /* Correlate our response to the request */
+      assert(payload && (typeof payload === 'object'), 'JSON payload is not an object')
+      assert(payload.id === id, 'Invalid/uncorrelated ID in response')
+
+      /* Analyze the _payload_ status code, is successful, we have a winner! */
+      if (payload.statusCode === 200) return payload
+      throw new Error(`${payload.error || /* coverage ignore next */ 'Unknown error'} (${payload.statusCode})`)
+    })
+  }
+}
+
+/* ========================================================================== *
+ *                                                                            *
+ * ========================================================================== */
+
+export class NodeProvider extends WebSocketProvider {
+  constructor(url: URL) {
+    super()
+
+    /* Clone the URL and verify it's http/https */
+    url = new URL(url.href)
+
+    /* Extract the secret from the url, we support both "http://secret@host/..."
+     * and/or "http://whomever:secret@host/..." formats, discarding username */
+    const secret = decodeURIComponent(url.password || url.username)
+    assert(secret, 'No connection secret specified in URL')
+    url.password = ''
+    url.username = ''
+
+    /* Prepare the URL for http and web sockets */
+    const baseHttpUrl = new URL(url.href)
+    const baseWsUrl = new URL(url.href)
+    baseWsUrl.protocol = `ws${baseWsUrl.protocol.slice(4)}`
+
+    /* Our methods */
+    this._getUniqueRequestId = (): string => randomUUID()
+
+    this._getWebSocket = async (): Promise<WebSocket> => {
+      const token = await getAuthenticationToken(secret)
+      const wsUrl = new URL(baseWsUrl.href)
+      wsUrl.searchParams.set('auth', token)
+      return this._connectWebSocket(new WebSocket(wsUrl))
+    }
+
+    this.query = makeQuery(baseHttpUrl, secret)
+  }
+
+  /* ======================================================================== *
+   * METHODS FROM CONSTRUCTOR                                                 *
+   * ======================================================================== */
+
+  query: (query: string, params: (string | null)[]) => Promise<PGConnectionResult>
+  protected _getWebSocket: () => Promise<WebSocket>
+  protected _getUniqueRequestId: () => string
+}
+
+export class NodeClient extends PGClient {
+  constructor(url?: URL | string) {
+    url = url || process.env.PGURL
+    assert(url, 'No URL to connect to (PGURL environment variable missing?)')
+    super(new NodeProvider(typeof url === 'string' ? new URL(url) : url))
+  }
+}
+
+registerProvider('http', NodeProvider)
+registerProvider('https', NodeProvider)