@hyperdrive.bot/fleet-server 0.3.147 → 0.3.149

package/dist/server/server/ingestion/subscriptions/store.js

@@ -0,0 +1,82 @@
+import { randomBytes } from "node:crypto";
+import { mkdir, readFile, readdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { StoredSubscriptionSchema, } from "@hyperdrive.bot/fleet-protocol/ingestion/subscription-types";
+import { writeJsonFileAtomic } from "../../atomic-file.js";
+function generateSubscriptionId() {
+    return randomBytes(4).toString("hex");
+}
+/**
+ * File-backed persistence for session subscriptions, one JSON file per
+ * subscription under `dir` (the caller supplies `join(paseoHome, "subscriptions")`).
+ *
+ * Structurally identical to `SourceStore` and `ScheduleStore`, deliberately: a
+ * third shape here would be a third set of atomicity and parse bugs to find.
+ *
+ * `StoredSubscriptionSchema` is strict and `list()` is readdir + Promise.all, so
+ * ONE unparseable file rejects the whole array. That is the same trade the
+ * source store makes, and it carries the same obligation: every field added to
+ * the schema later must carry `.default(...)`, or records written before it
+ * existed stop parsing and every subscription silently disappears. There is no
+ * migration step. `accountLabel` on `StoredSourceSchema` is the precedent.
+ */
+export class SubscriptionStore {
+    constructor(dir) {
+        this.dir = dir;
+    }
+    filePath(id) {
+        return join(this.dir, `${id}.json`);
+    }
+    async ensureDir() {
+        await mkdir(this.dir, { recursive: true });
+    }
+    async list() {
+        await this.ensureDir();
+        const entries = await readdir(this.dir, { withFileTypes: true });
+        const subscriptions = await Promise.all(entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+            .map(async (entry) => {
+            const content = await readFile(join(this.dir, entry.name), "utf-8");
+            return StoredSubscriptionSchema.parse(JSON.parse(content));
+        }));
+        return subscriptions.sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+    }
+    async get(id) {
+        await this.ensureDir();
+        try {
+            const content = await readFile(this.filePath(id), "utf-8");
+            return StoredSubscriptionSchema.parse(JSON.parse(content));
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Every armed subscription pointing at `filterId`.
+     *
+     * The fan-out read. A filter with three armed subscribers returns three
+     * records here, and each one is notified on its own budget: this is the
+     * function that makes one filter serve many sessions.
+     */
+    async listArmedForFilter(filterId) {
+        const all = await this.list();
+        return all.filter((subscription) => subscription.filterId === filterId && subscription.status === "armed");
+    }
+    async create(subscription) {
+        const created = { ...subscription, id: generateSubscriptionId() };
+        await this.put(created);
+        return created;
+    }
+    async put(subscription) {
+        await this.ensureDir();
+        await writeJsonFileAtomic(this.filePath(subscription.id), subscription);
+    }
+    async delete(id) {
+        await this.ensureDir();
+        await rm(this.filePath(id), { force: true });
+    }
+}
+//# sourceMappingURL=store.js.map