create-svc 0.1.10 → 0.1.12

package/templates/targets/workers/src/index.ts

@@ -0,0 +1,198 @@
+import { Hono } from "hono";
+import { authMiddleware } from "./auth";
+import { createStorage } from "./storage";
+
+type Env = {
+  HYPERDRIVE?: Hyperdrive;
+  AUTH_ENABLED?: string;
+  AUTH_ISSUER?: string;
+  AUTH_AUDIENCE?: string;
+  AUTH_JWKS_URL?: string;
+};
+
+export function createApp() {
+  const app = new Hono<{ Bindings: Env }>();
+
+  app.get("/healthz", (context) => context.json({ status: "ok" }));
+  app.get("/readyz", (context) => context.json({ status: "ok" }));
+  app.get("/", (context) =>
+    context.json({
+      service: "{{SERVICE_NAME}}",
+      domain: "waitlist",
+      apiOrigin: "https://api.{{SERVICE_NAME}}.anmho.com",
+    })
+  );
+
+  app.use("/v1/*", authMiddleware());
+
+  app.post("/v1/waitlist", async (context) => {
+    const body = await context.req.json().catch(() => ({}));
+    const email = String(body.email ?? "").trim().toLowerCase();
+    if (!/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(email)) {
+      return context.json({ error: "valid email is required", code: "invalid_email" }, 400);
+    }
+
+    const result = await createStorage(context.env).joinWaitlist({
+      email,
+      name: body.name ? String(body.name) : null,
+      company: body.company ? String(body.company) : null,
+      source: body.source ? String(body.source) : null,
+    });
+    return context.json(result, result.created ? 201 : 200);
+  });
+
+  app.get("/v1/waitlist", async (context) => {
+    const email = String(context.req.query("email") ?? "").trim().toLowerCase();
+    if (!email) {
+      return context.json({ error: "email is required", code: "missing_email" }, 400);
+    }
+    return context.json({ entry: await createStorage(context.env).getWaitlistEntryByEmail(email) });
+  });
+
+  app.get("/v1/waitlist/:entryId", async (context) => {
+    const entry = await createStorage(context.env).getWaitlistEntry(context.req.param("entryId"));
+    if (!entry) {
+      return context.json({ error: "waitlist entry not found", code: "not_found" }, 404);
+    }
+    return context.json({ entry });
+  });
+
+  app.get("/v1/admin/waitlist", async (context) => {
+    try {
+      const status = context.req.query("status");
+      return context.json({
+        entries: await createStorage(context.env).listWaitlistEntries({
+          status: status ? normalizeStatus(status) : null,
+          limit: parseOptionalNumber(context.req.query("limit")),
+        }),
+      });
+    } catch (error) {
+      return writeError(context, error);
+    }
+  });
+
+  app.get("/v1/admin/waitlist/export", async (context) => {
+    try {
+      const status = context.req.query("status");
+      const entries = await createStorage(context.env).listWaitlistEntries({
+        status: status ? normalizeStatus(status) : null,
+        limit: parseOptionalNumber(context.req.query("limit")),
+      });
+      return new Response(entriesToCsv(entries), {
+        headers: {
+          "Content-Type": "text/csv; charset=utf-8",
+          "Content-Disposition": 'attachment; filename="waitlist.csv"',
+        },
+      });
+    } catch (error) {
+      return writeError(context, error);
+    }
+  });
+
+  app.patch("/v1/admin/waitlist/:entryId", async (context) => {
+    try {
+      const body = await context.req.json().catch(() => ({}));
+      const status = normalizeStatus(String(body.status ?? ""));
+      const entry = await createStorage(context.env).updateWaitlistEntryStatus(context.req.param("entryId"), status);
+      if (!entry) {
+        return context.json({ error: "waitlist entry not found", code: "not_found" }, 404);
+      }
+      return context.json({ entry });
+    } catch (error) {
+      return writeError(context, error);
+    }
+  });
+
+  app.post("/v1/triggers/waitlist", async (context) => {
+    const body = await context.req.json().catch(() => ({}));
+    const trigger = await createStorage(context.env).recordTrigger({
+      type: String(body.type ?? "manual"),
+      entryId: body.entry_id ?? body.entryId ?? null,
+      payload: body,
+    });
+    return context.json({ trigger }, 202);
+  });
+
+  app.post("/webhooks/:provider", async (context) => {
+    const rawBody = await context.req.text();
+    const trigger = await createStorage(context.env).recordTrigger({
+      type: `webhook.${context.req.param("provider")}`,
+      entryId: null,
+      payload: {
+        headers: Object.fromEntries(context.req.raw.headers),
+        rawBody,
+      },
+    });
+    return context.json({ trigger }, 202);
+  });
+
+  app.get("/webhooks/:provider/health", (context) => context.json({ status: "ok", provider: context.req.param("provider") }));
+  return app;
+}
+
+const app = createApp();
+
+class ValidationError extends Error {
+  constructor(
+    readonly code: string,
+    message: string
+  ) {
+    super(message);
+  }
+}
+
+function normalizeStatus(value: string) {
+  const status = value.trim().toLowerCase();
+  if (status === "joined" || status === "invited" || status === "converted" || status === "archived") {
+    return status;
+  }
+  throw new ValidationError("invalid_status", "status must be one of joined, invited, converted, archived");
+}
+
+function writeError(context: any, error: unknown) {
+  if (error instanceof ValidationError) {
+    return context.json({ error: error.message, code: error.code }, 400);
+  }
+  console.error(error);
+  return context.json({ error: "internal server error", code: "internal" }, 500);
+}
+
+function parseOptionalNumber(value: string | undefined) {
+  return value ? Number(value) : null;
+}
+
+function entriesToCsv(entries: Awaited<ReturnType<ReturnType<typeof createStorage>["listWaitlistEntries"]>>) {
+  const headers = ["id", "email", "name", "company", "source", "status", "created_at", "updated_at"];
+  return [
+    headers.join(","),
+    ...entries.map((entry) =>
+      [
+        entry.id,
+        entry.email,
+        entry.name ?? "",
+        entry.company ?? "",
+        entry.source ?? "",
+        entry.status,
+        entry.created_at,
+        entry.updated_at,
+      ]
+        .map(csvCell)
+        .join(",")
+    ),
+  ].join("\n");
+}
+
+function csvCell(value: string) {
+  return `"${value.replaceAll('"', '""')}"`;
+}
+
+export default {
+  fetch: app.fetch,
+  async scheduled(_event: ScheduledEvent, env: Env, context: ExecutionContext) {
+    context.waitUntil(
+      createStorage(env).claimQueuedTriggers(10).then((triggers) => {
+        console.log("processed waitlist triggers", triggers.length);
+      })
+    );
+  },
+};

package/templates/targets/workers/src/storage.ts

@@ -0,0 +1,370 @@
+import { Client } from "pg";
+
+export type WaitlistEntry = {
+  id: string;
+  email: string;
+  name: string | null;
+  company: string | null;
+  source: string | null;
+  status: string;
+  created_at: string;
+  updated_at: string;
+};
+
+export type WaitlistTrigger = {
+  id: string;
+  type: string;
+  entry_id: string | null;
+  status: string;
+  payload_json: string;
+  created_at: string;
+  processed_at: string | null;
+};
+
+export type WaitlistStorage = {
+  joinWaitlist(input: {
+    email: string;
+    name: string | null;
+    company: string | null;
+    source: string | null;
+  }): Promise<{ entry: WaitlistEntry; created: boolean }>;
+  getWaitlistEntryByEmail(email: string): Promise<WaitlistEntry | null>;
+  getWaitlistEntry(entryId: string): Promise<WaitlistEntry | null>;
+  listWaitlistEntries(input?: { status?: string | null; limit?: number | null }): Promise<WaitlistEntry[]>;
+  updateWaitlistEntryStatus(entryId: string, status: string): Promise<WaitlistEntry | null>;
+  recordTrigger(input: {
+    type: string;
+    entryId: string | null;
+    payload: unknown;
+  }): Promise<WaitlistTrigger>;
+  claimQueuedTriggers(limit: number): Promise<WaitlistTrigger[]>;
+};
+
+type Env = {
+  HYPERDRIVE?: Hyperdrive;
+};
+
+const memoryStorage = createMemoryStorage();
+
+export function createStorage(env: Env = {}): WaitlistStorage {
+  if (env.HYPERDRIVE?.connectionString) {
+    return createPostgresStorage(env.HYPERDRIVE.connectionString);
+  }
+  return memoryStorage;
+}
+
+function createPostgresStorage(connectionString: string): WaitlistStorage {
+  return {
+    async joinWaitlist(input) {
+      const client = new Client({ connectionString });
+      await client.connect();
+      try {
+        await ensureSchema(client);
+        const now = new Date().toISOString();
+        const result = await client.query<WaitlistEntry>(
+          `
+insert into waitlist_entries (id, email, name, company, source, status, created_at, updated_at)
+values ($1, $2, $3, $4, $5, 'joined', $6, $6)
+on conflict (email) do update
+set
+  name = coalesce(excluded.name, waitlist_entries.name),
+  company = coalesce(excluded.company, waitlist_entries.company),
+  source = coalesce(excluded.source, waitlist_entries.source),
+  updated_at = excluded.updated_at
+returning id, email, name, company, source, status, created_at, updated_at, (xmax = 0) as created
+`,
+          [crypto.randomUUID(), input.email, input.name, input.company, input.source, now]
+        );
+        const row = result.rows[0] as WaitlistEntry & { created?: boolean };
+        return { entry: normalizeEntry(row), created: Boolean(row.created) };
+      } finally {
+        await client.end();
+      }
+    },
+
+    async getWaitlistEntryByEmail(email) {
+      const client = new Client({ connectionString });
+      await client.connect();
+      try {
+        await ensureSchema(client);
+        const result = await client.query<WaitlistEntry>(
+          "select id, email, name, company, source, status, created_at, updated_at from waitlist_entries where email = $1",
+          [email]
+        );
+        return result.rows[0] ? normalizeEntry(result.rows[0]) : null;
+      } finally {
+        await client.end();
+      }
+    },
+
+    async getWaitlistEntry(entryId) {
+      const client = new Client({ connectionString });
+      await client.connect();
+      try {
+        await ensureSchema(client);
+        const result = await client.query<WaitlistEntry>(
+          "select id, email, name, company, source, status, created_at, updated_at from waitlist_entries where id = $1",
+          [entryId]
+        );
+        return result.rows[0] ? normalizeEntry(result.rows[0]) : null;
+      } finally {
+        await client.end();
+      }
+    },
+
+    async listWaitlistEntries(input = {}) {
+      const client = new Client({ connectionString });
+      await client.connect();
+      try {
+        await ensureSchema(client);
+        const limit = clampLimit(input.limit);
+        const result = input.status
+          ? await client.query<WaitlistEntry>(
+              `
+select id, email, name, company, source, status, created_at, updated_at
+from waitlist_entries
+where status = $1
+order by created_at desc
+limit $2
+`,
+              [input.status, limit]
+            )
+          : await client.query<WaitlistEntry>(
+              `
+select id, email, name, company, source, status, created_at, updated_at
+from waitlist_entries
+order by created_at desc
+limit $1
+`,
+              [limit]
+            );
+        return result.rows.map(normalizeEntry);
+      } finally {
+        await client.end();
+      }
+    },
+
+    async updateWaitlistEntryStatus(entryId, status) {
+      const client = new Client({ connectionString });
+      await client.connect();
+      try {
+        await ensureSchema(client);
+        const result = await client.query<WaitlistEntry>(
+          `
+update waitlist_entries
+set status = $2, updated_at = now()
+where id = $1
+returning id, email, name, company, source, status, created_at, updated_at
+`,
+          [entryId, status]
+        );
+        return result.rows[0] ? normalizeEntry(result.rows[0]) : null;
+      } finally {
+        await client.end();
+      }
+    },
+
+    async recordTrigger(input) {
+      const client = new Client({ connectionString });
+      await client.connect();
+      try {
+        await ensureSchema(client);
+        const now = new Date().toISOString();
+        const result = await client.query<WaitlistTrigger>(
+          `
+insert into waitlist_triggers (id, type, entry_id, status, payload_json, created_at)
+values ($1, $2, $3, 'queued', $4, $5)
+returning id, type, entry_id, status, payload_json, created_at, processed_at
+`,
+          [crypto.randomUUID(), input.type, input.entryId, JSON.stringify(input.payload ?? {}), now]
+        );
+        return normalizeTrigger(result.rows[0]);
+      } finally {
+        await client.end();
+      }
+    },
+
+    async claimQueuedTriggers(limit) {
+      const client = new Client({ connectionString });
+      await client.connect();
+      try {
+        await ensureSchema(client);
+        const result = await client.query<WaitlistTrigger>(
+          `
+update waitlist_triggers
+set status = 'processed', processed_at = now()
+where id in (
+  select id
+  from waitlist_triggers
+  where status = 'queued'
+  order by created_at asc
+  limit $1
+  for update skip locked
+)
+returning id, type, entry_id, status, payload_json, created_at, processed_at
+`,
+          [limit]
+        );
+        return result.rows.map(normalizeTrigger);
+      } finally {
+        await client.end();
+      }
+    },
+  };
+}
+
+async function ensureSchema(client: Client) {
+  await client.query(`
+create table if not exists waitlist_entries (
+  id text primary key,
+  email text not null unique,
+  name text,
+  company text,
+  source text,
+  status text not null default 'joined',
+  created_at timestamptz not null default now(),
+  updated_at timestamptz not null default now()
+);
+
+create table if not exists waitlist_triggers (
+  id text primary key,
+  type text not null,
+  entry_id text references waitlist_entries(id) on delete set null,
+  status text not null default 'queued',
+  payload_json text not null default '{}',
+  created_at timestamptz not null default now(),
+  processed_at timestamptz
+);
+
+create index if not exists waitlist_triggers_status_created_idx
+  on waitlist_triggers (status, created_at);
+`);
+}
+
+function createMemoryStorage(): WaitlistStorage {
+  const entries = new Map<string, WaitlistEntry>();
+  const entriesByEmail = new Map<string, string>();
+  const triggers = new Map<string, WaitlistTrigger>();
+
+  return {
+    async joinWaitlist(input) {
+      const existingId = entriesByEmail.get(input.email);
+      if (existingId) {
+        const existing = entries.get(existingId)!;
+        const updated = {
+          ...existing,
+          name: input.name ?? existing.name,
+          company: input.company ?? existing.company,
+          source: input.source ?? existing.source,
+          updated_at: new Date().toISOString(),
+        };
+        entries.set(existing.id, updated);
+        return { entry: updated, created: false };
+      }
+
+      const now = new Date().toISOString();
+      const entry = {
+        id: crypto.randomUUID(),
+        email: input.email,
+        name: input.name,
+        company: input.company,
+        source: input.source,
+        status: "joined",
+        created_at: now,
+        updated_at: now,
+      };
+      entries.set(entry.id, entry);
+      entriesByEmail.set(entry.email, entry.id);
+      return { entry, created: true };
+    },
+
+    async getWaitlistEntryByEmail(email) {
+      const id = entriesByEmail.get(email);
+      return id ? entries.get(id) ?? null : null;
+    },
+
+    async getWaitlistEntry(entryId) {
+      return entries.get(entryId) ?? null;
+    },
+
+    async listWaitlistEntries(input = {}) {
+      return [...entries.values()]
+        .filter((entry) => !input.status || entry.status === input.status)
+        .sort((left, right) => right.created_at.localeCompare(left.created_at))
+        .slice(0, clampLimit(input.limit));
+    },
+
+    async updateWaitlistEntryStatus(entryId, status) {
+      const entry = entries.get(entryId);
+      if (!entry) {
+        return null;
+      }
+      const updated = {
+        ...entry,
+        status,
+        updated_at: new Date().toISOString(),
+      };
+      entries.set(entry.id, updated);
+      return updated;
+    },
+
+    async recordTrigger(input) {
+      const now = new Date().toISOString();
+      const trigger = {
+        id: crypto.randomUUID(),
+        type: input.type,
+        entry_id: input.entryId,
+        status: "queued",
+        payload_json: JSON.stringify(input.payload ?? {}),
+        created_at: now,
+        processed_at: null,
+      };
+      triggers.set(trigger.id, trigger);
+      return trigger;
+    },
+
+    async claimQueuedTriggers(limit) {
+      const claimed = [...triggers.values()]
+        .filter((trigger) => trigger.status === "queued")
+        .sort((left, right) => left.created_at.localeCompare(right.created_at))
+        .slice(0, limit)
+        .map((trigger) => ({
+          ...trigger,
+          status: "processed",
+          processed_at: new Date().toISOString(),
+        }));
+
+      for (const trigger of claimed) {
+        triggers.set(trigger.id, trigger);
+      }
+      return claimed;
+    },
+  };
+}
+
+function normalizeEntry(row: WaitlistEntry): WaitlistEntry {
+  return {
+    ...row,
+    created_at: normalizeDate(row.created_at),
+    updated_at: normalizeDate(row.updated_at),
+  };
+}
+
+function normalizeTrigger(row: WaitlistTrigger): WaitlistTrigger {
+  return {
+    ...row,
+    created_at: normalizeDate(row.created_at),
+    processed_at: row.processed_at ? normalizeDate(row.processed_at) : null,
+  };
+}
+
+function clampLimit(value: number | null | undefined) {
+  if (!value || !Number.isFinite(value)) {
+    return 100;
+  }
+  return Math.min(Math.max(Math.trunc(value), 1), 500);
+}
+
+function normalizeDate(value: string | Date) {
+  return value instanceof Date ? value.toISOString() : new Date(value).toISOString();
+}

package/templates/targets/workers/test/app.test.ts

@@ -0,0 +1,108 @@
+import { expect, test } from "bun:test";
+import { createApp } from "../src/index";
+
+type JoinResponse = {
+  entry: {
+    id: string;
+    email: string;
+    name?: string | null;
+    source?: string | null;
+    status?: string;
+  };
+  created: boolean;
+};
+
+test("health endpoint returns ok", async () => {
+  const response = await createApp().request("/healthz");
+  expect(response.status).toBe(200);
+  await expect(response.json()).resolves.toMatchObject({ status: "ok" });
+});
+
+test("waitlist join persists an idempotent entry", async () => {
+  const app = createApp();
+  const response = await app.request("/v1/waitlist", {
+    method: "POST",
+    body: JSON.stringify({ email: "Workers@Example.com", name: "Workers Example" }),
+    headers: { "content-type": "application/json" },
+  });
+
+  expect(response.status).toBe(201);
+  const created = (await response.json()) as JoinResponse;
+  expect(created).toMatchObject({
+    entry: {
+      email: "workers@example.com",
+      name: "Workers Example",
+      status: "joined",
+    },
+    created: true,
+  });
+
+  const duplicate = await app.request("/v1/waitlist", {
+    method: "POST",
+    body: JSON.stringify({ email: "workers@example.com", source: "repeat" }),
+    headers: { "content-type": "application/json" },
+  });
+  expect(duplicate.status).toBe(200);
+  await expect(duplicate.json()).resolves.toMatchObject({
+    entry: {
+      id: created.entry.id,
+      email: "workers@example.com",
+      source: "repeat",
+    },
+    created: false,
+  });
+
+  const lookup = await app.request("/v1/waitlist?email=workers@example.com");
+  expect(lookup.status).toBe(200);
+  await expect(lookup.json()).resolves.toMatchObject({
+    entry: {
+      id: created.entry.id,
+      email: "workers@example.com",
+    },
+  });
+
+  const updated = await app.request(`/v1/admin/waitlist/${created.entry.id}`, {
+    method: "PATCH",
+    body: JSON.stringify({ status: "invited" }),
+    headers: { "content-type": "application/json" },
+  });
+  expect(updated.status).toBe(200);
+  await expect(updated.json()).resolves.toMatchObject({
+    entry: {
+      id: created.entry.id,
+      status: "invited",
+    },
+  });
+
+  const list = await app.request("/v1/admin/waitlist?status=invited");
+  expect(list.status).toBe(200);
+  await expect(list.json()).resolves.toMatchObject({
+    entries: [
+      {
+        id: created.entry.id,
+        email: "workers@example.com",
+      },
+    ],
+  });
+
+  const exported = await app.request("/v1/admin/waitlist/export?status=invited");
+  expect(exported.status).toBe(200);
+  expect(exported.headers.get("content-type")).toContain("text/csv");
+  expect(await exported.text()).toContain("workers@example.com");
+});
+
+test("waitlist trigger is queued for cron processing", async () => {
+  const response = await createApp().request("/v1/triggers/waitlist", {
+    method: "POST",
+    body: JSON.stringify({ type: "cron.digest" }),
+    headers: { "content-type": "application/json" },
+  });
+
+  expect(response.status).toBe(202);
+  await expect(response.json()).resolves.toMatchObject({
+    trigger: {
+      type: "cron.digest",
+      status: "queued",
+    },
+  });
+});

package/templates/targets/workers/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "types": ["bun", "@cloudflare/workers-types"]
+  },
+  "include": ["src/**/*.ts", "test/**/*.ts", "scripts/**/*.ts"]
+}

package/templates/targets/workers/wrangler.toml

@@ -0,0 +1,24 @@
+name = "{{SERVICE_ID}}"
+main = "src/index.ts"
+compatibility_date = "2026-05-14"
+compatibility_flags = ["nodejs_compat"]
+
+[observability]
+enabled = true
+
+[vars]
+AUTH_ENABLED = "true"
+AUTH_ISSUER = "{{AUTH_ISSUER}}"
+AUTH_AUDIENCE = "{{AUTH_AUDIENCE}}"
+AUTH_JWKS_URL = "{{AUTH_JWKS_URL}}"
+
+[triggers]
+crons = ["*/15 * * * *"]
+
+[[routes]]
+pattern = "{{API_HOSTNAME}}/*"
+custom_domain = true
+
+[[hyperdrive]]
+binding = "HYPERDRIVE"
+id = ""