@access-dlsu/leapify 0.260601.1 → 0.260601.2

package/dist/index.cjs

@@ -952,7 +952,10 @@ var GFormsService = class {
       const response = await fetch(url.toString(), {
         headers: { Authorization: `Bearer ${token}` }
       });
-      if (!response.ok) throw new Error(`Forms API error: ${response.status}`);
+      if (!response.ok) {
+        const err = await response.text();
+        throw new Error(`Forms API error: ${response.status} ${err}`);
+      }
       const data = await response.json();
       allResponses.push(...data.responses ?? []);
       pageToken = data.nextPageToken;
@@ -1226,6 +1229,27 @@ classesRoute.get("/:slug/slots", eventsSlotsRateLimit, async (c) => {
   c.header("Cache-Control", "public, max-age=5, stale-while-revalidate=5");
   return c.json({ data: info });
 });
+classesRoute.post("/:slug/reconcile", authMiddleware, adminMiddleware, async (c) => {
+  const { slug } = c.req.param();
+  const db = createDb(c.env.DB);
+  const cache = new CacheService(c.env.KV);
+  const gforms = new GFormsService(c.env.GFORMS_SERVICE_ACCOUNT_JSON);
+  const slots = new SlotsService(db, cache);
+  const event = await db.query.events.findFirst({
+    where: drizzleOrm.eq(events.slug, slug),
+    columns: { gformsId: true }
+  });
+  if (!event) throw notFound("Event");
+  if (!event.gformsId) return c.json({ error: "No gformsId set for this event" }, 400);
+  try {
+    const googleCount = await gforms.getExactResponseCount(event.gformsId);
+    await slots.correctCount(slug, googleCount);
+    return c.json({ data: { registeredSlots: googleCount } });
+  } catch (err) {
+    const message = err?.message ?? "Failed to fetch from Google Forms API";
+    return c.json({ error: { code: "GFORMS_API_ERROR", message } }, 502);
+  }
+});
 classesRoute.post(
   "/",
   authMiddleware,
@@ -1533,6 +1557,196 @@ async function verifyGoogSignature(body, signature, secret) {
     return false;
   }
 }
+var LOCK_KEY = "cron:reconcile-slots:lock";
+var LOCK_TTL = 300;
+async function reconcileSlots(env) {
+  const db = createDb(env.DB);
+  const cache = new CacheService(env.KV);
+  const gforms = new GFormsService(env.GFORMS_SERVICE_ACCOUNT_JSON);
+  const slots = new SlotsService(db, cache);
+  const lock = await cache.get(LOCK_KEY);
+  if (lock) {
+    console.log("[reconcile-slots] Lock held, skipping.");
+    return;
+  }
+  await cache.set(LOCK_KEY, "1", LOCK_TTL);
+  try {
+    const publishedEvents = await db.query.events.findMany({
+      where: drizzleOrm.isNotNull(events.gformsId),
+      columns: { id: true, slug: true, gformsId: true, registeredSlots: true }
+    });
+    const eventsWithForms = publishedEvents.filter((e) => e.gformsId);
+    let corrected = 0;
+    for (const event of eventsWithForms) {
+      try {
+        const googleCount = await gforms.getExactResponseCount(event.gformsId);
+        const localCount = event.registeredSlots;
+        if (googleCount !== localCount) {
+          console.warn(
+            `[reconcile-slots] Drift on "${event.slug}": local=${localCount}, google=${googleCount}`
+          );
+          await slots.correctCount(event.slug, googleCount);
+          corrected++;
+        }
+      } catch (err) {
+        console.error(`[reconcile-slots] Error checking "${event.slug}":`, err);
+      }
+    }
+    console.log(
+      `[reconcile-slots] Checked ${eventsWithForms.length} events, corrected ${corrected}.`
+    );
+  } finally {
+    await cache.del(LOCK_KEY);
+  }
+}
+
+// src/routes/internal/reconcile-slots.ts
+var reconcileSlotsRoute = new hono.Hono();
+reconcileSlotsRoute.post("/", internalMiddleware, async (c) => {
+  await reconcileSlots(c.env);
+  return c.json({ ok: true });
+});
+async function batchRelease(env) {
+  const db = createDb(env.DB);
+  const cache = new CacheService(env.KV);
+  const now = Math.floor(Date.now() / 1e3);
+  const toPublish = await db.query.events.findMany({
+    where: drizzleOrm.and(drizzleOrm.eq(events.status, "queued"), drizzleOrm.lte(events.releaseAt, now)),
+    columns: { id: true, slug: true }
+  });
+  if (toPublish.length === 0) return;
+  const ids = toPublish.map((e) => e.id);
+  await db.update(events).set({ status: "published", publishedAt: drizzleOrm.sql`(unixepoch())` }).where(
+    // Drizzle doesn't have inArray for D1; use raw SQL for batch
+    drizzleOrm.sql`${events.id} IN (${drizzleOrm.sql.join(
+      ids.map((id) => drizzleOrm.sql`${id}`),
+      drizzleOrm.sql`, `
+    )})`
+  );
+  await cache.del("events:list");
+  await cache.del("events:etag");
+  console.log(
+    `[batch-release] Published ${toPublish.length} events:`,
+    toPublish.map((e) => e.slug).join(", ")
+  );
+}
+
+// src/routes/internal/batch-release.ts
+var batchReleaseRoute = new hono.Hono();
+batchReleaseRoute.post("/", internalMiddleware, async (c) => {
+  await batchRelease(c.env);
+  return c.json({ ok: true });
+});
+function parseStartTimestamp(dateTime, startTime) {
+  if (!dateTime) return null;
+  const combined = startTime ? `${dateTime} ${startTime}` : dateTime;
+  const ms = Date.parse(combined);
+  return Number.isNaN(ms) ? null : Math.floor(ms / 1e3);
+}
+async function reminderEmails(env) {
+  if (!env.EMAIL_QUEUE) {
+    console.warn(
+      "[reminder-emails] EMAIL_QUEUE binding not configured, skipping."
+    );
+    return;
+  }
+  const hasSes = !!(env.SES_REGION && env.SES_ACCESS_KEY_ID && env.SES_SECRET_ACCESS_KEY);
+  const hasResend = !!env.RESEND_API_KEY;
+  if (!hasSes && !hasResend) {
+    console.warn(
+      "[reminder-emails] No email providers configured. Skipping reminders."
+    );
+    return;
+  }
+  const db = createDb(env.DB);
+  const now = Math.floor(Date.now() / 1e3);
+  const candidates24h = await db.query.events.findMany({
+    where: drizzleOrm.and(
+      drizzleOrm.eq(events.status, "published"),
+      drizzleOrm.eq(events.reminder24hSent, false)
+    ),
+    columns: {
+      id: true,
+      dateTime: true,
+      startTime: true
+    }
+  });
+  for (const event of candidates24h) {
+    const startsAt = parseStartTimestamp(event.dateTime, event.startTime);
+    if (!startsAt) continue;
+    const hoursUntil = (startsAt - now) / 3600;
+    if (hoursUntil <= 25 && hoursUntil >= 23) {
+      await env.EMAIL_QUEUE.send({
+        type: "send_reminder_email",
+        payload: { eventId: event.id, hoursBeforeEvent: 24 }
+      });
+    }
+  }
+  const candidates1h = await db.query.events.findMany({
+    where: drizzleOrm.and(
+      drizzleOrm.eq(events.status, "published"),
+      drizzleOrm.eq(events.reminder1hSent, false)
+    ),
+    columns: {
+      id: true,
+      dateTime: true,
+      startTime: true
+    }
+  });
+  for (const event of candidates1h) {
+    const startsAt = parseStartTimestamp(event.dateTime, event.startTime);
+    if (!startsAt) continue;
+    const hoursUntil = (startsAt - now) / 3600;
+    if (hoursUntil <= 1.5 && hoursUntil >= 0) {
+      await env.EMAIL_QUEUE.send({
+        type: "send_reminder_email",
+        payload: { eventId: event.id, hoursBeforeEvent: 1 }
+      });
+    }
+  }
+}
+
+// src/routes/internal/reminder-emails.ts
+var reminderEmailsRoute = new hono.Hono();
+reminderEmailsRoute.post("/", internalMiddleware, async (c) => {
+  await reminderEmails(c.env);
+  return c.json({ ok: true });
+});
+var RENEWAL_WINDOW = 86400;
+async function renewWatches(env) {
+  const db = createDb(env.DB);
+  const gforms = new GFormsService(env.GFORMS_SERVICE_ACCOUNT_JSON);
+  const now = Math.floor(Date.now() / 1e3);
+  const threshold = now + RENEWAL_WINDOW;
+  const expiring = await db.query.events.findMany({
+    where: drizzleOrm.and(
+      drizzleOrm.eq(events.status, "published"),
+      drizzleOrm.lte(events.watchExpiresAt, threshold)
+    ),
+    columns: { id: true, slug: true, gformsId: true, watchId: true, watchExpiresAt: true }
+  });
+  const watchEvents = expiring.filter((e) => e.gformsId && e.watchId);
+  let renewed = 0;
+  for (const event of watchEvents) {
+    try {
+      const result = await gforms.renewWatch(event.gformsId, event.watchId);
+      const newExpiry = Math.floor(new Date(result.expireTime).getTime() / 1e3);
+      await db.update(events).set({ watchExpiresAt: newExpiry }).where(drizzleOrm.eq(events.id, event.id));
+      renewed++;
+      console.log(`[renew-watches] Renewed Watch for "${event.slug}", expires ${result.expireTime}`);
+    } catch (err) {
+      console.error(`[renew-watches] Failed to renew Watch for "${event.slug}":`, err);
+    }
+  }
+  console.log(`[renew-watches] Renewed ${renewed}/${watchEvents.length} watches.`);
+}
+
+// src/routes/internal/renew-watches.ts
+var renewWatchesRoute = new hono.Hono();
+renewWatchesRoute.post("/", internalMiddleware, async (c) => {
+  await renewWatches(c.env);
+  return c.json({ ok: true });
+});
 var ALLOWED_MIME_TYPES = /* @__PURE__ */ new Set([
   "image/jpeg",
   "image/png",
@@ -1799,6 +2013,10 @@ function createApp(options = {}) {
   app.route("/api/faqs", faqsRoute);
   app.route("/api/uploads", uploadsRoute);
   app.route("/internal/gforms-webhook", gformsWebhookRoute);
+  app.route("/internal/reconcile-slots", reconcileSlotsRoute);
+  app.route("/internal/batch-release", batchReleaseRoute);
+  app.route("/internal/reminder-emails", reminderEmailsRoute);
+  app.route("/internal/renew-watches", renewWatchesRoute);
   app.onError(errorHandler);
   app.notFound(
     (c) => c.json({ error: { code: "NOT_FOUND", message: "Route not found" } }, 404)
@@ -2229,168 +2447,6 @@ async function processJob(job, services) {
     }
   }
 }
-async function batchRelease(env) {
-  const db = createDb(env.DB);
-  const cache = new CacheService(env.KV);
-  const now = Math.floor(Date.now() / 1e3);
-  const toPublish = await db.query.events.findMany({
-    where: drizzleOrm.and(drizzleOrm.eq(events.status, "queued"), drizzleOrm.lte(events.releaseAt, now)),
-    columns: { id: true, slug: true }
-  });
-  if (toPublish.length === 0) return;
-  const ids = toPublish.map((e) => e.id);
-  await db.update(events).set({ status: "published", publishedAt: drizzleOrm.sql`(unixepoch())` }).where(
-    // Drizzle doesn't have inArray for D1; use raw SQL for batch
-    drizzleOrm.sql`${events.id} IN (${drizzleOrm.sql.join(
-      ids.map((id) => drizzleOrm.sql`${id}`),
-      drizzleOrm.sql`, `
-    )})`
-  );
-  await cache.del("events:list");
-  await cache.del("events:etag");
-  console.log(
-    `[batch-release] Published ${toPublish.length} events:`,
-    toPublish.map((e) => e.slug).join(", ")
-  );
-}
-var LOCK_KEY = "cron:reconcile-slots:lock";
-var LOCK_TTL = 300;
-async function reconcileSlots(env) {
-  const db = createDb(env.DB);
-  const cache = new CacheService(env.KV);
-  const gforms = new GFormsService(env.GFORMS_SERVICE_ACCOUNT_JSON);
-  const slots = new SlotsService(db, cache);
-  const lock = await cache.get(LOCK_KEY);
-  if (lock) {
-    console.log("[reconcile-slots] Lock held, skipping.");
-    return;
-  }
-  await cache.set(LOCK_KEY, "1", LOCK_TTL);
-  try {
-    const publishedEvents = await db.query.events.findMany({
-      where: drizzleOrm.eq(events.status, "published"),
-      columns: { id: true, slug: true, gformsId: true, registeredSlots: true }
-    });
-    const eventsWithForms = publishedEvents.filter((e) => e.gformsId);
-    let corrected = 0;
-    for (const event of eventsWithForms) {
-      try {
-        const googleCount = await gforms.getExactResponseCount(event.gformsId);
-        const localCount = event.registeredSlots;
-        if (googleCount !== localCount) {
-          console.warn(
-            `[reconcile-slots] Drift on "${event.slug}": local=${localCount}, google=${googleCount}`
-          );
-          await slots.correctCount(event.slug, googleCount);
-          corrected++;
-        }
-      } catch (err) {
-        console.error(`[reconcile-slots] Error checking "${event.slug}":`, err);
-      }
-    }
-    console.log(
-      `[reconcile-slots] Checked ${eventsWithForms.length} events, corrected ${corrected}.`
-    );
-  } finally {
-    await cache.del(LOCK_KEY);
-  }
-}
-function parseStartTimestamp(dateTime, startTime) {
-  if (!dateTime) return null;
-  const combined = startTime ? `${dateTime} ${startTime}` : dateTime;
-  const ms = Date.parse(combined);
-  return Number.isNaN(ms) ? null : Math.floor(ms / 1e3);
-}
-async function reminderEmails(env) {
-  if (!env.EMAIL_QUEUE) {
-    console.warn(
-      "[reminder-emails] EMAIL_QUEUE binding not configured, skipping."
-    );
-    return;
-  }
-  const hasSes = !!(env.SES_REGION && env.SES_ACCESS_KEY_ID && env.SES_SECRET_ACCESS_KEY);
-  const hasResend = !!env.RESEND_API_KEY;
-  if (!hasSes && !hasResend) {
-    console.warn(
-      "[reminder-emails] No email providers configured. Skipping reminders."
-    );
-    return;
-  }
-  const db = createDb(env.DB);
-  const now = Math.floor(Date.now() / 1e3);
-  const candidates24h = await db.query.events.findMany({
-    where: drizzleOrm.and(
-      drizzleOrm.eq(events.status, "published"),
-      drizzleOrm.eq(events.reminder24hSent, false)
-    ),
-    columns: {
-      id: true,
-      dateTime: true,
-      startTime: true
-    }
-  });
-  for (const event of candidates24h) {
-    const startsAt = parseStartTimestamp(event.dateTime, event.startTime);
-    if (!startsAt) continue;
-    const hoursUntil = (startsAt - now) / 3600;
-    if (hoursUntil <= 25 && hoursUntil >= 23) {
-      await env.EMAIL_QUEUE.send({
-        type: "send_reminder_email",
-        payload: { eventId: event.id, hoursBeforeEvent: 24 }
-      });
-    }
-  }
-  const candidates1h = await db.query.events.findMany({
-    where: drizzleOrm.and(
-      drizzleOrm.eq(events.status, "published"),
-      drizzleOrm.eq(events.reminder1hSent, false)
-    ),
-    columns: {
-      id: true,
-      dateTime: true,
-      startTime: true
-    }
-  });
-  for (const event of candidates1h) {
-    const startsAt = parseStartTimestamp(event.dateTime, event.startTime);
-    if (!startsAt) continue;
-    const hoursUntil = (startsAt - now) / 3600;
-    if (hoursUntil <= 1.5 && hoursUntil >= 0) {
-      await env.EMAIL_QUEUE.send({
-        type: "send_reminder_email",
-        payload: { eventId: event.id, hoursBeforeEvent: 1 }
-      });
-    }
-  }
-}
-var RENEWAL_WINDOW = 86400;
-async function renewWatches(env) {
-  const db = createDb(env.DB);
-  const gforms = new GFormsService(env.GFORMS_SERVICE_ACCOUNT_JSON);
-  const now = Math.floor(Date.now() / 1e3);
-  const threshold = now + RENEWAL_WINDOW;
-  const expiring = await db.query.events.findMany({
-    where: drizzleOrm.and(
-      drizzleOrm.eq(events.status, "published"),
-      drizzleOrm.lte(events.watchExpiresAt, threshold)
-    ),
-    columns: { id: true, slug: true, gformsId: true, watchId: true, watchExpiresAt: true }
-  });
-  const watchEvents = expiring.filter((e) => e.gformsId && e.watchId);
-  let renewed = 0;
-  for (const event of watchEvents) {
-    try {
-      const result = await gforms.renewWatch(event.gformsId, event.watchId);
-      const newExpiry = Math.floor(new Date(result.expireTime).getTime() / 1e3);
-      await db.update(events).set({ watchExpiresAt: newExpiry }).where(drizzleOrm.eq(events.id, event.id));
-      renewed++;
-      console.log(`[renew-watches] Renewed Watch for "${event.slug}", expires ${result.expireTime}`);
-    } catch (err) {
-      console.error(`[renew-watches] Failed to renew Watch for "${event.slug}":`, err);
-    }
-  }
-  console.log(`[renew-watches] Renewed ${renewed}/${watchEvents.length} watches.`);
-}
 
 // src/db/migrate.ts
 var PATCH_STATEMENTS = [
@@ -2597,7 +2653,7 @@ function defaultGetRuntimeConfig(env) {
   };
 }
 function injectConfig(html, config) {
-  const configScript = `<script>window.__CONFIG__=${JSON.stringify(config)};</script>`;
+  const configScript = `<script>window.__CONFIG__=${JSON.stringify(config)};<\/script>`;
   return html.replace("</head>", `${configScript}</head>`);
 }
 function createWorkerHandler(options) {
@@ -2719,7 +2775,7 @@ function getRuntimeConfig(env) {
   };
 }
 function injectConfig2(html, config) {
-  const configScript = `<script>window.__CONFIG__=${JSON.stringify(config)};</script>`;
+  const configScript = `<script>window.__CONFIG__=${JSON.stringify(config)};<\/script>`;
   return html.replace("</head>", `${configScript}</head>`);
 }