@guren/server 1.0.0-rc.25 → 1.0.0-rc.26

package/dist/redis/index.js

@@ -0,0 +1,597 @@
+import {
+  Redis,
+  createRedisClient
+} from "../chunk-UY3AZSYL.js";
+
+// src/redis/scan-keys.ts
+async function scanKeys(redis, pattern) {
+  const keys = [];
+  let cursor = "0";
+  do {
+    const [newCursor, foundKeys] = await redis.scan(cursor, "MATCH", pattern, "COUNT", 100);
+    cursor = newCursor;
+    keys.push(...foundKeys);
+  } while (cursor !== "0");
+  return keys;
+}
+
+// src/redis/RedisSessionStore.ts
+var RedisSessionStore = class {
+  constructor(redis, options = {}) {
+    this.redis = redis;
+    this.prefix = options.prefix ?? "session:";
+  }
+  prefix;
+  /**
+   * Read session data from Redis.
+   */
+  async read(id) {
+    const key = this.prefix + id;
+    const data = await this.redis.get(key);
+    if (!data) {
+      return void 0;
+    }
+    try {
+      return JSON.parse(data);
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Write session data to Redis with TTL.
+   */
+  async write(id, data, ttlSeconds) {
+    const key = this.prefix + id;
+    const serialized = JSON.stringify(data);
+    await this.redis.setex(key, ttlSeconds, serialized);
+  }
+  /**
+   * Delete a session from Redis.
+   */
+  async destroy(id) {
+    const key = this.prefix + id;
+    await this.redis.del(key);
+  }
+  /**
+   * Get all session keys (for debugging/admin purposes).
+   * Note: This uses SCAN to avoid blocking Redis.
+   */
+  async keys() {
+    const keys = await scanKeys(this.redis, this.prefix + "*");
+    return keys.map((key) => key.slice(this.prefix.length));
+  }
+  /**
+   * Get the count of sessions (for monitoring).
+   */
+  async size() {
+    const keys = await this.keys();
+    return keys.length;
+  }
+  /**
+   * Clear all sessions.
+   * Use with caution in production!
+   */
+  async clear() {
+    const keys = await this.keys();
+    if (keys.length > 0) {
+      const prefixedKeys = keys.map((key) => this.prefix + key);
+      await this.redis.del(...prefixedKeys);
+    }
+  }
+};
+
+// src/redis/RedisRateLimitStore.ts
+var INCREMENT_SCRIPT = `
+local key = KEYS[1]
+local window = tonumber(ARGV[1])
+local now = tonumber(ARGV[2])
+
+local count = redis.call('INCR', key)
+if count == 1 then
+  redis.call('PEXPIRE', key, window)
+end
+local ttl = redis.call('PTTL', key)
+local resetAt = now + ttl
+return {count, resetAt}
+`;
+var RedisRateLimitStore = class {
+  constructor(redis, options = {}) {
+    this.redis = redis;
+    this.prefix = options.prefix ?? "ratelimit:";
+  }
+  prefix;
+  /**
+   * Get current rate limit entry for a key.
+   */
+  async get(key) {
+    const redisKey = this.prefix + key;
+    const [countStr, ttl] = await Promise.all([
+      this.redis.get(redisKey),
+      this.redis.pttl(redisKey)
+    ]);
+    if (!countStr || ttl <= 0) {
+      return null;
+    }
+    return {
+      count: parseInt(countStr, 10),
+      resetAt: Date.now() + ttl
+    };
+  }
+  /**
+   * Increment the rate limit counter atomically.
+   */
+  async increment(key, windowMs) {
+    const redisKey = this.prefix + key;
+    const now = Date.now();
+    const result = await this.redis.eval(
+      INCREMENT_SCRIPT,
+      1,
+      redisKey,
+      windowMs.toString(),
+      now.toString()
+    );
+    return {
+      count: result[0],
+      resetAt: result[1]
+    };
+  }
+  /**
+   * Reset the rate limit for a key.
+   */
+  async reset(key) {
+    const redisKey = this.prefix + key;
+    await this.redis.del(redisKey);
+  }
+  /**
+   * Get all rate limit keys (for debugging/admin purposes).
+   */
+  async keys() {
+    const keys = await scanKeys(this.redis, this.prefix + "*");
+    return keys.map((key) => key.slice(this.prefix.length));
+  }
+  /**
+   * Clear all rate limits.
+   */
+  async clear() {
+    const keys = await this.keys();
+    if (keys.length > 0) {
+      const prefixedKeys = keys.map((key) => this.prefix + key);
+      await this.redis.del(...prefixedKeys);
+    }
+  }
+};
+var RedisSlidingWindowRateLimitStore = class {
+  constructor(redis, options = {}) {
+    this.redis = redis;
+    this.prefix = options.prefix ?? "ratelimit:sw:";
+  }
+  prefix;
+  /**
+   * Get current rate limit entry for a key.
+   */
+  async get(key) {
+    const redisKey = this.prefix + key;
+    const count = await this.redis.zcard(redisKey);
+    if (count === 0) {
+      return null;
+    }
+    const ttl = await this.redis.pttl(redisKey);
+    return {
+      count,
+      resetAt: ttl > 0 ? Date.now() + ttl : Date.now()
+    };
+  }
+  /**
+   * Increment the rate limit counter using sorted set.
+   * Each request is stored with its timestamp as score.
+   */
+  async increment(key, windowMs) {
+    const redisKey = this.prefix + key;
+    const now = Date.now();
+    const windowStart = now - windowMs;
+    const pipeline = this.redis.pipeline();
+    pipeline.zremrangebyscore(redisKey, "-inf", windowStart);
+    pipeline.zadd(redisKey, now, `${now}:${Math.random()}`);
+    pipeline.zcard(redisKey);
+    pipeline.pexpire(redisKey, windowMs);
+    const results = await pipeline.exec();
+    const count = results?.[2]?.[1] ?? 1;
+    return {
+      count,
+      resetAt: now + windowMs
+    };
+  }
+  /**
+   * Reset the rate limit for a key.
+   */
+  async reset(key) {
+    const redisKey = this.prefix + key;
+    await this.redis.del(redisKey);
+  }
+  /**
+   * Clear all rate limits.
+   */
+  async clear() {
+    const keys = await scanKeys(this.redis, this.prefix + "*");
+    if (keys.length > 0) {
+      await this.redis.del(...keys);
+    }
+  }
+};
+
+// src/redis/RedisApiTokenStore.ts
+var RedisApiTokenStore = class {
+  constructor(redis, options = {}) {
+    this.redis = redis;
+    this.prefix = options.prefix ?? "apitoken:";
+  }
+  prefix;
+  /**
+   * Store a new API token.
+   */
+  async store(token) {
+    const tokenKey = `${this.prefix}${token.id}`;
+    const hashKey = `${this.prefix}hash:${token.hashedToken}`;
+    const userKey = `${this.prefix}user:${token.userId}`;
+    const serialized = this.serializeToken(token);
+    const pipeline = this.redis.pipeline();
+    pipeline.hset(tokenKey, serialized);
+    pipeline.set(hashKey, token.id);
+    pipeline.sadd(userKey, token.id);
+    if (token.expiresAt) {
+      const ttl = Math.max(0, token.expiresAt.getTime() - Date.now());
+      if (ttl > 0) {
+        pipeline.pexpire(tokenKey, ttl);
+        pipeline.pexpire(hashKey, ttl);
+      }
+    }
+    await pipeline.exec();
+  }
+  /**
+   * Find a token by its hashed value.
+   */
+  async findByHashedToken(hashedToken) {
+    const hashKey = `${this.prefix}hash:${hashedToken}`;
+    const tokenId = await this.redis.get(hashKey);
+    if (!tokenId) {
+      return null;
+    }
+    return this.findById(tokenId);
+  }
+  /**
+   * Find all tokens for a user.
+   */
+  async findByUserId(userId) {
+    const userKey = `${this.prefix}user:${userId}`;
+    const tokenIds = await this.redis.smembers(userKey);
+    const tokens = [];
+    for (const id of tokenIds) {
+      const token = await this.findById(id);
+      if (token) {
+        tokens.push(token);
+      }
+    }
+    return tokens;
+  }
+  /**
+   * Delete a token by its ID.
+   */
+  async delete(id) {
+    const token = await this.findById(id);
+    if (!token) return;
+    const tokenKey = `${this.prefix}${id}`;
+    const hashKey = `${this.prefix}hash:${token.hashedToken}`;
+    const userKey = `${this.prefix}user:${token.userId}`;
+    const pipeline = this.redis.pipeline();
+    pipeline.del(tokenKey);
+    pipeline.del(hashKey);
+    pipeline.srem(userKey, id);
+    await pipeline.exec();
+  }
+  /**
+   * Delete all tokens for a user.
+   */
+  async deleteForUser(userId) {
+    const tokens = await this.findByUserId(userId);
+    for (const token of tokens) {
+      await this.delete(token.id);
+    }
+    const userKey = `${this.prefix}user:${userId}`;
+    await this.redis.del(userKey);
+  }
+  /**
+   * Update the last used timestamp.
+   */
+  async updateLastUsed(id, timestamp) {
+    const tokenKey = `${this.prefix}${id}`;
+    await this.redis.hset(tokenKey, "lastUsedAt", timestamp.toISOString());
+  }
+  /**
+   * Find a token by its ID.
+   */
+  async findById(id) {
+    const tokenKey = `${this.prefix}${id}`;
+    const data = await this.redis.hgetall(tokenKey);
+    if (!data || Object.keys(data).length === 0) {
+      return null;
+    }
+    return this.deserializeToken(data);
+  }
+  /**
+   * Serialize a token for Redis storage.
+   */
+  serializeToken(token) {
+    return {
+      id: token.id,
+      name: token.name,
+      hashedToken: token.hashedToken,
+      userId: String(token.userId),
+      abilities: JSON.stringify(token.abilities),
+      lastUsedAt: token.lastUsedAt?.toISOString() ?? "",
+      expiresAt: token.expiresAt?.toISOString() ?? "",
+      createdAt: token.createdAt.toISOString()
+    };
+  }
+  /**
+   * Deserialize a token from Redis storage.
+   */
+  deserializeToken(data) {
+    return {
+      id: data.id,
+      name: data.name,
+      hashedToken: data.hashedToken,
+      userId: data.userId,
+      abilities: JSON.parse(data.abilities),
+      lastUsedAt: data.lastUsedAt ? new Date(data.lastUsedAt) : null,
+      expiresAt: data.expiresAt ? new Date(data.expiresAt) : null,
+      createdAt: new Date(data.createdAt)
+    };
+  }
+  /**
+   * Clear all tokens (for testing).
+   */
+  async clear() {
+    const keys = await scanKeys(this.redis, this.prefix + "*");
+    if (keys.length > 0) {
+      await this.redis.del(...keys);
+    }
+  }
+};
+
+// src/redis/RedisPasswordResetStore.ts
+var RedisPasswordResetStore = class {
+  constructor(redis, options = {}) {
+    this.redis = redis;
+    this.prefix = options.prefix ?? "pwreset:";
+  }
+  prefix;
+  /**
+   * Store a password reset token.
+   */
+  async store(tokenId, email, expiresAt) {
+    const tokenKey = `${this.prefix}${tokenId}`;
+    const emailKey = `${this.prefix}email:${email.toLowerCase()}`;
+    const ttlMs = Math.max(0, expiresAt.getTime() - Date.now());
+    if (ttlMs <= 0) {
+      return;
+    }
+    const data = JSON.stringify({ email, expiresAt: expiresAt.toISOString() });
+    const pipeline = this.redis.pipeline();
+    pipeline.psetex(tokenKey, ttlMs, data);
+    pipeline.sadd(emailKey, tokenId);
+    pipeline.pexpire(emailKey, ttlMs + 6e4);
+    await pipeline.exec();
+  }
+  /**
+   * Find a token by its hash.
+   */
+  async find(tokenId) {
+    const tokenKey = `${this.prefix}${tokenId}`;
+    const data = await this.redis.get(tokenKey);
+    if (!data) {
+      return null;
+    }
+    try {
+      const parsed = JSON.parse(data);
+      return {
+        email: parsed.email,
+        expiresAt: new Date(parsed.expiresAt)
+      };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Delete a token by its hash.
+   */
+  async delete(tokenId) {
+    const tokenKey = `${this.prefix}${tokenId}`;
+    const data = await this.redis.get(tokenKey);
+    if (data) {
+      try {
+        const parsed = JSON.parse(data);
+        const emailKey = `${this.prefix}email:${parsed.email.toLowerCase()}`;
+        await this.redis.srem(emailKey, tokenId);
+      } catch {
+      }
+    }
+    await this.redis.del(tokenKey);
+  }
+  /**
+   * Delete all tokens for an email.
+   */
+  async deleteForEmail(email) {
+    const emailKey = `${this.prefix}email:${email.toLowerCase()}`;
+    const tokenIds = await this.redis.smembers(emailKey);
+    if (tokenIds.length > 0) {
+      const tokenKeys = tokenIds.map((tokenId) => `${this.prefix}${tokenId}`);
+      await this.redis.del(...tokenKeys, emailKey);
+    } else {
+      await this.redis.del(emailKey);
+    }
+  }
+  /**
+   * Clear all tokens (for testing).
+   */
+  async clear() {
+    const keys = await scanKeys(this.redis, this.prefix + "*");
+    if (keys.length > 0) {
+      await this.redis.del(...keys);
+    }
+  }
+};
+
+// src/redis/RedisEmailVerificationStore.ts
+var RedisEmailVerificationStore = class {
+  constructor(redis, options = {}) {
+    this.redis = redis;
+    this.prefix = options.prefix ?? "emailverify:";
+  }
+  prefix;
+  /**
+   * Store an email verification token.
+   */
+  async store(token) {
+    const tokenKey = `${this.prefix}${token.tokenId}`;
+    const emailKey = `${this.prefix}email:${token.email.toLowerCase()}`;
+    const ttlMs = Math.max(0, token.expiresAt.getTime() - Date.now());
+    if (ttlMs <= 0) {
+      return;
+    }
+    const data = JSON.stringify({
+      tokenId: token.tokenId,
+      email: token.email,
+      expiresAt: token.expiresAt.toISOString(),
+      createdAt: token.createdAt.toISOString()
+    });
+    const pipeline = this.redis.pipeline();
+    pipeline.psetex(tokenKey, ttlMs, data);
+    pipeline.sadd(emailKey, token.tokenId);
+    pipeline.pexpire(emailKey, ttlMs + 6e4);
+    await pipeline.exec();
+  }
+  /**
+   * Find a token by its hash.
+   */
+  async findByTokenId(tokenId) {
+    const tokenKey = `${this.prefix}${tokenId}`;
+    const data = await this.redis.get(tokenKey);
+    if (!data) {
+      return null;
+    }
+    try {
+      const parsed = JSON.parse(data);
+      return {
+        tokenId: parsed.tokenId,
+        email: parsed.email,
+        expiresAt: new Date(parsed.expiresAt),
+        createdAt: new Date(parsed.createdAt)
+      };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Delete a token by its hash.
+   */
+  async delete(tokenId) {
+    const tokenKey = `${this.prefix}${tokenId}`;
+    const data = await this.redis.get(tokenKey);
+    if (data) {
+      try {
+        const parsed = JSON.parse(data);
+        const emailKey = `${this.prefix}email:${parsed.email.toLowerCase()}`;
+        await this.redis.srem(emailKey, tokenId);
+      } catch {
+      }
+    }
+    await this.redis.del(tokenKey);
+  }
+  /**
+   * Delete all tokens for an email.
+   */
+  async deleteForEmail(email) {
+    const emailKey = `${this.prefix}email:${email.toLowerCase()}`;
+    const tokenIds = await this.redis.smembers(emailKey);
+    if (tokenIds.length > 0) {
+      const tokenKeys = tokenIds.map((tokenId) => `${this.prefix}${tokenId}`);
+      await this.redis.del(...tokenKeys, emailKey);
+    } else {
+      await this.redis.del(emailKey);
+    }
+  }
+  /**
+   * Clear all tokens (for testing).
+   */
+  async clear() {
+    const keys = await scanKeys(this.redis, this.prefix + "*");
+    if (keys.length > 0) {
+      await this.redis.del(...keys);
+    }
+  }
+};
+
+// src/redis/RedisOAuthStateStore.ts
+var RedisOAuthStateStore = class {
+  constructor(redis, options = {}) {
+    this.redis = redis;
+    this.prefix = options.prefix ?? "oauthstate:";
+  }
+  prefix;
+  async store(stateHash, payload) {
+    const ttlMs = Math.max(0, payload.expiresAt.getTime() - Date.now());
+    if (ttlMs <= 0) {
+      return;
+    }
+    const data = JSON.stringify({
+      provider: payload.provider,
+      redirectTo: payload.redirectTo,
+      expiresAt: payload.expiresAt.toISOString()
+    });
+    await this.redis.psetex(`${this.prefix}${stateHash}`, ttlMs, data);
+  }
+  async find(stateHash) {
+    const data = await this.redis.get(`${this.prefix}${stateHash}`);
+    if (!data) {
+      return null;
+    }
+    try {
+      const parsed = JSON.parse(data);
+      const payload = {
+        provider: parsed.provider,
+        redirectTo: parsed.redirectTo,
+        expiresAt: new Date(parsed.expiresAt)
+      };
+      if (payload.expiresAt.getTime() <= Date.now()) {
+        await this.delete(stateHash);
+        return null;
+      }
+      return payload;
+    } catch {
+      return null;
+    }
+  }
+  async delete(stateHash) {
+    await this.redis.del(`${this.prefix}${stateHash}`);
+  }
+  /**
+   * Clear all states (for testing).
+   */
+  async clear() {
+    const keys = await scanKeys(this.redis, this.prefix + "*");
+    if (keys.length > 0) {
+      await this.redis.del(...keys);
+    }
+  }
+};
+export {
+  Redis,
+  RedisApiTokenStore,
+  RedisEmailVerificationStore,
+  RedisOAuthStateStore,
+  RedisPasswordResetStore,
+  RedisRateLimitStore,
+  RedisSessionStore,
+  RedisSlidingWindowRateLimitStore,
+  createRedisClient
+};

package/dist/runtime/index.d.ts

@@ -1,7 +1,8 @@
-import { A as Application } from '../Application-Hlryz3ln.js';
-export { D as DevBannerOptions, G as GUREN_ASCII_ART, a as StartViteDevServerOptions, b as StartedViteDevServer, l as logDevServerBanner, s as startViteDevServer } from '../Application-Hlryz3ln.js';
+import { A as Application } from '../Application-BnsyCKXY.js';
+export { D as DevBannerOptions, G as GUREN_ASCII_ART, a as StartViteDevServerOptions, b as StartedViteDevServer, l as logDevServerBanner, s as startViteDevServer } from '../Application-BnsyCKXY.js';
 import 'hono';
-import '../api-token-ChekhpB7.js';
+import '../api-token-BSSCLlFW.js';
+import '../AuthManager-SfhCNkAU.js';
 import '@guren/orm';
 import 'vite';
 import '../EventManager-CmIoLt7r.js';

package/dist/runtime/index.js

@@ -3,7 +3,7 @@ import {
   logDevServerBanner,
   parseImportMap,
   startViteDevServer
-} from "../chunk-X4E2I4Z5.js";
+} from "../chunk-NRLZJILN.js";
 import {
   hash
 } from "../chunk-QQKTH5KX.js";
@@ -110,7 +110,9 @@ var DEFAULT_PREFIX = "/resources/js";
 var DEFAULT_VENDOR_PATH = "/vendor/inertia-client.tsx";
 var DEFAULT_JSX_RUNTIME = "https://esm.sh/react@19.0.0/jsx-dev-runtime?dev";
 var require2 = createRequire(import.meta.url);
-var gurenInertiaClient = require2.resolve("@guren/inertia-client/app");
+function resolveGurenInertiaClient() {
+  return require2.resolve("@guren/inertia-client/app");
+}
 function registerDevAssets(app, options) {
   if (typeof Bun === "undefined") {
     throw new Error("Bun runtime is required for dev asset serving.");
@@ -124,7 +126,7 @@ function registerDevAssets(app, options) {
   const cssDir = options.cssDir ?? resolve2(resourcesDir, "css");
   const cssRoute = options.cssRoute ?? deriveCssRoute(prefix);
   const inertiaClientPath = options.inertiaClientPath ?? DEFAULT_VENDOR_PATH;
-  const inertiaClientSource = options.inertiaClientSource ?? gurenInertiaClient;
+  const inertiaClientSource = options.inertiaClientSource ?? resolveGurenInertiaClient();
   const jsxRuntimeUrl = options.jsxRuntimeUrl ?? DEFAULT_JSX_RUNTIME;
   const resourcesJsDir = resolve2(resourcesDir, "js");
   const reactImportPattern = /from\s+['"]react['"]/u;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guren/server",
-  "version": "1.0.0-rc.25",
+  "version": "1.0.0-rc.26",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -96,6 +96,10 @@
     "./lambda": {
       "types": "./dist/lambda/index.d.ts",
       "default": "./dist/lambda/index.js"
+    },
+    "./redis": {
+      "types": "./dist/redis/index.d.ts",
+      "default": "./dist/redis/index.js"
     }
   },
   "scripts": {
@@ -105,21 +109,21 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@guren/inertia-client": "^1.0.0-rc.24",
-    "@guren/orm": "^1.0.0-rc.26",
+    "@guren/orm": "^1.0.0-rc.27",
     "@modelcontextprotocol/sdk": "^1.27.1",
     "chalk": "^5.3.0",
     "consola": "^3.4.2",
     "figlet": "^1.7.0",
     "hono": "^4.12.18",
     "ioredis": "^5.9.1",
-    "nodemailer": "^8.0.4"
+    "nodemailer": "^9.0.1"
   },
   "peerDependencies": {
     "@aws-sdk/client-s3": "^3.0.0",
     "@aws-sdk/client-sqs": "^3.0.0",
     "@aws-sdk/s3-request-presigner": "^3.0.0",
-    "vite": ">=7.0.0"
+    "vite": ">=7.0.0",
+    "@guren/inertia-client": "^1.0.0-rc.25"
   },
   "peerDependenciesMeta": {
     "@aws-sdk/client-s3": {
@@ -130,6 +134,9 @@
     },
     "@aws-sdk/s3-request-presigner": {
       "optional": true
+    },
+    "@guren/inertia-client": {
+      "optional": true
     }
   },
   "devDependencies": {