@odla-ai/chapter 0.4.0 → 0.7.0

package/dist/worker/index.cjs

@@ -20,7 +20,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/worker.ts
 var worker_exports = {};
 __export(worker_exports, {
-  chapterWorker: () => chapterWorker
+  chapterWorker: () => chapterWorker,
+  createWorkerContext: () => createWorkerContext
 });
 module.exports = __toCommonJS(worker_exports);
 
@@ -120,6 +121,27 @@ function createWorkerContext(options) {
 // src/worker-routes.ts
 var import_crm2 = require("@odla-ai/crm");
 
+// src/clerk.ts
+function clerkInviteRequest(input) {
+  return {
+    path: "/v1/invitations",
+    body: {
+      email_address: input.email,
+      notify: true,
+      ...input.redirectUrl ? { redirect_url: input.redirectUrl } : {}
+    }
+  };
+}
+async function createClerkInvitation(secretKey, input, fetchImpl = fetch) {
+  const { path, body } = clerkInviteRequest(input);
+  const res = await fetchImpl(`https://api.clerk.com${path}`, {
+    method: "POST",
+    headers: { authorization: `Bearer ${secretKey}`, "content-type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  return { ok: res.ok, status: res.status };
+}
+
 // src/member.ts
 async function submitApplication(db, chapter, fields, opts) {
   const app = chapter.application;
@@ -173,21 +195,32 @@ function sharedPersonInput(person) {
   if (person.linkedin) input.linkedin = person.linkedin;
   return input;
 }
-async function projectSharedRecord(deps, person) {
-  const email = person.email.toLowerCase();
-  const input = sharedPersonInput(person);
+async function upsertPerson(deps, opts) {
+  const email = opts.email.toLowerCase();
   const crmDeps = { crm: deps.crm, db: deps.db, now: deps.now, newId: deps.newId };
-  const { crm_record } = await deps.db.query({
-    crm_record: { $: { where: { type: "person", primaryEmail: email }, limit: 1 } }
-  });
+  const { crm_record } = await deps.db.query({ crm_record: { $: { where: { type: "person", primaryEmail: email }, limit: 1 } } });
   const existing = crm_record?.[0];
   if (existing && typeof existing.id === "string") {
-    await (0, import_crm.updateRecord)(crmDeps, { id: existing.id, input });
+    await (0, import_crm.updateRecord)(crmDeps, { id: existing.id, input: opts.input });
     return { recordId: existing.id };
   }
-  const created = await (0, import_crm.createRecord)(crmDeps, { type: "person", input, mutationId: `share:${person.hubRecordId}` });
+  const created = await (0, import_crm.createRecord)(crmDeps, { type: "person", input: opts.input, mutationId: opts.mutationId });
   return { recordId: created.id };
 }
+async function projectSharedRecord(deps, person) {
+  return upsertPerson(deps, { email: person.email, input: sharedPersonInput(person), mutationId: `share:${person.hubRecordId}` });
+}
+async function projectApplicant(deps, applicant) {
+  const input = sharedPersonInput({
+    email: applicant.email,
+    firstName: applicant.firstName,
+    lastName: applicant.lastName,
+    phone: applicant.phone,
+    linkedin: applicant.linkedin,
+    hubRecordId: applicant.applicationId
+  });
+  return upsertPerson(deps, { email: applicant.email, input, mutationId: `apply:${applicant.applicationId}` });
+}
 
 // src/scheduling.ts
 var SCHEDULING_DEFAULTS = {
@@ -235,10 +268,6 @@ function resolveScheduling(config) {
   if (typeof c.summaryTemplate !== "string") fail2("summaryTemplate must be a string");
   return { ...c, days };
 }
-var BOOKABLE_STATUSES = ["submitted", "paid_pending_vetting", "call_scheduled"];
-function canBookFrom(status) {
-  return BOOKABLE_STATUSES.includes(status);
-}
 function slotWindow(now, windowDays) {
   return { from: now, to: now + windowDays * 864e5 };
 }
@@ -317,7 +346,141 @@ function memberApplication(app, meeting, defaultTimezone) {
   return { ...summary, meetingAt, meetUrl, timezone };
 }
 
+// src/email.ts
+function render(template, vars) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? "");
+}
+function groupVars(group, vars) {
+  return {
+    ...vars,
+    refundPolicyText: group.refundPolicyText ?? "",
+    commitmentText: group.commitmentText ?? "",
+    normsText: group.normsText ?? ""
+  };
+}
+function isAlreadySent(priorRows) {
+  return priorRows.some((row) => !row.error);
+}
+function planDelivery(input) {
+  const tpl = input.group.emailTemplates?.[input.template];
+  if (!tpl) return { deliver: false, reason: "template-missing" };
+  if (tpl.enabled === false && !input.force) return { deliver: false, reason: "disabled" };
+  const vars = groupVars(input.group, input.vars);
+  const isProd = input.envName === "prod";
+  const redirect = !isProd && !!input.group.debugEmail;
+  const transport = !isProd && !redirect ? "log-only" : input.cloudflareReady ? "cloudflare" : "log-only";
+  const to = redirect ? input.group.debugEmail : input.to;
+  const subject = (redirect ? "[dev] " : "") + render(tpl.subject, vars);
+  const text = redirect ? `(dev redirect; original recipient: ${input.to})
+
+` + render(tpl.text, vars) : render(tpl.text, vars);
+  return { deliver: true, transport, to, subject, text, redirected: redirect };
+}
+
+// src/notify.ts
+async function sendTemplated(deps, input) {
+  const { emailLog } = await deps.db.query({ emailLog: { $: { where: { dedupeKey: input.dedupeKey } } } });
+  const prior = Array.isArray(emailLog) ? emailLog : [];
+  if (isAlreadySent(prior)) return { sent: true, reason: "already-sent" };
+  const cloudflareReady = Boolean(deps.sender && deps.from);
+  const decision = planDelivery({
+    envName: deps.envName,
+    group: input.group,
+    template: input.template,
+    to: input.to,
+    vars: input.vars,
+    cloudflareReady,
+    force: input.force
+  });
+  if (!decision.deliver) return { sent: false, reason: decision.reason };
+  let error;
+  let messageId;
+  if (decision.transport === "cloudflare" && deps.sender && deps.from) {
+    try {
+      const res = await deps.sender.send({
+        from: deps.from,
+        to: [decision.to],
+        subject: decision.subject,
+        text: decision.text,
+        replyTo: input.group.replyTo
+      });
+      messageId = res.messageId;
+    } catch (e) {
+      error = e instanceof Error ? e.message : String(e);
+    }
+  }
+  const id = deps.newId();
+  const row = {
+    id,
+    groupId: input.group.id,
+    to: decision.to,
+    template: input.template,
+    subject: decision.subject,
+    body: decision.text,
+    transport: decision.transport,
+    redirected: decision.redirected,
+    dedupeKey: input.dedupeKey,
+    sentAt: deps.now(),
+    ...input.applicationId ? { applicationId: input.applicationId } : {},
+    ...messageId ? { messageId } : {},
+    ...error ? { error } : {}
+  };
+  await deps.db.transact([{ t: "update", ns: "emailLog", id, attrs: row }], error ? void 0 : { mutationId: `email:${input.dedupeKey}` });
+  return error ? { sent: false, reason: error } : { sent: true };
+}
+function emailGroupFrom(row) {
+  const str = (v) => typeof v === "string" ? v : void 0;
+  const templates = row.emailTemplates && typeof row.emailTemplates === "object" ? row.emailTemplates : {};
+  return {
+    id: String(row.id),
+    name: String(row.name ?? ""),
+    replyTo: str(row.replyTo) ?? "",
+    debugEmail: str(row.debugEmail),
+    refundPolicyText: str(row.refundPolicyText),
+    commitmentText: str(row.commitmentText),
+    normsText: str(row.normsText),
+    emailTemplates: templates
+  };
+}
+
 // src/worker-routes.ts
+async function provisionApplicant(db, chapter, applicationId, fields) {
+  const email = typeof fields.email === "string" ? fields.email : "";
+  if (!email) return;
+  const s = (v) => typeof v === "string" ? v : void 0;
+  try {
+    await projectApplicant(
+      { crm: chapter.crm, db, now: () => Date.now(), newId: () => crypto.randomUUID() },
+      { applicationId, email, firstName: s(fields.firstName), lastName: s(fields.lastName), phone: s(fields.phone), linkedin: s(fields.linkedin) }
+    );
+  } catch {
+  }
+  try {
+    const secret = await getVaultSecret(db, "clerk_secret_key");
+    if (secret) await createClerkInvitation(secret, { email });
+  } catch {
+  }
+}
+async function notifyAdminOfApplication(db, env, chapterId, applicationId, fields) {
+  try {
+    const groups = (await db.query({ groups: { $: { where: { id: chapterId }, limit: 1 } } })).groups;
+    const group = Array.isArray(groups) ? groups[0] : void 0;
+    if (!group || typeof group.notificationEmail !== "string" || !group.notificationEmail) return;
+    const s = (v) => typeof v === "string" ? v : "";
+    await sendTemplated(
+      { db, envName: env.ODLA_ENV, sender: env.SEND_EMAIL, from: env.EMAIL_FROM, now: () => Date.now(), newId: () => crypto.randomUUID() },
+      {
+        group: emailGroupFrom(group),
+        template: "adminNotification",
+        to: group.notificationEmail,
+        vars: { firstName: s(fields.firstName), lastName: s(fields.lastName), email: s(fields.email), phone: s(fields.phone), state: s(fields.state) },
+        dedupeKey: `apply:${applicationId}:admin`,
+        applicationId
+      }
+    );
+  } catch {
+  }
+}
 async function memberSessionApplication(db, chapterId, email) {
   const apps = (await db.query({ applications: { $: { where: { email }, order: { createdAt: "desc" }, limit: 1 } } })).applications;
   const app = Array.isArray(apps) ? apps[0] : void 0;
@@ -329,6 +492,7 @@ async function memberSessionApplication(db, chapterId, email) {
   const timezone = resolveScheduling(group?.schedulingJson).timezone;
   return memberApplication(app, meeting, timezone);
 }
+var handleHealth = async (_req, url) => url.pathname === "/api/health" ? json({ ok: true }) : null;
 var handleConfig = async (_req, url, env, ctx) => {
   if (url.pathname !== "/api/config") return null;
   try {
@@ -418,13 +582,18 @@ var handleMember = async (req, url, env, ctx) => {
       return json({ error: "invalid JSON body" }, 400);
     }
     const submissionId = typeof parsed.submissionId === "string" ? parsed.submissionId : void 0;
-    const result = await submitApplication(ctx.makeDb(env), chapter, parsed, {
+    const db = ctx.makeDb(env);
+    const result = await submitApplication(db, chapter, parsed, {
       submissionId,
       groupId: chapter.id,
       now: Date.now(),
       newId: () => crypto.randomUUID()
     });
     if (!result.ok) return json({ error: result.error }, 400);
+    if (!result.duplicate) {
+      await notifyAdminOfApplication(db, env, chapter.id, result.id, parsed);
+      await provisionApplicant(db, chapter, result.id, parsed);
+    }
     return json({ id: result.id, duplicate: result.duplicate, status: result.status });
   }
   return null;
@@ -432,6 +601,13 @@ var handleMember = async (req, url, env, ctx) => {
 
 // src/worker-routes-schedule.ts
 var import_calendar = require("@odla-ai/calendar");
+
+// src/pipeline.ts
+function canBook(status, p) {
+  return p.bookableFrom.includes(status);
+}
+
+// src/worker-routes-schedule.ts
 function errCode(err) {
   if (err && typeof err === "object") {
     const code = err.code;
@@ -473,7 +649,7 @@ async function bookSlot(req, env, ctx) {
   const app = await firstRow(db, "applications", { where: { id: applicationId }, limit: 1 });
   if (!app) return json({ error: "not found" }, 404);
   const status = String(app.status ?? "");
-  if (!canBookFrom(status)) return json({ error: `cannot book from status "${status}"` }, 409);
+  if (!canBook(status, ctx.chapter.pipeline)) return json({ error: `cannot book from status "${status}"` }, 409);
   const group = await firstRow(db, "groups", { where: { id: String(app.groupId ?? ctx.chapter.id) }, limit: 1 });
   if (!group) return json({ error: "group not found" }, 500);
   const cfg = resolveScheduling(group.schedulingJson);
@@ -535,6 +711,12 @@ async function bookSlot(req, env, ctx) {
   }
   const appOp = { t: "update", ns: "applications", id: applicationId, attrs: applicationBookingUpdate(status, startAt, htmlLink) };
   await db.transact([meetingOp, appOp]);
+  if (typeof app.email === "string" && app.email) {
+    await sendTemplated(
+      { db, envName: env.ODLA_ENV, sender: env.SEND_EMAIL, from: env.EMAIL_FROM, now: () => Date.now(), newId: () => crypto.randomUUID() },
+      { group: emailGroupFrom(group), template: "prepEmail", to: app.email, vars: { firstName: String(app.firstName ?? "") }, dedupeKey: `prep:${applicationId}`, applicationId }
+    ).catch(() => void 0);
+  }
   return json({ ok: true, startAt, endAt, meetUrl, rescheduled: decision.reschedule });
 }
 var handleSchedule = async (req, url, env, ctx) => {
@@ -770,6 +952,25 @@ async function findApplication(db, event) {
   }
   return void 0;
 }
+async function notifyPaymentConfirmed(db, env, eventId, app) {
+  try {
+    if (typeof app.email !== "string" || !app.email) return;
+    const group = await firstRow2(db, "groups", { where: { id: String(app.groupId ?? "") }, limit: 1 });
+    if (!group) return;
+    await sendTemplated(
+      { db, envName: env.ODLA_ENV, sender: env.SEND_EMAIL, from: env.EMAIL_FROM, now: () => Date.now(), newId: () => crypto.randomUUID() },
+      {
+        group: emailGroupFrom(group),
+        template: "paymentConfirmation",
+        to: app.email,
+        vars: { firstName: typeof app.firstName === "string" ? app.firstName : "" },
+        dedupeKey: `${eventId}:confirm`,
+        applicationId: String(app.id)
+      }
+    );
+  } catch {
+  }
+}
 function webhookPatch(event, status) {
   switch (event.kind) {
     case "first_payment":
@@ -841,6 +1042,7 @@ async function ingestWebhook(req, env, ctx) {
   if (Object.keys(patch).length) {
     await db.transact([{ t: "update", ns: "applications", id: String(app.id), attrs: patch }], { mutationId: webhookMutationId(eventId) });
   }
+  if (event.kind === "first_payment") await notifyPaymentConfirmed(db, env, eventId, app);
   return json({ ok: true });
 }
 async function refundApplication(req, url, env, ctx) {
@@ -877,14 +1079,139 @@ var handlePayments = async (req, url, env, ctx) => {
   return null;
 };
 
+// src/worker-routes-admin.ts
+var import_calendar2 = require("@odla-ai/calendar");
+
+// src/reconcile.ts
+function isReconcilable(meeting, now) {
+  return meeting.status === "scheduled" && Boolean(meeting.googleEventId) && (meeting.startAt ?? 0) > now - 36e5;
+}
+function reconcileMeetings(meetings, events, now) {
+  const byEvent = new Map(events.map((e) => [e.eventId, e]));
+  const decisions = [];
+  for (const m of meetings) {
+    if (!isReconcilable(m, now) || !m.googleEventId) continue;
+    const g = byEvent.get(m.googleEventId);
+    if (!g || g.status === "cancelled") {
+      decisions.push({
+        meetingId: m.id,
+        applicationId: m.applicationId,
+        kind: "cancelled",
+        meetingPatch: { status: "cancelled", drift: "none", adoptedFromGoogleAt: now },
+        applicationPatch: { meetingAt: 0, meetingLink: "" }
+      });
+    } else if (g.startAt !== void 0 && g.startAt !== m.startAt) {
+      const duration = (m.endAt ?? 0) - (m.startAt ?? 0);
+      decisions.push({
+        meetingId: m.id,
+        applicationId: m.applicationId,
+        kind: "moved",
+        meetingPatch: { startAt: g.startAt, endAt: g.endAt ?? g.startAt + duration, drift: "none", adoptedFromGoogleAt: now },
+        applicationPatch: { meetingAt: g.startAt }
+      });
+    }
+  }
+  return decisions;
+}
+
+// src/worker-routes-admin.ts
+async function adminGroup(req, env, ctx, url) {
+  const rawDb = ctx.makeDb(env);
+  const u = await ctx.verifyUser(req, env);
+  if (!u || !await ctx.isAdmin(rawDb, u)) return json({ error: "forbidden" }, 403);
+  const db = rawDb;
+  const groupId = url.searchParams.get("group") ?? ctx.chapter.id;
+  const group = (await db.query({ groups: { $: { where: { id: groupId }, limit: 1 } } })).groups?.[0];
+  if (!group) return json({ error: "not found" }, 404);
+  return { db, group };
+}
+var handleAdminScheduling = async (req, url, env, ctx) => {
+  if (url.pathname !== "/api/admin/scheduling" || req.method !== "GET" && req.method !== "PUT") return null;
+  const got = await adminGroup(req, env, ctx, url);
+  if (got instanceof Response) return got;
+  const { db, group } = got;
+  if (req.method === "GET") {
+    return json({ scheduling: resolveScheduling(group.schedulingJson) });
+  }
+  let body;
+  try {
+    body = JSON.parse(await req.text());
+  } catch {
+    return json({ error: "invalid JSON body" }, 400);
+  }
+  let resolved;
+  try {
+    resolved = resolveScheduling(body);
+  } catch (e) {
+    return json({ error: e instanceof Error ? e.message : "invalid scheduling config" }, 400);
+  }
+  await db.transact([{ t: "update", ns: "groups", id: String(group.id), attrs: { schedulingJson: resolved } }]);
+  return json({ scheduling: resolved });
+};
+async function upcomingEvents(env) {
+  const cal = (0, import_calendar2.initCalendar)({ appId: env.ODLA_APP_ID, env: env.ODLA_ENV, adminToken: env.ODLA_API_KEY, endpoint: env.ODLA_PLATFORM });
+  const res = await cal.availability.upcoming();
+  return res.events.map((e) => ({ eventId: e.eventId, status: e.status, startAt: e.startAt, endAt: e.endAt }));
+}
+function toReconcile(rows) {
+  return rows.map((m) => ({
+    id: String(m.id),
+    applicationId: String(m.applicationId),
+    googleEventId: typeof m.googleEventId === "string" ? m.googleEventId : null,
+    status: String(m.status ?? ""),
+    startAt: typeof m.startAt === "number" ? m.startAt : null,
+    endAt: typeof m.endAt === "number" ? m.endAt : null
+  }));
+}
+var handleAdminMeetings = async (req, url, env, ctx) => {
+  if (req.method !== "GET" || url.pathname !== "/api/admin/meetings") return null;
+  const rawDb = ctx.makeDb(env);
+  const u = await ctx.verifyUser(req, env);
+  if (!u || !await ctx.isAdmin(rawDb, u)) return json({ error: "forbidden" }, 403);
+  const db = rawDb;
+  const query = await db.query({ meetings: { $: { where: { status: "scheduled" }, order: { startAt: "asc" }, limit: 500 } } });
+  const rows = Array.isArray(query.meetings) ? query.meetings : [];
+  let decisions = [];
+  try {
+    decisions = reconcileMeetings(toReconcile(rows), await upcomingEvents(env), Date.now());
+  } catch {
+  }
+  const patched = /* @__PURE__ */ new Map();
+  for (const d of decisions) {
+    const ops = [
+      { t: "update", ns: "meetings", id: d.meetingId, attrs: d.meetingPatch },
+      { t: "update", ns: "applications", id: d.applicationId, attrs: d.applicationPatch }
+    ];
+    try {
+      await db.transact(ops);
+      patched.set(d.meetingId, d.meetingPatch);
+    } catch {
+    }
+  }
+  const meetings = rows.map((m) => ({ ...m, ...patched.get(String(m.id)) ?? {} })).filter((m) => m.status === "scheduled");
+  return json({ meetings, adopted: decisions.length });
+};
+
 // src/worker.ts
-var ROUTES = [handleConfig, handleMe, handleCrm, handleNetworkShared, handleMember, handleSchedule, handlePayments];
+var BUILTIN_ROUTES = [
+  handleHealth,
+  handleConfig,
+  handleMe,
+  handleCrm,
+  handleNetworkShared,
+  handleMember,
+  handleSchedule,
+  handlePayments,
+  handleAdminMeetings,
+  handleAdminScheduling
+];
 function chapterWorker(options) {
   const ctx = createWorkerContext(options);
+  const routes = [...options.routes ?? [], ...BUILTIN_ROUTES];
   return {
     async fetch(req, env) {
       const url = new URL(req.url);
-      for (const route of ROUTES) {
+      for (const route of routes) {
         const res = await route(req, url, env, ctx);
         if (res) return res;
       }