feat: implement local storage layer and schema

Author: jaiswalism

src/storage/db.ts

@@ -0,0 +1,86 @@
+import { ProblemRecord, Settings, SyncLogEntry, RetryQueueItem } from './types';
+
+const SCHEMA_VERSION = 1;
+
+export const DEFAULT_SETTINGS: Settings = {
+  pat: null,
+  repository: null,
+  folderStructure: 'Difficulty',
+  versionMode: 'versioned',
+  commitTemplate: "Solved: {title}\nDifficulty: {difficulty}\nLanguage: {language}\nRuntime: {runtime}",
+  autoSync: true,
+  readmeEnabled: true,
+  schemaVersion: SCHEMA_VERSION,
+};
+
+export const db = {
+  async get<T>(key: string): Promise<T | null> {
+    const result = await chrome.storage.local.get(key);
+    return result[key] || null;
+  },
+
+  async set<T>(key: string, value: T): Promise<void> {
+    await chrome.storage.local.set({ [key]: value });
+  },
+
+  async getSettings(): Promise<Settings> {
+    const settings = await this.get<Settings>('settings');
+    if (!settings) return DEFAULT_SETTINGS;
+    
+    // Future migration logic can go here based on settings.schemaVersion
+    return settings;
+  },
+
+  async updateSettings(partial: Partial<Settings>): Promise<Settings> {
+    const current = await this.getSettings();
+    const updated = { ...current, ...partial };
+    await this.set('settings', updated);
+    return updated;
+  },
+
+  async getAllProblems(): Promise<ProblemRecord[]> {
+    const data = await chrome.storage.local.get(null);
+    const problems: ProblemRecord[] = [];
+    for (const key in data) {
+      if (key.startsWith('problems:')) {
+        problems.push(data[key]);
+      }
+    }
+    return problems;
+  },
+
+  async saveProblem(problem: ProblemRecord): Promise<void> {
+    await this.set(`problems:${problem.id}:${problem.language}`, problem);
+  },
+
+  async getProblem(id: string, language: string): Promise<ProblemRecord | null> {
+    return this.get<ProblemRecord>(`problems:${id}:${language}`);
+  },
+
+  async addLogEntry(entry: SyncLogEntry): Promise<void> {
+    const dateKey = new Date(entry.timestamp).toISOString().split('T')[0];
+    const logsKey = `log:${dateKey}`;
+    const logs = (await this.get<SyncLogEntry[]>(logsKey)) || [];
+    logs.push(entry);
+    await this.set(logsKey, logs);
+  },
+
+  async getLogs(date: Date): Promise<SyncLogEntry[]> {
+    const dateKey = date.toISOString().split('T')[0];
+    return (await this.get<SyncLogEntry[]>(`log:${dateKey}`)) || [];
+  },
+
+  async pushToQueue(item: Omit<RetryQueueItem, 'attempts'>): Promise<void> {
+    const queue = (await this.get<RetryQueueItem[]>('queue')) || [];
+    queue.push({ ...item, attempts: 0 });
+    await this.set('queue', queue);
+  },
+
+  async getQueue(): Promise<RetryQueueItem[]> {
+    return (await this.get<RetryQueueItem[]>('queue')) || [];
+  },
+
+  async saveQueue(queue: RetryQueueItem[]): Promise<void> {
+    await this.set('queue', queue);
+  }
+};

src/storage/types.ts

@@ -0,0 +1,42 @@
+export interface ProblemRecord {
+  id: string;
+  title: string;
+  difficulty: 'Easy' | 'Medium' | 'Hard';
+  language: string;
+  runtime: string;
+  memory: string;
+  submissionTime: number;
+  tags?: string[];
+  companyTags?: string[];
+  code: string;
+  url: string;
+  version: number;
+}
+
+export type FolderStructure = 'Difficulty' | 'Topic' | 'Language' | 'Number' | 'Flat';
+
+export interface Settings {
+  pat: string | null;
+  repository: string | null;
+  folderStructure: FolderStructure;
+  versionMode: 'versioned' | 'overwrite';
+  commitTemplate: string;
+  autoSync: boolean;
+  readmeEnabled: boolean;
+  schemaVersion: number;
+}
+
+export interface SyncLogEntry {
+  problemId: string;
+  title: string;
+  timestamp: number;
+  status: 'success' | 'failure' | 'skipped';
+  reason?: string;
+}
+
+export interface RetryQueueItem {
+  problemId: string;
+  reason: string;
+  timestamp: number;
+  attempts: number;
+}