@cap-js-community/common 0.1.0

package/src/rate-limiting/RateLimiting.js

@@ -0,0 +1,213 @@
+"use strict";
+
+const cds = require("@sap/cds");
+
+const redisCounter = require("./redis/counter");
+const redisResetTime = require("./redis/resetTime");
+
+const { connectionCheck } = require("./redis/common");
+
+const COMPONENT_NAME = "rateLimiting";
+
+class RateLimiting {
+  constructor(service, { maxConcurrent, maxInWindow, window } = {}) {
+    this.log = cds.log(COMPONENT_NAME);
+    this.service = service;
+    this.id = service.name;
+    this.resetTime = null;
+    this.tenantCounts = {}; // [<tenant>: {concurrent: 0, window: 0}]
+    this.maxConcurrent =
+      maxConcurrent || service.definition["@cds.rateLimt.maxConcurrent"] || cds.env.rateLimiting.maxConcurrent;
+    this.maxInWindow =
+      maxInWindow || service.definition["@cds.rateLimt.maxInWindow"] || cds.env.rateLimiting.maxInWindow;
+    this.window = window || service.definition["@cds.rateLimt.window"] || cds.env.rateLimiting.window;
+    this.redisActive = cds.env.rateLimiting.redis;
+  }
+
+  async setup() {
+    if (this.redisActive && !(await connectionCheck())) {
+      this.redisActive = cds.env.rateLimiting.redis = false;
+    }
+    this.redisTenantInWindowCounts = redisCounter({
+      name: `rateLimiting:${this.id}:inWindowCounts`,
+    });
+    this.redisTenantResetTime = redisResetTime({
+      name: `rateLimiting:${this.id}:resetTime`,
+    });
+    this.monitor(this.service);
+    this.log.info("using rate limiting", {
+      service: this.service.name,
+      maxConcurrent: this.maxConcurrent,
+      maxInWindow: this.maxInWindow,
+      window: this.window,
+      redis: this.redisActive,
+    });
+  }
+
+  initTenant(tenant) {
+    tenant = tenant || "";
+    this.tenantCounts[tenant] = this.tenantCounts[tenant] || { concurrent: 0, window: 0 };
+    return tenant;
+  }
+
+  async calcResetTime() {
+    this.resetTime = new Date();
+    this.resetTime.setMilliseconds(this.resetTime.getMilliseconds() + this.window);
+    await (await this.redisTenantResetTime).set(this.resetTime);
+    return this.resetTime;
+  }
+
+  async nextResetTime() {
+    this.resetTime = await (await this.redisTenantResetTime).get();
+    if (this.resetTime) {
+      return this.resetTime;
+    }
+    return await this.calcResetTime();
+  }
+
+  async increment(tenant) {
+    tenant = this.initTenant(tenant);
+    const concurrentCount = this.tenantCounts[tenant].concurrent + 1;
+    this.tenantCounts[tenant].concurrent = concurrentCount;
+    const inWindowCount = await (await this.redisTenantInWindowCounts).increment(tenant);
+    this.tenantCounts[tenant].window = inWindowCount;
+    return {
+      ok: concurrentCount <= this.maxConcurrent && inWindowCount <= this.maxInWindow,
+      count: {
+        concurrent: concurrentCount,
+        inWindow: inWindowCount,
+      },
+      exceeds: {
+        concurrent: concurrentCount > this.maxConcurrent,
+        inWindow: inWindowCount > this.maxInWindow,
+      },
+    };
+  }
+
+  async decrement(tenant) {
+    tenant = this.initTenant(tenant);
+    const concurrentCount = this.tenantCounts[tenant].concurrent - 1;
+    this.tenantCounts[tenant].concurrent = Math.max(concurrentCount, 0);
+  }
+
+  async clearInWindow(tenant) {
+    tenant = this.initTenant(tenant);
+    this.tenantCounts[tenant].window = await (await this.redisTenantInWindowCounts).reset(tenant);
+  }
+
+  async clearAllInWindow() {
+    await this.calcResetTime();
+    await Promise.allDone(
+      Object.keys(this.tenantCounts).map(async (tenant) => {
+        await this.clearInWindow(tenant);
+      }),
+    );
+  }
+
+  isExternal(req) {
+    return !!req.protocol?.match(/rest|odata/);
+  }
+
+  monitor(srv) {
+    srv.rateLimiting = this;
+
+    if (parseInt(process.env.CF_INSTANCE_INDEX) === 0) {
+      (async () => {
+        try {
+          await this.calcResetTime();
+        } catch (err) {
+          this.log.error("Resetting rate limit time failed", err);
+        }
+        setInterval(async () => {
+          try {
+            await this.clearAllInWindow();
+          } catch (err) {
+            this.log.error("Resetting rate limit window failed", err);
+          }
+        }, this.window).unref();
+      })();
+    }
+
+    srv.before("*", async (req) => {
+      if (!req.http?.req) {
+        return;
+      }
+
+      // decrement
+      req.on("succeeded", async () => {
+        if (this.isExternal(req)) {
+          await this.decrement(req.tenant);
+        }
+      });
+      req.on("failed", async () => {
+        if (this.isExternal(req)) {
+          await this.decrement(req.tenant);
+        }
+      });
+
+      // increment
+      if (this.isExternal(req)) {
+        try {
+          const status = await this.increment(req.tenant);
+          if (status.ok) {
+            await this.accept(req, status);
+          } else {
+            await this.reject(req, status);
+          }
+        } catch (err) {
+          this.log.error("Incrementing rate limit counter failed", err);
+          await this.reject(req, { ok: false });
+        }
+      }
+    });
+  }
+
+  async accept(req, status) {
+    try {
+      await this.addHeaders(req, status.count);
+    } catch (err) {
+      this.log.error("Adding rate limit headers failed", err);
+      await this.reject(req, { ok: false });
+    }
+  }
+
+  async reject(req, status) {
+    try {
+      await this.addHeaders(req, status.count);
+    } catch (err) {
+      this.log.error("Adding rate limit headers failed", err);
+    }
+    if (status.exceeds?.inWindow) {
+      req.error({
+        code: "TOO_MANY_REQUESTS",
+        status: 429,
+        message: `Too many requests in time window (max ${this.maxInWindow}), please try again later.`,
+      });
+    } else if (status.exceeds?.concurrent) {
+      req.error({
+        code: "TOO_MANY_REQUESTS",
+        status: 429,
+        message: `Too many concurrent requests (max ${this.maxConcurrent}), please try again later.`,
+      });
+    } else {
+      req.error({
+        code: "TOO_MANY_REQUESTS",
+        status: 429,
+        message: "Too many requests, please try again later.",
+      });
+    }
+  }
+
+  async addHeaders(req, count) {
+    const response = req.http.res;
+    if (response && !response.headersSent) {
+      response.setHeader("X-RateLimit-Limit", this.maxInWindow);
+      response.setHeader("X-RateLimit-Remaining", Math.max(this.maxInWindow - count.inWindow, 0));
+      response.setHeader("X-RateLimit-Reset", Math.ceil((await this.nextResetTime()).getTime() / 1000));
+      response.setHeader("Retry-After", Math.ceil(this.window / 1000));
+      response.setHeader("Date", new Date().toUTCString());
+    }
+  }
+}
+
+module.exports = RateLimiting;

package/src/rate-limiting/index.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = {
+  RateLimiting: require("./RateLimiting"),
+};

package/src/rate-limiting/redis/common.js

@@ -0,0 +1,33 @@
+"use strict";
+
+const cds = require("@sap/cds");
+
+const { RedisClient } = require("../../redis-client");
+
+const COMPONENT_NAME = "rateLimiting";
+
+async function connectionCheck() {
+  return await RedisClient.default(COMPONENT_NAME).connectionCheck();
+}
+
+async function perform(key, cb, cbFallback, retry = cds.env.rateLimiting.retry) {
+  const client = cds.env.rateLimiting.redis && (await RedisClient.default(COMPONENT_NAME).createMainClientAndConnect());
+  if (client) {
+    const value = await cb(client, key);
+    if (value === undefined) {
+      if (retry > 0) {
+        return await perform(key, cb, cbFallback, retry - 1);
+      } else {
+        cds.log(COMPONENT_NAME).error("Retry limit reached", { key });
+        throw new Error("Rate limiting retry limit reached");
+      }
+    }
+    return value;
+  }
+  return cbFallback(key);
+}
+
+module.exports = {
+  connectionCheck,
+  perform,
+};

package/src/rate-limiting/redis/counter.js

@@ -0,0 +1,63 @@
+"use strict";
+
+const { perform } = require("./common");
+
+module.exports = async ({ name = "default" }) => {
+  const counts = {};
+
+  async function increment(key) {
+    return await perform(
+      `${name}/${key}`,
+      async (client, key) => {
+        return await client.incr(key);
+      },
+      (key) => {
+        counts[key] ??= 0;
+        counts[key]++;
+        return counts[key];
+      },
+    );
+  }
+
+  async function decrement(key) {
+    return await perform(
+      `${name}/${key}`,
+      async (client, key) => {
+        return await client.decr(key);
+      },
+      (key) => {
+        counts[key] ??= 0;
+        counts[key]--;
+        return counts[key];
+      },
+    );
+  }
+
+  async function reset(key) {
+    return await perform(
+      `${name}/${key}`,
+      async (client, key) => {
+        const status = await client.set(key, 0);
+        if (status === "OK") {
+          return 0;
+        }
+      },
+      (key) => {
+        counts[key] = 0;
+        return counts[key];
+      },
+    );
+  }
+
+  return {
+    increment: async function (key) {
+      return await increment(key);
+    },
+    decrement: async function (key) {
+      return await decrement(key);
+    },
+    reset: async function (key) {
+      return await reset(key);
+    },
+  };
+};

package/src/rate-limiting/redis/resetTime.js

@@ -0,0 +1,44 @@
+"use strict";
+
+const { perform } = require("./common");
+
+module.exports = async ({ name = "default" }) => {
+  let resetTime;
+
+  async function set(date) {
+    return await perform(
+      name,
+      async (client, key) => {
+        const status = await client.set(key, date.toISOString());
+        if (status === "OK") {
+          return date;
+        }
+      },
+      () => {
+        resetTime = date;
+      },
+    );
+  }
+
+  async function get() {
+    return await perform(
+      name,
+      async (client, key) => {
+        const value = await client.get(key);
+        return value ? new Date(value) : null;
+      },
+      () => {
+        return resetTime;
+      },
+    );
+  }
+
+  return {
+    set: async function (date) {
+      return await set(date);
+    },
+    get: async function () {
+      return await get();
+    },
+  };
+};

package/src/redis-client/RedisClient.js

@@ -0,0 +1,238 @@
+"use strict";
+
+const redis = require("redis");
+
+const COMPONENT_NAME = "redisClient";
+const LOG_AFTER_SEC = 5;
+
+class RedisClient {
+  constructor(name) {
+    this.name = name;
+    this.log = cds.log(COMPONENT_NAME);
+    this.mainClientPromise = null;
+    this.additionalClientPromise = null;
+    this.subscriberClientPromise = null;
+    this.subscribedChannels = {};
+    this.lastErrorLog = Date.now();
+  }
+
+  createMainClientAndConnect(options) {
+    if (this.mainClientPromise) {
+      return this.mainClientPromise;
+    }
+
+    const errorHandlerCreateClient = (err) => {
+      this.mainClientPromise?.then?.(this.resilientClientClose);
+      this.log.error("Error from main redis client", err);
+      this.mainClientPromise = null;
+      setTimeout(() => this.createMainClientAndConnect(options), LOG_AFTER_SEC * 1000).unref();
+    };
+
+    this.mainClientPromise = this.createClientAndConnect(options, errorHandlerCreateClient);
+    return this.mainClientPromise;
+  }
+
+  createAdditionalClientAndConnect(options) {
+    if (this.additionalClientPromise) {
+      return this.additionalClientPromise;
+    }
+
+    const errorHandlerCreateClient = (err) => {
+      this.additionalClientPromise?.then?.(this.resilientClientClose);
+      this.log.error("Error from additional redis client", err);
+      this.additionalClientPromise = null;
+      setTimeout(() => this.createAdditionalClientAndConnect(options), LOG_AFTER_SEC * 1000).unref();
+    };
+
+    this.additionalClientPromise = this.createClientAndConnect(options, errorHandlerCreateClient);
+    return this.additionalClientPromise;
+  }
+
+  async createClientAndConnect(options, errorHandlerCreateClient, isConnectionCheck) {
+    try {
+      const client = this.createClientBase(options);
+      if (!client) {
+        return;
+      }
+      if (!isConnectionCheck) {
+        client.on("error", (err) => {
+          const dateNow = Date.now();
+          if (dateNow - this.lastErrorLog > LOG_AFTER_SEC * 1000) {
+            this.log.error("Error from redis client", err);
+            this.lastErrorLog = dateNow;
+          }
+        });
+
+        client.on("reconnecting", () => {
+          const dateNow = Date.now();
+          if (dateNow - this.lastErrorLog > LOG_AFTER_SEC * 1000) {
+            this.log.info("Redis client trying reconnect...");
+            this.lastErrorLog = dateNow;
+          }
+        });
+      }
+      await client.connect();
+      return client;
+    } catch (err) {
+      errorHandlerCreateClient(err);
+    }
+  }
+
+  async connectionCheck(options) {
+    let error;
+    try {
+      const client = await this.createClientAndConnect(
+        options,
+        (err) => {
+          error = err;
+        },
+        true,
+      );
+      if (error) {
+        throw error;
+      }
+      if (client) {
+        await this.resilientClientClose(client);
+        return true;
+      }
+    } catch (err) {
+      this.log.warn("Falling back to no redis mode. Redis connection could not be established: ", err.message);
+    }
+    return false;
+  }
+
+  createClientBase(redisOptions = {}) {
+    const { credentials, options } =
+      (this.name ? cds.requires[`redis-${this.name}`] : undefined) || cds.requires["redis"] || {};
+    const socket = {
+      host: credentials?.hostname ?? "127.0.0.1",
+      tls: !!credentials?.tls,
+      port: credentials?.port ?? 6379,
+      ...options?.socket,
+      ...redisOptions.socket,
+    };
+    const socketOptions = {
+      ...options,
+      ...redisOptions,
+      password: options?.password ?? options?.password ?? credentials?.password,
+      socket,
+    };
+    try {
+      if (credentials?.cluster_mode) {
+        return redis.createCluster({
+          rootNodes: [socketOptions],
+          defaults: socketOptions,
+        });
+      }
+      return redis.createClient(socketOptions);
+    } catch (err) {
+      throw new Error("Error during create client with redis-cache service" + err);
+    }
+  }
+
+  subscribeChannel(options, channel, subscribeHandler) {
+    this.subscribedChannels[channel] = subscribeHandler;
+    const errorHandlerCreateClient = (err) => {
+      this.log.error(`Error from redis client for for channel ${channel}`, err);
+      this.subscriberClientPromise?.then?.(this.resilientClientClose);
+      this.subscriberClientPromise = null;
+      setTimeout(
+        () => this.subscribeChannels(options, this.subscribedChannels, subscribeHandler),
+        LOG_AFTER_SEC * 1000,
+      ).unref();
+    };
+    this.subscribeChannels(options, { [channel]: subscribeHandler }, errorHandlerCreateClient);
+  }
+
+  subscribeChannels(options, subscribedChannels, errorHandlerCreateClient) {
+    this.subscriberClientPromise = this.createClientAndConnect(options, errorHandlerCreateClient)
+      .then((client) => {
+        for (const channel in this.subscribedChannels) {
+          const fn = subscribedChannels[channel];
+          client._subscribedChannels ??= {};
+          if (client._subscribedChannels[channel]) {
+            continue;
+          }
+          this.log.info("Subscribe redis client connected channel", { channel });
+          client
+            .subscribe(channel, fn)
+            .then(() => {
+              client._subscribedChannels ??= {};
+              client._subscribedChannels[channel] = 1;
+            })
+            .catch(() => {
+              this.log.error("Error subscribe to channel - retrying...");
+              setTimeout(() => this.subscribeChannels(options, [channel], fn), LOG_AFTER_SEC * 1000).unref();
+            });
+        }
+      })
+      .catch((err) => {
+        cds
+          .log(COMPONENT_NAME)
+          .error(
+            `Error from redis client during startup - trying to reconnect - ${Object.keys(this.subscribedChannels).join(
+              ", ",
+            )}`,
+            err,
+          );
+      });
+  }
+
+  async publishMessage(options, channel, message) {
+    const client = await this.createMainClientAndConnect(options);
+    return await client.publish(channel, message);
+  }
+
+  async closeMainClient() {
+    const client = this.mainClientPromise;
+    this.mainClientPromise = null;
+    await this.resilientClientClose(await client);
+    this.log.info("Main redis client closed!");
+  }
+
+  async closeAdditionalClient() {
+    const client = this.additionalClientPromise;
+    this.additionalClientPromise = null;
+    await this.resilientClientClose(await client);
+    this.log.info("Additional redis client closed!");
+  }
+
+  async closeSubscribeClient() {
+    const client = this.subscriberClientPromise;
+    this.subscriberClientPromise = null;
+    await this.resilientClientClose(await client);
+    this.log.info("Subscribe redis client closed!");
+  }
+
+  async closeClients() {
+    await this.closeMainClient();
+    await this.closeAdditionalClient();
+    await this.closeSubscribeClient();
+  }
+
+  async resilientClientClose(client) {
+    try {
+      if (client?.quit) {
+        await client.quit();
+      }
+    } catch (err) {
+      this.log.info("Error during redis close - continuing...", err);
+    }
+  }
+
+  static default(name = "default") {
+    RedisClient._default ??= {};
+    if (!RedisClient._default[name]) {
+      RedisClient._default[name] = new RedisClient(name);
+    }
+    return RedisClient._default[name];
+  }
+
+  static async closeAllClients() {
+    for (const entry of Object.values(RedisClient._default || {})) {
+      await entry.closeClients();
+    }
+  }
+}
+
+module.exports = RedisClient;

package/src/redis-client/index.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = {
+  RedisClient: require("./RedisClient"),
+};