layercache 1.0.1 → 1.1.0

package/dist/cli.cjs

@@ -0,0 +1,296 @@
+#!/usr/bin/env node
+"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);
+
+// src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(cli_exports);
+var import_ioredis = __toESM(require("ioredis"), 1);
+
+// src/invalidation/PatternMatcher.ts
+var PatternMatcher = class _PatternMatcher {
+  /**
+   * Tests whether a glob-style pattern matches a value.
+   * Supports `*` (any sequence of characters) and `?` (any single character).
+   * Uses a linear-time algorithm to avoid ReDoS vulnerabilities.
+   */
+  static matches(pattern, value) {
+    return _PatternMatcher.matchLinear(pattern, value);
+  }
+  /**
+   * Linear-time glob matching using dynamic programming.
+   * Avoids catastrophic backtracking that RegExp-based glob matching can cause.
+   */
+  static matchLinear(pattern, value) {
+    const m = pattern.length;
+    const n = value.length;
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(false));
+    dp[0][0] = true;
+    for (let i = 1; i <= m; i++) {
+      if (pattern[i - 1] === "*") {
+        dp[i][0] = dp[i - 1]?.[0];
+      }
+    }
+    for (let i = 1; i <= m; i++) {
+      for (let j = 1; j <= n; j++) {
+        const pc = pattern[i - 1];
+        if (pc === "*") {
+          dp[i][j] = dp[i - 1]?.[j] || dp[i]?.[j - 1];
+        } else if (pc === "?" || pc === value[j - 1]) {
+          dp[i][j] = dp[i - 1]?.[j - 1];
+        }
+      }
+    }
+    return dp[m]?.[n];
+  }
+};
+
+// src/invalidation/RedisTagIndex.ts
+var RedisTagIndex = class {
+  client;
+  prefix;
+  scanCount;
+  constructor(options) {
+    this.client = options.client;
+    this.prefix = options.prefix ?? "layercache:tag-index";
+    this.scanCount = options.scanCount ?? 100;
+  }
+  async touch(key) {
+    await this.client.sadd(this.knownKeysKey(), key);
+  }
+  async track(key, tags) {
+    const keyTagsKey = this.keyTagsKey(key);
+    const existingTags = await this.client.smembers(keyTagsKey);
+    const pipeline = this.client.pipeline();
+    pipeline.sadd(this.knownKeysKey(), key);
+    for (const tag of existingTags) {
+      pipeline.srem(this.tagKeysKey(tag), key);
+    }
+    pipeline.del(keyTagsKey);
+    if (tags.length > 0) {
+      pipeline.sadd(keyTagsKey, ...tags);
+      for (const tag of new Set(tags)) {
+        pipeline.sadd(this.tagKeysKey(tag), key);
+      }
+    }
+    await pipeline.exec();
+  }
+  async remove(key) {
+    const keyTagsKey = this.keyTagsKey(key);
+    const existingTags = await this.client.smembers(keyTagsKey);
+    const pipeline = this.client.pipeline();
+    pipeline.srem(this.knownKeysKey(), key);
+    pipeline.del(keyTagsKey);
+    for (const tag of existingTags) {
+      pipeline.srem(this.tagKeysKey(tag), key);
+    }
+    await pipeline.exec();
+  }
+  async keysForTag(tag) {
+    return this.client.smembers(this.tagKeysKey(tag));
+  }
+  async matchPattern(pattern) {
+    const matches = [];
+    let cursor = "0";
+    do {
+      const [nextCursor, keys] = await this.client.sscan(
+        this.knownKeysKey(),
+        cursor,
+        "MATCH",
+        pattern,
+        "COUNT",
+        this.scanCount
+      );
+      cursor = nextCursor;
+      matches.push(...keys.filter((key) => PatternMatcher.matches(pattern, key)));
+    } while (cursor !== "0");
+    return matches;
+  }
+  async clear() {
+    const indexKeys = await this.scanIndexKeys();
+    if (indexKeys.length === 0) {
+      return;
+    }
+    await this.client.del(...indexKeys);
+  }
+  async scanIndexKeys() {
+    const matches = [];
+    let cursor = "0";
+    const pattern = `${this.prefix}:*`;
+    do {
+      const [nextCursor, keys] = await this.client.scan(cursor, "MATCH", pattern, "COUNT", this.scanCount);
+      cursor = nextCursor;
+      matches.push(...keys);
+    } while (cursor !== "0");
+    return matches;
+  }
+  knownKeysKey() {
+    return `${this.prefix}:keys`;
+  }
+  keyTagsKey(key) {
+    return `${this.prefix}:key:${encodeURIComponent(key)}`;
+  }
+  tagKeysKey(tag) {
+    return `${this.prefix}:tag:${encodeURIComponent(tag)}`;
+  }
+};
+
+// src/cli.ts
+var CONNECT_TIMEOUT_MS = 5e3;
+async function main(argv = process.argv.slice(2)) {
+  const args = parseArgs(argv);
+  if (!args.command || !args.redisUrl) {
+    printUsage();
+    process.exitCode = 1;
+    return;
+  }
+  const redisUrl = validateRedisUrl(args.redisUrl);
+  if (!redisUrl) {
+    process.stderr.write(
+      `Error: invalid Redis URL "${args.redisUrl}". Expected format: redis://[user:password@]host[:port][/db]
+`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const redis = new import_ioredis.default(redisUrl, {
+    connectTimeout: CONNECT_TIMEOUT_MS,
+    lazyConnect: true,
+    enableReadyCheck: false
+  });
+  try {
+    await redis.connect().catch((error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to connect to Redis at "${redisUrl}": ${message}`);
+    });
+    if (args.command === "stats") {
+      const keys = await scanKeys(redis, args.pattern ?? "*");
+      process.stdout.write(`${JSON.stringify({ totalKeys: keys.length, pattern: args.pattern ?? "*" }, null, 2)}
+`);
+      return;
+    }
+    if (args.command === "keys") {
+      const keys = await scanKeys(redis, args.pattern ?? "*");
+      if (keys.length > 0) {
+        process.stdout.write(`${keys.join("\n")}
+`);
+      }
+      return;
+    }
+    if (args.command === "invalidate") {
+      if (args.tag) {
+        const tagIndex = new RedisTagIndex({ client: redis, prefix: args.tagIndexPrefix ?? "layercache:tag-index" });
+        const keys2 = await tagIndex.keysForTag(args.tag);
+        if (keys2.length > 0) {
+          await redis.del(...keys2);
+        }
+        process.stdout.write(`${JSON.stringify({ deletedKeys: keys2.length, tag: args.tag }, null, 2)}
+`);
+        return;
+      }
+      const keys = await scanKeys(redis, args.pattern ?? "*");
+      if (keys.length > 0) {
+        await redis.del(...keys);
+      }
+      process.stdout.write(`${JSON.stringify({ deletedKeys: keys.length, pattern: args.pattern ?? "*" }, null, 2)}
+`);
+      return;
+    }
+    printUsage();
+    process.exitCode = 1;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`Error: ${message}
+`);
+    process.exitCode = 1;
+  } finally {
+    redis.disconnect();
+  }
+}
+function validateRedisUrl(url) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "redis:" && parsed.protocol !== "rediss:") {
+      return null;
+    }
+    return url;
+  } catch {
+    if (/^[A-Za-z0-9._-]+(:\d+)?$/.test(url)) {
+      return url;
+    }
+    return null;
+  }
+}
+function parseArgs(argv) {
+  const [command, ...rest] = argv;
+  const parsed = { command };
+  for (let index = 0; index < rest.length; index += 1) {
+    const token = rest[index];
+    const value = rest[index + 1];
+    if (token === "--redis") {
+      parsed.redisUrl = value;
+      index += 1;
+    } else if (token === "--pattern") {
+      parsed.pattern = value;
+      index += 1;
+    } else if (token === "--tag") {
+      parsed.tag = value;
+      index += 1;
+    } else if (token === "--tag-index-prefix") {
+      parsed.tagIndexPrefix = value;
+      index += 1;
+    }
+  }
+  return parsed;
+}
+async function scanKeys(redis, pattern) {
+  const keys = [];
+  let cursor = "0";
+  do {
+    const [nextCursor, batch] = await redis.scan(cursor, "MATCH", pattern, "COUNT", 100);
+    cursor = nextCursor;
+    keys.push(...batch);
+  } while (cursor !== "0");
+  return keys;
+}
+function printUsage() {
+  process.stdout.write(
+    "Usage:\n  layercache stats --redis <url> [--pattern <glob>]\n  layercache keys --redis <url> [--pattern <glob>]\n  layercache invalidate --redis <url> [--pattern <glob> | --tag <tag>] [--tag-index-prefix <prefix>]\n\nOptions:\n  --redis <url>               Redis connection URL (e.g. redis://localhost:6379)\n  --pattern <glob>            Glob pattern to filter keys (default: *)\n  --tag <tag>                 Invalidate by tag name\n  --tag-index-prefix <prefix> Redis key prefix for tag index (default: layercache:tag-index)\n"
+  );
+}
+if (process.argv[1]?.includes("cli.")) {
+  void main();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main
+});

package/dist/cli.d.cts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+declare function main(argv?: string[]): Promise<void>;
+
+export { main };

package/dist/cli.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+declare function main(argv?: string[]): Promise<void>;
+
+export { main };

package/dist/cli.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+import {
+  RedisTagIndex
+} from "./chunk-QUB5VZFZ.js";
+
+// src/cli.ts
+import Redis from "ioredis";
+var CONNECT_TIMEOUT_MS = 5e3;
+async function main(argv = process.argv.slice(2)) {
+  const args = parseArgs(argv);
+  if (!args.command || !args.redisUrl) {
+    printUsage();
+    process.exitCode = 1;
+    return;
+  }
+  const redisUrl = validateRedisUrl(args.redisUrl);
+  if (!redisUrl) {
+    process.stderr.write(
+      `Error: invalid Redis URL "${args.redisUrl}". Expected format: redis://[user:password@]host[:port][/db]
+`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const redis = new Redis(redisUrl, {
+    connectTimeout: CONNECT_TIMEOUT_MS,
+    lazyConnect: true,
+    enableReadyCheck: false
+  });
+  try {
+    await redis.connect().catch((error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to connect to Redis at "${redisUrl}": ${message}`);
+    });
+    if (args.command === "stats") {
+      const keys = await scanKeys(redis, args.pattern ?? "*");
+      process.stdout.write(`${JSON.stringify({ totalKeys: keys.length, pattern: args.pattern ?? "*" }, null, 2)}
+`);
+      return;
+    }
+    if (args.command === "keys") {
+      const keys = await scanKeys(redis, args.pattern ?? "*");
+      if (keys.length > 0) {
+        process.stdout.write(`${keys.join("\n")}
+`);
+      }
+      return;
+    }
+    if (args.command === "invalidate") {
+      if (args.tag) {
+        const tagIndex = new RedisTagIndex({ client: redis, prefix: args.tagIndexPrefix ?? "layercache:tag-index" });
+        const keys2 = await tagIndex.keysForTag(args.tag);
+        if (keys2.length > 0) {
+          await redis.del(...keys2);
+        }
+        process.stdout.write(`${JSON.stringify({ deletedKeys: keys2.length, tag: args.tag }, null, 2)}
+`);
+        return;
+      }
+      const keys = await scanKeys(redis, args.pattern ?? "*");
+      if (keys.length > 0) {
+        await redis.del(...keys);
+      }
+      process.stdout.write(`${JSON.stringify({ deletedKeys: keys.length, pattern: args.pattern ?? "*" }, null, 2)}
+`);
+      return;
+    }
+    printUsage();
+    process.exitCode = 1;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`Error: ${message}
+`);
+    process.exitCode = 1;
+  } finally {
+    redis.disconnect();
+  }
+}
+function validateRedisUrl(url) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "redis:" && parsed.protocol !== "rediss:") {
+      return null;
+    }
+    return url;
+  } catch {
+    if (/^[A-Za-z0-9._-]+(:\d+)?$/.test(url)) {
+      return url;
+    }
+    return null;
+  }
+}
+function parseArgs(argv) {
+  const [command, ...rest] = argv;
+  const parsed = { command };
+  for (let index = 0; index < rest.length; index += 1) {
+    const token = rest[index];
+    const value = rest[index + 1];
+    if (token === "--redis") {
+      parsed.redisUrl = value;
+      index += 1;
+    } else if (token === "--pattern") {
+      parsed.pattern = value;
+      index += 1;
+    } else if (token === "--tag") {
+      parsed.tag = value;
+      index += 1;
+    } else if (token === "--tag-index-prefix") {
+      parsed.tagIndexPrefix = value;
+      index += 1;
+    }
+  }
+  return parsed;
+}
+async function scanKeys(redis, pattern) {
+  const keys = [];
+  let cursor = "0";
+  do {
+    const [nextCursor, batch] = await redis.scan(cursor, "MATCH", pattern, "COUNT", 100);
+    cursor = nextCursor;
+    keys.push(...batch);
+  } while (cursor !== "0");
+  return keys;
+}
+function printUsage() {
+  process.stdout.write(
+    "Usage:\n  layercache stats --redis <url> [--pattern <glob>]\n  layercache keys --redis <url> [--pattern <glob>]\n  layercache invalidate --redis <url> [--pattern <glob> | --tag <tag>] [--tag-index-prefix <prefix>]\n\nOptions:\n  --redis <url>               Redis connection URL (e.g. redis://localhost:6379)\n  --pattern <glob>            Glob pattern to filter keys (default: *)\n  --tag <tag>                 Invalidate by tag name\n  --tag-index-prefix <prefix> Redis key prefix for tag index (default: layercache:tag-index)\n"
+  );
+}
+if (process.argv[1]?.includes("cli.")) {
+  void main();
+}
+export {
+  main
+};