zele 0.1.2 → 0.2.0

package/src/gmail-cache.ts

@@ -12,6 +12,8 @@ export const TTL = {
   LABELS: 30 * 60 * 1000, // 30 minutes
   PROFILE: 24 * 60 * 60 * 1000, // 24 hours
   LABEL_COUNTS: 2 * 60 * 1000, // 2 minutes
+  CALENDAR_LIST: 30 * 60 * 1000, // 30 minutes
+  CALENDAR_EVENTS: 5 * 60 * 1000, // 5 minutes
 } as const
 
 function isExpired(createdAt: Date, ttlMs: number): boolean {
@@ -202,6 +204,90 @@ export async function setLastHistoryId(email: string, historyId: string): Promis
   })
 }
 
+// ---------------------------------------------------------------------------
+// Calendar list cache
+// ---------------------------------------------------------------------------
+
+export async function cacheCalendarList(email: string, data: unknown): Promise<void> {
+  const prisma = await getPrisma()
+  await prisma.calendar_lists.upsert({
+    where: { email },
+    create: { email, data: JSON.stringify(data), ttl_ms: TTL.CALENDAR_LIST },
+    update: { data: JSON.stringify(data), ttl_ms: TTL.CALENDAR_LIST, created_at: new Date() },
+  })
+}
+
+export async function getCachedCalendarList<T = unknown>(email: string): Promise<T | undefined> {
+  const prisma = await getPrisma()
+  const row = await prisma.calendar_lists.findUnique({ where: { email } })
+  if (!row || isExpired(row.created_at, row.ttl_ms)) return undefined
+  return JSON.parse(row.data) as T
+}
+
+export async function invalidateCalendarLists(email: string): Promise<void> {
+  const prisma = await getPrisma()
+  await prisma.calendar_lists.deleteMany({ where: { email } })
+}
+
+// ---------------------------------------------------------------------------
+// Calendar events cache
+// ---------------------------------------------------------------------------
+
+export async function cacheCalendarEvents(
+  email: string,
+  params: { calendarId?: string; timeMin?: string; timeMax?: string; query?: string; maxResults?: number; pageToken?: string },
+  data: unknown,
+): Promise<void> {
+  const prisma = await getPrisma()
+  const where = {
+    email,
+    calendar_id: params.calendarId ?? '',
+    time_min: params.timeMin ?? '',
+    time_max: params.timeMax ?? '',
+    query: params.query ?? '',
+    max_results: params.maxResults ?? 0,
+    page_token: params.pageToken ?? '',
+  }
+
+  await prisma.calendar_events.upsert({
+    where: { email_calendar_id_time_min_time_max_query_max_results_page_token: where },
+    create: { ...where, data: JSON.stringify(data), ttl_ms: TTL.CALENDAR_EVENTS },
+    update: { data: JSON.stringify(data), ttl_ms: TTL.CALENDAR_EVENTS, created_at: new Date() },
+  })
+}
+
+export async function getCachedCalendarEvents<T = unknown>(
+  email: string,
+  params: { calendarId?: string; timeMin?: string; timeMax?: string; query?: string; maxResults?: number; pageToken?: string },
+): Promise<T | undefined> {
+  const prisma = await getPrisma()
+  const row = await prisma.calendar_events.findUnique({
+    where: {
+      email_calendar_id_time_min_time_max_query_max_results_page_token: {
+        email,
+        calendar_id: params.calendarId ?? '',
+        time_min: params.timeMin ?? '',
+        time_max: params.timeMax ?? '',
+        query: params.query ?? '',
+        max_results: params.maxResults ?? 0,
+        page_token: params.pageToken ?? '',
+      },
+    },
+  })
+
+  if (!row || isExpired(row.created_at, row.ttl_ms)) return undefined
+  return JSON.parse(row.data) as T
+}
+
+export async function invalidateCalendarEvents(email: string, calendarId?: string): Promise<void> {
+  const prisma = await getPrisma()
+  if (calendarId) {
+    await prisma.calendar_events.deleteMany({ where: { email, calendar_id: calendarId } })
+  } else {
+    await prisma.calendar_events.deleteMany({ where: { email } })
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Housekeeping
 // ---------------------------------------------------------------------------
@@ -230,6 +316,14 @@ export async function clearExpired(): Promise<void> {
     `DELETE FROM profiles WHERE (strftime('%s', created_at) * 1000 + ttl_ms) < ?`,
     now,
   )
+  await prisma.$executeRawUnsafe(
+    `DELETE FROM calendar_lists WHERE (strftime('%s', created_at) * 1000 + ttl_ms) < ?`,
+    now,
+  )
+  await prisma.$executeRawUnsafe(
+    `DELETE FROM calendar_events WHERE (strftime('%s', created_at) * 1000 + ttl_ms) < ?`,
+    now,
+  )
 }
 
 export async function clearAll(email: string): Promise<void> {
@@ -240,4 +334,6 @@ export async function clearAll(email: string): Promise<void> {
   await prisma.label_counts.deleteMany({ where: { email } })
   await prisma.profiles.deleteMany({ where: { email } })
   await prisma.sync_states.deleteMany({ where: { email } })
+  await prisma.calendar_lists.deleteMany({ where: { email } })
+  await prisma.calendar_events.deleteMany({ where: { email } })
 }

package/src/gmail-client.ts

@@ -12,6 +12,7 @@ import { gmail as gmailApi, type gmail_v1 } from '@googleapis/gmail'
 import type { OAuth2Client } from 'google-auth-library'
 import { createMimeMessage } from 'mimetext'
 import { parseFrom, parseAddressList } from './email-utils.js'
+import { withRetry, mapConcurrent } from './api-utils.js'
 
 // ---------------------------------------------------------------------------
 // Types
@@ -105,8 +106,6 @@ const SYSTEM_LABEL_IDS = new Set([
   'MUTED',
 ])
 
-const MAX_CONCURRENCY = 10
-
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -121,61 +120,6 @@ function encodeBase64Url(data: string | Buffer) {
   return buf.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
 }
 
-/** Run promises with bounded concurrency */
-async function mapConcurrent<T, R>(
-  items: T[],
-  fn: (item: T) => Promise<R>,
-  concurrency = MAX_CONCURRENCY,
-): Promise<R[]> {
-  const results: R[] = []
-  let index = 0
-
-  async function worker() {
-    while (index < items.length) {
-      const i = index++
-      results[i] = await fn(items[i]!)
-    }
-  }
-
-  const workers = Array.from({ length: Math.min(concurrency, items.length) }, () => worker())
-  await Promise.all(workers)
-  return results
-}
-
-/** Simple retry for rate limit errors (429 and 403 quota errors).
- *  Matches Zero's gmail-rate-limit.ts schedule: up to 10 attempts, 60s base delay. */
-async function withRetry<T>(fn: () => Promise<T>, maxAttempts = 10, delayMs = 60000): Promise<T> {
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    try {
-      return await fn()
-    } catch (err: any) {
-      if (!isRateLimitError(err) || attempt === maxAttempts) throw err
-      const wait = delayMs * Math.pow(2, attempt - 1)
-      await new Promise((r) => setTimeout(r, wait))
-    }
-  }
-  throw new Error('unreachable')
-}
-
-function isRateLimitError(err: any): boolean {
-  const status = err?.code ?? err?.status ?? err?.response?.status
-  if (status === 429) return true
-  if (status === 403) {
-    const errors = err?.errors ?? err?.response?.data?.error?.errors ?? []
-    return errors.some((e: any) =>
-      [
-        'userRateLimitExceeded',
-        'rateLimitExceeded',
-        'quotaExceeded',
-        'dailyLimitExceeded',
-        'limitExceeded',
-        'backendError',
-      ].includes(e.reason),
-    )
-  }
-  return false
-}
-
 // ---------------------------------------------------------------------------
 // GmailClient
 // ---------------------------------------------------------------------------

package/src/output.ts

@@ -158,6 +158,57 @@ export function formatDate(dateStr: string): string {
   return date.toLocaleDateString(undefined, { month: 'short', day: 'numeric', year: 'numeric' })
 }
 
+// ---------------------------------------------------------------------------
+// Calendar event time formatting
+// ---------------------------------------------------------------------------
+
+/**
+ * Format event start/end times for display.
+ * Same day: "Feb 10, 2:00 - 3:00 PM"
+ * Different days: "Feb 10, 2:00 PM - Feb 11, 10:00 AM"
+ * All-day single: "Feb 10"
+ * All-day multi: "Feb 10 - Feb 12"
+ */
+export function formatEventTime(start: string, end: string, allDay = false): { start: string; end: string } {
+  if (allDay) {
+    const startDate = new Date(start + 'T00:00:00')
+    const endDate = new Date(end + 'T00:00:00')
+    // Calendar API uses exclusive end date for all-day events
+    endDate.setDate(endDate.getDate() - 1)
+
+    const fmt = (d: Date) => d.toLocaleDateString(undefined, { month: 'short', day: 'numeric' })
+
+    if (startDate.getTime() === endDate.getTime()) {
+      const s = fmt(startDate)
+      return { start: s, end: s }
+    }
+    return { start: fmt(startDate), end: fmt(endDate) }
+  }
+
+  const startDate = new Date(start)
+  const endDate = new Date(end)
+
+  const timeOpts: Intl.DateTimeFormatOptions = { hour: 'numeric', minute: '2-digit' }
+  const dateTimeOpts: Intl.DateTimeFormatOptions = { month: 'short', day: 'numeric', hour: 'numeric', minute: '2-digit' }
+
+  const sameDay = startDate.toDateString() === endDate.toDateString()
+
+  if (sameDay) {
+    const dateStr = startDate.toLocaleDateString(undefined, { month: 'short', day: 'numeric' })
+    const startTime = startDate.toLocaleTimeString(undefined, timeOpts)
+    const endTime = endDate.toLocaleTimeString(undefined, timeOpts)
+    return {
+      start: `${dateStr}, ${startTime}`,
+      end: endTime,
+    }
+  }
+
+  return {
+    start: startDate.toLocaleString(undefined, dateTimeOpts),
+    end: endDate.toLocaleString(undefined, dateTimeOpts),
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Sender formatting
 // ---------------------------------------------------------------------------

package/src/schema.sql

@@ -50,6 +50,27 @@ CREATE TABLE IF NOT EXISTS "profiles" (
     "created_at" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
     CONSTRAINT "profiles_email_fkey" FOREIGN KEY ("email") REFERENCES "accounts" ("email") ON DELETE CASCADE ON UPDATE CASCADE
 );
+CREATE TABLE IF NOT EXISTS "calendar_lists" (
+    "email" TEXT NOT NULL PRIMARY KEY,
+    "data" TEXT NOT NULL,
+    "ttl_ms" INTEGER NOT NULL,
+    "created_at" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    CONSTRAINT "calendar_lists_email_fkey" FOREIGN KEY ("email") REFERENCES "accounts" ("email") ON DELETE CASCADE ON UPDATE CASCADE
+);
+CREATE TABLE IF NOT EXISTS "calendar_events" (
+    "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    "email" TEXT NOT NULL,
+    "calendar_id" TEXT NOT NULL DEFAULT '',
+    "time_min" TEXT NOT NULL DEFAULT '',
+    "time_max" TEXT NOT NULL DEFAULT '',
+    "query" TEXT NOT NULL DEFAULT '',
+    "max_results" INTEGER NOT NULL DEFAULT 0,
+    "page_token" TEXT NOT NULL DEFAULT '',
+    "data" TEXT NOT NULL,
+    "ttl_ms" INTEGER NOT NULL,
+    "created_at" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    CONSTRAINT "calendar_events_email_fkey" FOREIGN KEY ("email") REFERENCES "accounts" ("email") ON DELETE CASCADE ON UPDATE CASCADE
+);
 CREATE TABLE IF NOT EXISTS "sync_states" (
     "email" TEXT NOT NULL,
     "key" TEXT NOT NULL,
@@ -60,3 +81,4 @@ CREATE TABLE IF NOT EXISTS "sync_states" (
 );
 CREATE UNIQUE INDEX "thread_lists_email_folder_query_label_ids_page_token_max_results_key" ON "thread_lists"("email", "folder", "query", "label_ids", "page_token", "max_results");
 CREATE UNIQUE INDEX "threads_email_thread_id_key" ON "threads"("email", "thread_id");
+CREATE UNIQUE INDEX "calendar_events_email_calendar_id_time_min_time_max_query_max_results_page_token_key" ON "calendar_events"("email", "calendar_id", "time_min", "time_max", "query", "max_results", "page_token");