@codaijs/keel 0.2.3 → 0.2.4

package/sails/push-notifications/files/backend/routes/notifications.ts

@@ -1,153 +1,153 @@
-import { Router, type Request, type Response } from "express";
-import { eq, and } from "drizzle-orm";
-import { db } from "../db/index.js";
-import { pushTokens } from "../db/schema/notifications.js";
-import {
-  sendPushNotification,
-  sendMultiplePushNotifications,
-} from "../services/notifications.js";
-import { requireAuth } from "../middleware/auth.js";
-
-export const notificationsRouter = Router();
-
-// ---------------------------------------------------------------------------
-// POST /register — Register a device push token
-// ---------------------------------------------------------------------------
-
-notificationsRouter.post(
-  "/register",
-  requireAuth,
-  async (req: Request, res: Response) => {
-    try {
-      const { token, platform } = req.body;
-
-      if (!token || typeof token !== "string") {
-        return res.status(400).json({ error: "token is required" });
-      }
-
-      const userId = req.user!.id;
-
-      // Check if this token is already registered for this user
-      const existing = await db.query.pushTokens.findFirst({
-        where: and(
-          eq(pushTokens.userId, userId),
-          eq(pushTokens.token, token),
-        ),
-      });
-
-      if (existing) {
-        return res.json({ message: "Token already registered", id: existing.id });
-      }
-
-      // Insert the new token
-      const [inserted] = await db
-        .insert(pushTokens)
-        .values({
-          userId,
-          token,
-          platform: platform ?? null,
-        })
-        .returning({ id: pushTokens.id });
-
-      return res.status(201).json({ message: "Token registered", id: inserted.id });
-    } catch (error) {
-      console.error("Error registering push token:", error);
-      return res.status(500).json({ error: "Failed to register push token" });
-    }
-  },
-);
-
-// ---------------------------------------------------------------------------
-// DELETE /unregister — Remove a device push token
-// ---------------------------------------------------------------------------
-
-notificationsRouter.delete(
-  "/unregister",
-  requireAuth,
-  async (req: Request, res: Response) => {
-    try {
-      const { token } = req.body;
-
-      if (!token || typeof token !== "string") {
-        return res.status(400).json({ error: "token is required" });
-      }
-
-      const userId = req.user!.id;
-
-      await db
-        .delete(pushTokens)
-        .where(
-          and(
-            eq(pushTokens.userId, userId),
-            eq(pushTokens.token, token),
-          ),
-        );
-
-      return res.json({ message: "Token unregistered" });
-    } catch (error) {
-      console.error("Error unregistering push token:", error);
-      return res.status(500).json({ error: "Failed to unregister push token" });
-    }
-  },
-);
-
-// ---------------------------------------------------------------------------
-// POST /send — Send a notification to a user (admin/internal use)
-// ---------------------------------------------------------------------------
-
-notificationsRouter.post(
-  "/send",
-  requireAuth,
-  async (req: Request, res: Response) => {
-    try {
-      const { userId, title, body, data } = req.body;
-
-      if (!userId || typeof userId !== "string") {
-        return res.status(400).json({ error: "userId is required" });
-      }
-      if (!title || typeof title !== "string") {
-        return res.status(400).json({ error: "title is required" });
-      }
-      if (!body || typeof body !== "string") {
-        return res.status(400).json({ error: "body is required" });
-      }
-
-      // Fetch all tokens for the target user
-      const tokens = await db.query.pushTokens.findMany({
-        where: eq(pushTokens.userId, userId),
-      });
-
-      if (tokens.length === 0) {
-        return res.status(404).json({ error: "No push tokens found for user" });
-      }
-
-      const tokenStrings = tokens.map((t) => t.token);
-
-      if (tokenStrings.length === 1) {
-        const messageId = await sendPushNotification(
-          tokenStrings[0],
-          title,
-          body,
-          data,
-        );
-        return res.json({ message: "Notification sent", messageId });
-      }
-
-      const result = await sendMultiplePushNotifications(
-        tokenStrings,
-        title,
-        body,
-        data,
-      );
-
-      return res.json({
-        message: "Notifications sent",
-        successCount: result.successCount,
-        failureCount: result.failureCount,
-      });
-    } catch (error) {
-      console.error("Error sending push notification:", error);
-      return res.status(500).json({ error: "Failed to send notification" });
-    }
-  },
-);
+import { Router, type Request, type Response } from "express";
+import { eq, and } from "drizzle-orm";
+import { db } from "../db/index.js";
+import { pushTokens } from "../db/schema/notifications.js";
+import {
+  sendPushNotification,
+  sendMultiplePushNotifications,
+} from "../services/notifications.js";
+import { requireAuth } from "../middleware/auth.js";
+
+export const notificationsRouter = Router();
+
+// ---------------------------------------------------------------------------
+// POST /register — Register a device push token
+// ---------------------------------------------------------------------------
+
+notificationsRouter.post(
+  "/register",
+  requireAuth,
+  async (req: Request, res: Response) => {
+    try {
+      const { token, platform } = req.body;
+
+      if (!token || typeof token !== "string") {
+        return res.status(400).json({ error: "token is required" });
+      }
+
+      const userId = req.user!.id;
+
+      // Check if this token is already registered for this user
+      const existing = await db.query.pushTokens.findFirst({
+        where: and(
+          eq(pushTokens.userId, userId),
+          eq(pushTokens.token, token),
+        ),
+      });
+
+      if (existing) {
+        return res.json({ message: "Token already registered", id: existing.id });
+      }
+
+      // Insert the new token
+      const [inserted] = await db
+        .insert(pushTokens)
+        .values({
+          userId,
+          token,
+          platform: platform ?? null,
+        })
+        .returning({ id: pushTokens.id });
+
+      return res.status(201).json({ message: "Token registered", id: inserted.id });
+    } catch (error) {
+      console.error("Error registering push token:", error);
+      return res.status(500).json({ error: "Failed to register push token" });
+    }
+  },
+);
+
+// ---------------------------------------------------------------------------
+// DELETE /unregister — Remove a device push token
+// ---------------------------------------------------------------------------
+
+notificationsRouter.delete(
+  "/unregister",
+  requireAuth,
+  async (req: Request, res: Response) => {
+    try {
+      const { token } = req.body;
+
+      if (!token || typeof token !== "string") {
+        return res.status(400).json({ error: "token is required" });
+      }
+
+      const userId = req.user!.id;
+
+      await db
+        .delete(pushTokens)
+        .where(
+          and(
+            eq(pushTokens.userId, userId),
+            eq(pushTokens.token, token),
+          ),
+        );
+
+      return res.json({ message: "Token unregistered" });
+    } catch (error) {
+      console.error("Error unregistering push token:", error);
+      return res.status(500).json({ error: "Failed to unregister push token" });
+    }
+  },
+);
+
+// ---------------------------------------------------------------------------
+// POST /send — Send a notification to a user (admin/internal use)
+// ---------------------------------------------------------------------------
+
+notificationsRouter.post(
+  "/send",
+  requireAuth,
+  async (req: Request, res: Response) => {
+    try {
+      const { userId, title, body, data } = req.body;
+
+      if (!userId || typeof userId !== "string") {
+        return res.status(400).json({ error: "userId is required" });
+      }
+      if (!title || typeof title !== "string") {
+        return res.status(400).json({ error: "title is required" });
+      }
+      if (!body || typeof body !== "string") {
+        return res.status(400).json({ error: "body is required" });
+      }
+
+      // Fetch all tokens for the target user
+      const tokens = await db.query.pushTokens.findMany({
+        where: eq(pushTokens.userId, userId),
+      });
+
+      if (tokens.length === 0) {
+        return res.status(404).json({ error: "No push tokens found for user" });
+      }
+
+      const tokenStrings = tokens.map((t) => t.token);
+
+      if (tokenStrings.length === 1) {
+        const messageId = await sendPushNotification(
+          tokenStrings[0],
+          title,
+          body,
+          data,
+        );
+        return res.json({ message: "Notification sent", messageId });
+      }
+
+      const result = await sendMultiplePushNotifications(
+        tokenStrings,
+        title,
+        body,
+        data,
+      );
+
+      return res.json({
+        message: "Notifications sent",
+        successCount: result.successCount,
+        failureCount: result.failureCount,
+      });
+    } catch (error) {
+      console.error("Error sending push notification:", error);
+      return res.status(500).json({ error: "Failed to send notification" });
+    }
+  },
+);

package/sails/push-notifications/files/backend/schema/notifications.ts

@@ -1,31 +1,31 @@
-import { pgTable, text, varchar, timestamp } from "drizzle-orm/pg-core";
-import { relations } from "drizzle-orm";
-import { users } from "./users.js";
-
-/**
- * Push notification device tokens table.
- *
- * Stores FCM device tokens for each user. A user can have multiple tokens
- * (one per device). Tokens are registered when the user grants push permission
- * on a native device and removed on logout or token invalidation.
- */
-export const pushTokens = pgTable("push_tokens", {
-  id: text("id")
-    .primaryKey()
-    .$defaultFn(() => crypto.randomUUID()),
-  userId: text("user_id")
-    .notNull()
-    .references(() => users.id, { onDelete: "cascade" }),
-  token: text("token").notNull(),
-  platform: varchar("platform", { length: 20 }),
-  createdAt: timestamp("created_at", { withTimezone: true })
-    .notNull()
-    .defaultNow(),
-});
-
-export const pushTokensRelations = relations(pushTokens, ({ one }) => ({
-  user: one(users, {
-    fields: [pushTokens.userId],
-    references: [users.id],
-  }),
-}));
+import { pgTable, text, varchar, timestamp } from "drizzle-orm/pg-core";
+import { relations } from "drizzle-orm";
+import { users } from "./users.js";
+
+/**
+ * Push notification device tokens table.
+ *
+ * Stores FCM device tokens for each user. A user can have multiple tokens
+ * (one per device). Tokens are registered when the user grants push permission
+ * on a native device and removed on logout or token invalidation.
+ */
+export const pushTokens = pgTable("push_tokens", {
+  id: text("id")
+    .primaryKey()
+    .$defaultFn(() => crypto.randomUUID()),
+  userId: text("user_id")
+    .notNull()
+    .references(() => users.id, { onDelete: "cascade" }),
+  token: text("token").notNull(),
+  platform: varchar("platform", { length: 20 }),
+  createdAt: timestamp("created_at", { withTimezone: true })
+    .notNull()
+    .defaultNow(),
+});
+
+export const pushTokensRelations = relations(pushTokens, ({ one }) => ({
+  user: one(users, {
+    fields: [pushTokens.userId],
+    references: [users.id],
+  }),
+}));

package/sails/push-notifications/files/backend/services/notifications.ts

@@ -1,117 +1,117 @@
-import admin from "firebase-admin";
-import { env } from "../env.js";
-
-// ---------------------------------------------------------------------------
-// Firebase Admin initialization
-// ---------------------------------------------------------------------------
-
-if (!admin.apps.length) {
-  admin.initializeApp({
-    credential: admin.credential.cert({
-      projectId: env.FIREBASE_PROJECT_ID,
-      privateKey: env.FIREBASE_PRIVATE_KEY.replace(/\\n/g, "\n"),
-      clientEmail: env.FIREBASE_CLIENT_EMAIL,
-    }),
-  });
-}
-
-const messaging = admin.messaging();
-
-// ---------------------------------------------------------------------------
-// Send a push notification to a single device
-// ---------------------------------------------------------------------------
-
-/**
- * Send a push notification to a single device token.
- *
- * @param token  - The FCM device token
- * @param title  - Notification title
- * @param body   - Notification body text
- * @param data   - Optional key-value data payload (for deep linking, etc.)
- * @returns The message ID from Firebase
- */
-export async function sendPushNotification(
-  token: string,
-  title: string,
-  body: string,
-  data?: Record<string, string>,
-): Promise<string> {
-  const message: admin.messaging.Message = {
-    token,
-    notification: {
-      title,
-      body,
-    },
-    data,
-    android: {
-      priority: "high",
-      notification: {
-        sound: "default",
-        channelId: "default",
-      },
-    },
-    apns: {
-      payload: {
-        aps: {
-          sound: "default",
-          badge: 1,
-        },
-      },
-    },
-  };
-
-  return messaging.send(message);
-}
-
-// ---------------------------------------------------------------------------
-// Send push notifications to multiple devices
-// ---------------------------------------------------------------------------
-
-/**
- * Send a push notification to multiple device tokens.
- *
- * Uses `sendEachForMulticast` to handle per-token delivery. Returns the
- * batch response so callers can check individual success/failure.
- *
- * @param tokens - Array of FCM device tokens
- * @param title  - Notification title
- * @param body   - Notification body text
- * @param data   - Optional key-value data payload
- * @returns The batch response from Firebase
- */
-export async function sendMultiplePushNotifications(
-  tokens: string[],
-  title: string,
-  body: string,
-  data?: Record<string, string>,
-): Promise<admin.messaging.BatchResponse> {
-  if (tokens.length === 0) {
-    return { responses: [], successCount: 0, failureCount: 0 };
-  }
-
-  const message: admin.messaging.MulticastMessage = {
-    tokens,
-    notification: {
-      title,
-      body,
-    },
-    data,
-    android: {
-      priority: "high",
-      notification: {
-        sound: "default",
-        channelId: "default",
-      },
-    },
-    apns: {
-      payload: {
-        aps: {
-          sound: "default",
-          badge: 1,
-        },
-      },
-    },
-  };
-
-  return messaging.sendEachForMulticast(message);
-}
+import admin from "firebase-admin";
+import { env } from "../env.js";
+
+// ---------------------------------------------------------------------------
+// Firebase Admin initialization
+// ---------------------------------------------------------------------------
+
+if (!admin.apps.length) {
+  admin.initializeApp({
+    credential: admin.credential.cert({
+      projectId: env.FIREBASE_PROJECT_ID,
+      privateKey: env.FIREBASE_PRIVATE_KEY.replace(/\\n/g, "\n"),
+      clientEmail: env.FIREBASE_CLIENT_EMAIL,
+    }),
+  });
+}
+
+const messaging = admin.messaging();
+
+// ---------------------------------------------------------------------------
+// Send a push notification to a single device
+// ---------------------------------------------------------------------------
+
+/**
+ * Send a push notification to a single device token.
+ *
+ * @param token  - The FCM device token
+ * @param title  - Notification title
+ * @param body   - Notification body text
+ * @param data   - Optional key-value data payload (for deep linking, etc.)
+ * @returns The message ID from Firebase
+ */
+export async function sendPushNotification(
+  token: string,
+  title: string,
+  body: string,
+  data?: Record<string, string>,
+): Promise<string> {
+  const message: admin.messaging.Message = {
+    token,
+    notification: {
+      title,
+      body,
+    },
+    data,
+    android: {
+      priority: "high",
+      notification: {
+        sound: "default",
+        channelId: "default",
+      },
+    },
+    apns: {
+      payload: {
+        aps: {
+          sound: "default",
+          badge: 1,
+        },
+      },
+    },
+  };
+
+  return messaging.send(message);
+}
+
+// ---------------------------------------------------------------------------
+// Send push notifications to multiple devices
+// ---------------------------------------------------------------------------
+
+/**
+ * Send a push notification to multiple device tokens.
+ *
+ * Uses `sendEachForMulticast` to handle per-token delivery. Returns the
+ * batch response so callers can check individual success/failure.
+ *
+ * @param tokens - Array of FCM device tokens
+ * @param title  - Notification title
+ * @param body   - Notification body text
+ * @param data   - Optional key-value data payload
+ * @returns The batch response from Firebase
+ */
+export async function sendMultiplePushNotifications(
+  tokens: string[],
+  title: string,
+  body: string,
+  data?: Record<string, string>,
+): Promise<admin.messaging.BatchResponse> {
+  if (tokens.length === 0) {
+    return { responses: [], successCount: 0, failureCount: 0 };
+  }
+
+  const message: admin.messaging.MulticastMessage = {
+    tokens,
+    notification: {
+      title,
+      body,
+    },
+    data,
+    android: {
+      priority: "high",
+      notification: {
+        sound: "default",
+        channelId: "default",
+      },
+    },
+    apns: {
+      payload: {
+        aps: {
+          sound: "default",
+          badge: 1,
+        },
+      },
+    },
+  };
+
+  return messaging.sendEachForMulticast(message);
+}

package/sails/push-notifications/files/frontend/components/PushNotificationInit.tsx

@@ -1,12 +1,12 @@
-import { usePushNotifications } from "@/hooks/usePushNotifications.js";
-
-/**
- * Invisible component that initializes push notification registration.
- *
- * Place this inside Layout.tsx so that push notifications are set up as soon
- * as the app mounts on a native device. Renders nothing visible.
- */
-export function PushNotificationInit() {
-  usePushNotifications();
-  return null;
-}
+import { usePushNotifications } from "@/hooks/usePushNotifications.js";
+
+/**
+ * Invisible component that initializes push notification registration.
+ *
+ * Place this inside Layout.tsx so that push notifications are set up as soon
+ * as the app mounts on a native device. Renders nothing visible.
+ */
+export function PushNotificationInit() {
+  usePushNotifications();
+  return null;
+}