@iann29/rastro 0.1.0-alpha.0 → 0.1.0-alpha.2

package/src/component/goals.ts

@@ -62,10 +62,25 @@ export const upsert = mutation({
     if (args.goalId && existingByKey && existingByKey._id !== args.goalId) {
       fail("CONFLICT", "another goal already uses this key");
     }
+    const goals = await ctx.db
+      .query("goals")
+      .withIndex("by_siteId", (range) => range.eq("siteId", args.siteId))
+      .take(MAX_GOALS_PER_SITE + 1);
     const now = Date.now();
     if (goalId) {
       const goal = await ctx.db.get("goals", goalId);
       if (!goal || goal.siteId !== args.siteId) fail("NOT_FOUND", "goal not found");
+      if (
+        (args.active ?? goal.active) &&
+        goals.some((candidate) =>
+          candidate._id !== goalId &&
+          candidate.active &&
+          candidate.matchType === args.matchType &&
+          candidate.matchValue === matchValue
+        )
+      ) {
+        fail("CONFLICT", "another active goal already uses this matcher");
+      }
       await ctx.db.patch("goals", goalId, {
         key,
         name,
@@ -78,10 +93,16 @@ export const upsert = mutation({
       return goalId;
     }
 
-    const goals = await ctx.db
-      .query("goals")
-      .withIndex("by_siteId", (range) => range.eq("siteId", args.siteId))
-      .take(MAX_GOALS_PER_SITE + 1);
+    if (
+      (args.active ?? true) &&
+      goals.some((candidate) =>
+        candidate.active &&
+        candidate.matchType === args.matchType &&
+        candidate.matchValue === matchValue
+      )
+    ) {
+      fail("CONFLICT", "another active goal already uses this matcher");
+    }
     if (goals.length >= MAX_GOALS_PER_SITE) {
       fail("LIMIT_EXCEEDED", "goal limit reached", { limit: MAX_GOALS_PER_SITE });
     }

package/src/component/http.ts

@@ -24,16 +24,29 @@ http.route({
   handler: httpAction(async (ctx, request) => {
     const origin = request.headers.get("origin");
     if (!origin) return json({ error: { code: "ORIGIN_REQUIRED" } }, 400);
-    const bytes = await request.arrayBuffer();
-    if (bytes.byteLength > MAX_BATCH_BYTES) {
-      return json({ error: { code: "BATCH_TOO_LARGE", limitBytes: MAX_BATCH_BYTES } }, 413);
+    const headers = corsHeaders(origin);
+    const contentLength = Number(request.headers.get("content-length"));
+    if (Number.isFinite(contentLength) && contentLength > MAX_BATCH_BYTES) {
+      return json(
+        { error: { code: "BATCH_TOO_LARGE", limitBytes: MAX_BATCH_BYTES } },
+        413,
+        headers,
+      );
     }
 
     let payload: { siteId: string; events: TrackerEvent[] };
     try {
+      const bytes = await readLimitedBody(request, MAX_BATCH_BYTES);
       const parsed: unknown = JSON.parse(new TextDecoder().decode(bytes));
       payload = parsePayload(parsed);
     } catch (error) {
+      if (error instanceof PayloadTooLargeError) {
+        return json(
+          { error: { code: "BATCH_TOO_LARGE", limitBytes: MAX_BATCH_BYTES } },
+          413,
+          headers,
+        );
+      }
       return json(
         {
           error: {
@@ -42,6 +55,7 @@ http.route({
           },
         },
         400,
+        headers,
       );
     }
 
@@ -61,7 +75,7 @@ http.route({
         events: payload.events,
         context,
       });
-      return json(result, 200, corsHeaders(origin));
+      return json(result, 200, headers);
     } catch (error) {
       if (error instanceof ConvexError) {
         const data = error.data as { code?: string; message?: string };
@@ -71,9 +85,9 @@ http.route({
             : data.code === "RATE_LIMITED"
               ? 429
               : 400;
-        return json({ error: data }, status);
+        return json({ error: data }, status, headers);
       }
-      return json({ error: { code: "INVALID_REQUEST" } }, 400);
+      return json({ error: { code: "INVALID_REQUEST" } }, 400, headers);
     }
   }),
 });
@@ -136,6 +150,35 @@ function parsePayload(value: unknown): { siteId: string; events: TrackerEvent[]
   return { siteId: value.siteId, events: value.events.map(parseEvent) };
 }
 
+class PayloadTooLargeError extends Error {}
+
+async function readLimitedBody(
+  request: Request,
+  maximumBytes: number,
+): Promise<Uint8Array> {
+  if (!request.body) return new Uint8Array();
+  const reader = request.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let length = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    length += value.byteLength;
+    if (length > maximumBytes) {
+      await reader.cancel();
+      throw new PayloadTooLargeError();
+    }
+    chunks.push(value);
+  }
+  const result = new Uint8Array(length);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return result;
+}
+
 function parseEvent(value: unknown): TrackerEvent {
   if (!isPlainRecord(value)) throw new Error("each event must be an object");
   const type = value.type;