Add storage and cache implementations

FileTokenStorage (JSON file), MemoryTokenStorage (ConcurrentHashMap),
FileCache (file-per-key with TTL), MemoryCache (ConcurrentHashMap with TTL).

Co-Authored-By: claude-flow <ruv@ruv.net>

Author: Allow2 Dev

src/main/java/com/allow2/service/cache/FileCache.java

@@ -0,0 +1,96 @@
+package com.allow2.service.cache;
+
+import com.allow2.service.CacheInterface;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+/**
+ * File-based permission cache.
+ *
+ * <p>Each cache entry is stored as a separate JSON file in the cache directory.
+ * Suitable for single-server deployments.</p>
+ */
+public final class FileCache implements CacheInterface {
+
+    private final Path cacheDir;
+
+    /**
+     * @param cacheDir Directory for cache files. Created automatically if missing.
+     */
+    public FileCache(String cacheDir) {
+        this.cacheDir = Paths.get(cacheDir);
+        try {
+            if (!Files.exists(this.cacheDir)) {
+                Files.createDirectories(this.cacheDir);
+            }
+        } catch (IOException e) {
+            throw new RuntimeException("Failed to create cache directory: " + cacheDir, e);
+        }
+    }
+
+    @Override
+    public String get(String key) {
+        Path path = keyToPath(key);
+
+        if (!Files.exists(path)) {
+            return null;
+        }
+
+        try {
+            String contents = new String(Files.readAllBytes(path), StandardCharsets.UTF_8);
+            JSONObject entry = new JSONObject(contents);
+
+            if (!entry.has("expiresAt") || System.currentTimeMillis() / 1000 >= entry.getLong("expiresAt")) {
+                Files.deleteIfExists(path);
+                return null;
+            }
+
+            return entry.optString("value", null);
+        } catch (IOException | JSONException e) {
+            try {
+                Files.deleteIfExists(path);
+            } catch (IOException ignored) {
+            }
+            return null;
+        }
+    }
+
+    @Override
+    public void set(String key, String value, int ttl) {
+        Path path = keyToPath(key);
+
+        JSONObject entry = new JSONObject();
+        entry.put("value", value);
+        entry.put("expiresAt", System.currentTimeMillis() / 1000 + ttl);
+
+        try {
+            Files.write(path, entry.toString().getBytes(StandardCharsets.UTF_8));
+        } catch (IOException e) {
+            throw new RuntimeException("Failed to write cache file: " + path, e);
+        }
+    }
+
+    @Override
+    public void delete(String key) {
+        Path path = keyToPath(key);
+        try {
+            Files.deleteIfExists(path);
+        } catch (IOException e) {
+            // Silently ignore delete failures
+        }
+    }
+
+    /**
+     * Convert a cache key to a safe filesystem path.
+     */
+    private Path keyToPath(String key) {
+        String safeKey = key.replaceAll("[^a-zA-Z0-9_\\-]", "_");
+        return cacheDir.resolve(safeKey + ".json");
+    }
+}

src/main/java/com/allow2/service/cache/MemoryCache.java

@@ -0,0 +1,50 @@
+package com.allow2.service.cache;
+
+import com.allow2.service.CacheInterface;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * In-memory cache with TTL support using ConcurrentHashMap.
+ *
+ * <p>No persistence between JVM restarts. Useful for testing or when you
+ * only need to deduplicate checks within a single process lifecycle.</p>
+ */
+public final class MemoryCache implements CacheInterface {
+
+    private final ConcurrentHashMap<String, CacheEntry> store = new ConcurrentHashMap<>();
+
+    @Override
+    public String get(String key) {
+        CacheEntry entry = store.get(key);
+        if (entry == null) {
+            return null;
+        }
+        if (System.currentTimeMillis() / 1000 >= entry.expiresAt) {
+            store.remove(key);
+            return null;
+        }
+        return entry.value;
+    }
+
+    @Override
+    public void set(String key, String value, int ttl) {
+        long expiresAt = System.currentTimeMillis() / 1000 + ttl;
+        store.put(key, new CacheEntry(value, expiresAt));
+    }
+
+    @Override
+    public void delete(String key) {
+        store.remove(key);
+    }
+
+    private static final class CacheEntry {
+        final String value;
+        final long expiresAt;
+
+        CacheEntry(String value, long expiresAt) {
+            this.value = value;
+            this.expiresAt = expiresAt;
+        }
+    }
+}

src/main/java/com/allow2/service/storage/FileTokenStorage.java

@@ -0,0 +1,111 @@
+package com.allow2.service.storage;
+
+import com.allow2.service.TokenStorageInterface;
+import com.allow2.service.models.OAuthTokens;
+import org.json.JSONObject;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.attribute.PosixFilePermission;
+import java.util.EnumSet;
+
+/**
+ * File-based JSON token storage.
+ *
+ * <p>Stores all tokens in a single JSON file. Suitable for development
+ * and single-server deployments. Not recommended for high-concurrency
+ * production use.</p>
+ */
+public final class FileTokenStorage implements TokenStorageInterface {
+
+    private final Path filePath;
+    private JSONObject data;
+
+    /**
+     * @param filePath Path to the JSON storage file.
+     */
+    public FileTokenStorage(String filePath) {
+        this.filePath = Paths.get(filePath);
+    }
+
+    @Override
+    public synchronized void store(String userId, OAuthTokens tokens) {
+        JSONObject all = loadAll();
+        JSONObject tokenObj = new JSONObject();
+        tokenObj.put("access_token", tokens.getAccessToken());
+        tokenObj.put("refresh_token", tokens.getRefreshToken());
+        tokenObj.put("expires_at", tokens.getExpiresAt());
+        all.put(userId, tokenObj);
+        saveAll(all);
+    }
+
+    @Override
+    public synchronized OAuthTokens retrieve(String userId) {
+        JSONObject all = loadAll();
+        if (!all.has(userId)) {
+            return null;
+        }
+        return OAuthTokens.fromJsonObject(all.getJSONObject(userId));
+    }
+
+    @Override
+    public synchronized void delete(String userId) {
+        JSONObject all = loadAll();
+        all.remove(userId);
+        saveAll(all);
+    }
+
+    @Override
+    public synchronized boolean exists(String userId) {
+        JSONObject all = loadAll();
+        return all.has(userId);
+    }
+
+    private JSONObject loadAll() {
+        if (data != null) {
+            return data;
+        }
+
+        if (!Files.exists(filePath)) {
+            data = new JSONObject();
+            return data;
+        }
+
+        try {
+            String contents = new String(Files.readAllBytes(filePath), StandardCharsets.UTF_8);
+            data = new JSONObject(contents);
+        } catch (IOException e) {
+            data = new JSONObject();
+        }
+
+        return data;
+    }
+
+    private void saveAll(JSONObject allData) {
+        this.data = allData;
+
+        try {
+            Path dir = filePath.getParent();
+            if (dir != null && !Files.exists(dir)) {
+                Files.createDirectories(dir);
+            }
+
+            Files.write(filePath, allData.toString(2).getBytes(StandardCharsets.UTF_8));
+
+            // Try to set file permissions to owner-only (may fail on non-POSIX systems)
+            try {
+                Files.setPosixFilePermissions(filePath, EnumSet.of(
+                        PosixFilePermission.OWNER_READ,
+                        PosixFilePermission.OWNER_WRITE
+                ));
+            } catch (UnsupportedOperationException e) {
+                // Non-POSIX filesystem, skip permission setting
+            }
+        } catch (IOException e) {
+            throw new RuntimeException("Failed to save token storage file: " + filePath, e);
+        }
+    }
+}

src/main/java/com/allow2/service/storage/MemoryTokenStorage.java

@@ -0,0 +1,37 @@
+package com.allow2.service.storage;
+
+import com.allow2.service.TokenStorageInterface;
+import com.allow2.service.models.OAuthTokens;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * In-memory token storage using ConcurrentHashMap.
+ *
+ * <p>No persistence between JVM restarts. Useful for testing or
+ * when you only need tokens for the lifetime of the process.</p>
+ */
+public final class MemoryTokenStorage implements TokenStorageInterface {
+
+    private final ConcurrentHashMap<String, OAuthTokens> store = new ConcurrentHashMap<>();
+
+    @Override
+    public void store(String userId, OAuthTokens tokens) {
+        store.put(userId, tokens);
+    }
+
+    @Override
+    public OAuthTokens retrieve(String userId) {
+        return store.get(userId);
+    }
+
+    @Override
+    public void delete(String userId) {
+        store.remove(userId);
+    }
+
+    @Override
+    public boolean exists(String userId) {
+        return store.containsKey(userId);
+    }
+}