@thingd/sdk 0.72.0 → 0.74.2

package/dist/stores/in-memory-thing-store.js

@@ -0,0 +1,709 @@
+import { randomUUID } from "node:crypto";
+const DEFAULT_LEASE_MS = 30_000;
+class Mutex {
+    queue = [];
+    locked = false;
+    async acquire() {
+        if (!this.locked) {
+            this.locked = true;
+            return () => this.release();
+        }
+        return new Promise((resolve) => {
+            this.queue.push(() => {
+                this.locked = true;
+                resolve(() => this.release());
+            });
+        });
+    }
+    release() {
+        const next = this.queue.shift();
+        if (next) {
+            next();
+        }
+        else {
+            this.locked = false;
+        }
+    }
+}
+export class InMemoryThingStore {
+    collections = new Map();
+    events = [];
+    nextEventSequence = 0;
+    queues = new Map();
+    links = new Map();
+    mutex = new Mutex();
+    eventIdempotencyKeys = new Map();
+    async withLock(fn) {
+        const release = await this.mutex.acquire();
+        try {
+            return fn();
+        }
+        finally {
+            release();
+        }
+    }
+    async put(collection, object, options) {
+        return this.withLock(() => {
+            const records = this.getCollection(collection);
+            const now = new Date().toISOString();
+            const existing = records.get(object.id);
+            // CAS check: if expectedVersion is set, verify it matches
+            if (options?.expectedVersion !== undefined) {
+                const currentVersion = existing?.version ?? 0;
+                if (currentVersion !== options.expectedVersion) {
+                    throw new Error(`Conflict: version mismatch for ${collection}/${object.id}: expected ${options.expectedVersion}, got ${currentVersion}`);
+                }
+            }
+            const record = {
+                ...object,
+                id: object.id,
+                collection,
+                createdAt: existing?.createdAt ?? now,
+                updatedAt: now,
+                version: (existing?.version ?? 0) + 1,
+            };
+            records.set(object.id, record);
+            return record;
+        });
+    }
+    async get(collection, id) {
+        return this.collections.get(collection)?.get(id) ?? null;
+    }
+    async getBatch(collection, ids) {
+        const records = this.collections.get(collection);
+        return ids.map((id) => records?.get(id) ?? null);
+    }
+    async delete(collection, id) {
+        return this.withLock(() => ({
+            deleted: this.collections.get(collection)?.delete(id) ?? false,
+        }));
+    }
+    async listObjects(collection, options) {
+        const records = this.collections.get(collection);
+        if (!records) {
+            return [];
+        }
+        let results = Array.from(records.values());
+        const filter = options?.filter;
+        if (filter) {
+            results = results.filter((obj) => Object.entries(filter).every(([key, value]) => obj[key] === value));
+        }
+        if (options?.sortBy) {
+            const { field, direction } = options.sortBy;
+            const asc = direction !== "desc";
+            results.sort((a, b) => {
+                const va = a[field];
+                const vb = b[field];
+                if (va === vb) {
+                    return 0;
+                }
+                if (va === undefined) {
+                    return 1;
+                }
+                if (vb === undefined) {
+                    return -1;
+                }
+                const cmp = va < vb ? -1 : 1;
+                return asc ? cmp : -cmp;
+            });
+        }
+        if (options?.offset) {
+            results = results.slice(options.offset);
+        }
+        if (options?.limit) {
+            results = results.slice(0, options.limit);
+        }
+        return results;
+    }
+    async appendEvent(stream, event) {
+        return this.withLock(() => {
+            // Idempotency check
+            const idempotencyKey = event.idempotencyKey;
+            if (idempotencyKey) {
+                const existing = this.eventIdempotencyKeys.get(`${stream}:${idempotencyKey}`);
+                if (existing !== undefined) {
+                    const found = this.events.find((e) => e.sequence === existing);
+                    if (found) {
+                        return found;
+                    }
+                }
+            }
+            this.nextEventSequence += 1;
+            const record = {
+                ...event,
+                id: randomUUID(),
+                stream,
+                sequence: this.nextEventSequence,
+                createdAt: new Date().toISOString(),
+            };
+            // Track idempotency key
+            if (idempotencyKey) {
+                this.eventIdempotencyKeys.set(`${stream}:${idempotencyKey}`, record.sequence);
+            }
+            this.events.push(record);
+            return record;
+        });
+    }
+    async listEvents(stream, options) {
+        let events = this.events;
+        if (stream) {
+            events = events.filter((event) => event.stream === stream);
+        }
+        const fromSeq = options?.fromSequence;
+        if (fromSeq) {
+            events = events.filter((event) => event.sequence > fromSeq);
+        }
+        if (options?.since) {
+            const since = options.since;
+            events = events.filter((event) => event.createdAt >= since);
+        }
+        if (options?.limit) {
+            events = events.slice(0, options.limit);
+        }
+        return [...events];
+    }
+    async pushJob(queue, payload, options = {}) {
+        return this.withLock(() => {
+            const jobs = this.getQueue(queue);
+            const now = new Date().toISOString();
+            const job = {
+                id: options.idempotencyKey ?? randomUUID(),
+                queue,
+                payload,
+                status: "ready",
+                attempts: 0,
+                maxAttempts: options.maxAttempts ?? 3,
+                createdAt: now,
+                availableAt: new Date(Date.now() + (options.delayMs ?? 0)).toISOString(),
+                priority: options.priority ?? 0,
+            };
+            const existing = jobs.find((candidate) => candidate.id === job.id);
+            if (existing) {
+                return this.cloneJob(existing);
+            }
+            jobs.push(job);
+            return this.cloneJob(job);
+        });
+    }
+    async claimJob(queue, options = {}) {
+        return this.withLock(() => {
+            this.releaseExpiredLeases(queue);
+            const now = new Date();
+            const candidates = this.queues
+                .get(queue)
+                ?.filter((candidate) => candidate.status === "ready" && candidate.availableAt <= now.toISOString())
+                ?.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+            const job = candidates?.[0] ?? null;
+            if (!job) {
+                return null;
+            }
+            job.status = "leased";
+            job.attempts += 1;
+            job.leasedAt = now.toISOString();
+            job.leaseExpiresAt = new Date(now.getTime() + (options.leaseMs ?? DEFAULT_LEASE_MS)).toISOString();
+            return this.cloneJob(job);
+        });
+    }
+    async ackJob(queue, jobId) {
+        return this.withLock(() => {
+            const job = this.findJob(queue, jobId);
+            if (!job) {
+                return { ok: false, reason: "not_found" };
+            }
+            if (job.status === "completed" || job.status === "dead") {
+                return { ok: false, reason: "terminal" };
+            }
+            if (job.status !== "leased") {
+                return { ok: false, reason: "not_leased" };
+            }
+            job.status = "completed";
+            job.completedAt = new Date().toISOString();
+            return { ok: true, job: this.cloneJob(job) };
+        });
+    }
+    async nackJob(queue, jobId, options = {}) {
+        return this.withLock(() => {
+            const job = this.findJob(queue, jobId);
+            if (!job) {
+                return { ok: false, reason: "not_found" };
+            }
+            if (job.status === "completed" || job.status === "dead") {
+                return { ok: false, reason: "terminal" };
+            }
+            if (job.status !== "leased") {
+                return { ok: false, reason: "not_leased" };
+            }
+            job.lastError = options.error;
+            job.leasedAt = undefined;
+            job.leaseExpiresAt = undefined;
+            if (job.attempts >= job.maxAttempts) {
+                job.status = "dead";
+                job.deadAt = new Date().toISOString();
+            }
+            else {
+                job.status = "ready";
+                job.availableAt = new Date(Date.now() + (options.delayMs ?? 0)).toISOString();
+            }
+            return { ok: true, job: this.cloneJob(job) };
+        });
+    }
+    async listJobs(queue) {
+        return (this.queues.get(queue) ?? []).map((job) => this.cloneJob(job));
+    }
+    async listDeadJobs(queue) {
+        return (this.queues.get(queue) ?? [])
+            .filter((job) => job.status === "dead")
+            .map((job) => this.cloneJob(job));
+    }
+    async search(query, options = {}) {
+        const normalizedQuery = query.toLowerCase();
+        const collections = options.collections ? new Set(options.collections) : null;
+        const filter = options.filter;
+        const results = [];
+        for (const [collection, records] of this.collections) {
+            if (collections && !collections.has(collection)) {
+                continue;
+            }
+            for (const record of records.values()) {
+                if (filter && !this.matchesFilter(filter, record)) {
+                    continue;
+                }
+                const haystack = JSON.stringify(record).toLowerCase();
+                if (haystack.includes(normalizedQuery)) {
+                    results.push({
+                        kind: "object",
+                        id: record.id,
+                        collection,
+                        score: 1,
+                        value: record,
+                    });
+                }
+            }
+        }
+        for (const event of this.events) {
+            if (filter && !this.matchesFilter(filter, event)) {
+                continue;
+            }
+            const haystack = JSON.stringify(event).toLowerCase();
+            if (haystack.includes(normalizedQuery)) {
+                results.push({
+                    kind: "event",
+                    id: event.id,
+                    stream: event.stream,
+                    score: 1,
+                    value: event,
+                });
+            }
+        }
+        return options.limit !== undefined ? results.slice(0, options.limit) : results;
+    }
+    async vectorSearch(collection, queryVector, options = {}) {
+        const records = this.collections.get(collection);
+        if (!records) {
+            return [];
+        }
+        const filter = options.filter;
+        const hits = [];
+        for (const record of records.values()) {
+            if (filter && !this.matchesFilter(filter, record)) {
+                continue;
+            }
+            const recordVector = record.vector;
+            if (!Array.isArray(recordVector)) {
+                continue;
+            }
+            const vec = recordVector;
+            if (vec.length !== queryVector.length) {
+                continue;
+            }
+            const score = cosineSimilarity(queryVector, vec);
+            hits.push({ id: record.id, score, value: record });
+        }
+        hits.sort((a, b) => b.score - a.score);
+        if (options.topK !== undefined) {
+            return hits.slice(0, options.topK);
+        }
+        return hits;
+    }
+    matchesFilter(filter, obj) {
+        return Object.entries(filter).every(([key, expected]) => {
+            return key in obj && obj[key] === expected;
+        });
+    }
+    async countObjects() {
+        let total = 0;
+        for (const records of this.collections.values()) {
+            total += records.size;
+        }
+        return total;
+    }
+    async countObjectsInCollection(collection) {
+        return this.collections.get(collection)?.size ?? 0;
+    }
+    async countEvents() {
+        return this.events.length;
+    }
+    async countActiveJobs() {
+        let total = 0;
+        for (const jobs of this.queues.values()) {
+            total += jobs.filter((job) => job.status !== "dead").length;
+        }
+        return total;
+    }
+    async countDeadJobs() {
+        let total = 0;
+        for (const jobs of this.queues.values()) {
+            total += jobs.filter((job) => job.status === "dead").length;
+        }
+        return total;
+    }
+    async countLinks() {
+        return this.links.size;
+    }
+    async putBatch(collection, objects) {
+        return this.withLock(() => {
+            const records = this.getCollection(collection);
+            const now = new Date().toISOString();
+            const results = [];
+            for (const object of objects) {
+                const existing = records.get(object.id);
+                const record = {
+                    ...object,
+                    id: object.id,
+                    collection,
+                    createdAt: existing?.createdAt ?? now,
+                    updatedAt: now,
+                    version: (existing?.version ?? 0) + 1,
+                };
+                records.set(object.id, record);
+                results.push(record);
+            }
+            return results;
+        });
+    }
+    async deleteBatch(collection, ids) {
+        return this.withLock(() => {
+            const records = this.collections.get(collection);
+            if (!records) {
+                return 0;
+            }
+            let count = 0;
+            for (const id of ids) {
+                if (records.delete(id)) {
+                    count++;
+                }
+            }
+            return count;
+        });
+    }
+    async createLink(fromRef, linkType, toRef, weight, metadataJson) {
+        return this.withLock(() => {
+            const link = {
+                id: randomUUID(),
+                fromRef,
+                linkType,
+                toRef,
+                weight,
+                metadataJson: metadataJson ?? "{}",
+                createdAt: new Date().toISOString(),
+            };
+            this.links.set(link.id, link);
+            return link;
+        });
+    }
+    async deleteLink(id) {
+        return this.withLock(() => {
+            return this.links.delete(id);
+        });
+    }
+    async getLink(id) {
+        return this.links.get(id) ?? null;
+    }
+    async getNeighbors(reference, direction, options) {
+        let results = Array.from(this.links.values());
+        results = results.filter((link) => {
+            if (direction === "Outgoing") {
+                return link.fromRef === reference;
+            }
+            if (direction === "Incoming") {
+                return link.toRef === reference;
+            }
+            return link.fromRef === reference || link.toRef === reference;
+        });
+        if (options.linkType) {
+            results = results.filter((link) => link.linkType === options.linkType);
+        }
+        if (options.limit !== undefined) {
+            results = results.slice(0, options.limit);
+        }
+        return results;
+    }
+    async listCollections() {
+        return Array.from(this.collections.keys()).sort();
+    }
+    async listQueues() {
+        return Array.from(this.queues.keys()).sort();
+    }
+    async createIndex(_collection, _field) {
+        // No-op for in-memory store
+    }
+    async listIndexes() {
+        return [];
+    }
+    async listStreams() {
+        const streams = new Set();
+        for (const event of this.events) {
+            streams.add(event.stream);
+        }
+        return Array.from(streams).sort();
+    }
+    async aggregate(collection, options) {
+        const records = Array.from(this.collections.get(collection)?.values() ?? []);
+        // Apply filter
+        const filtered = options.filter
+            ? records.filter((obj) => Object.entries(options.filter).every(([key, value]) => obj[key] === value))
+            : records;
+        if (options.groupBy) {
+            const groups = new Map();
+            for (const obj of filtered) {
+                const key = String(obj[options.groupBy] ?? "");
+                const group = groups.get(key) ?? [];
+                group.push(obj);
+                groups.set(key, group);
+            }
+            const groupResults = Array.from(groups.entries())
+                .map(([key, objs]) => ({
+                key,
+                value: this.computeAggregate(objs, options.function, options.field),
+            }))
+                .sort((a, b) => a.key.localeCompare(b.key));
+            const total = groupResults.reduce((sum, g) => sum + g.value, 0);
+            return { total, groups: groupResults };
+        }
+        const total = this.computeAggregate(filtered, options.function, options.field);
+        return { total, groups: [] };
+    }
+    async timeseries(collection, options) {
+        const records = Array.from(this.collections.get(collection)?.values() ?? []);
+        // Apply filter
+        let filtered = options.filter
+            ? records.filter((obj) => Object.entries(options.filter).every(([key, value]) => obj[key] === value))
+            : records;
+        // Apply time range
+        if (options.from) {
+            filtered = filtered.filter((obj) => obj.createdAt >= options.from);
+        }
+        if (options.to) {
+            filtered = filtered.filter((obj) => obj.createdAt < options.to);
+        }
+        // Bucket by createdAt
+        const format = this.getTimeBucketFormat(options.bucket);
+        const buckets = new Map();
+        for (const obj of filtered) {
+            const label = this.formatTimestamp(obj.createdAt, format);
+            const group = buckets.get(label) ?? [];
+            group.push(obj);
+            buckets.set(label, group);
+        }
+        const resultBuckets = Array.from(buckets.entries())
+            .map(([label, objs]) => ({
+            label,
+            value: this.computeAggregate(objs, options.function, options.field),
+        }))
+            .sort((a, b) => a.label.localeCompare(b.label));
+        return { buckets: resultBuckets };
+    }
+    async schema(collection, options) {
+        const sampleSize = options?.sampleSize ?? 50;
+        const collections = collection ? [collection] : Array.from(this.collections.keys()).sort();
+        const result = [];
+        for (const col of collections) {
+            const objects = Array.from(this.collections.get(col)?.values() ?? []);
+            if (objects.length === 0) {
+                continue;
+            }
+            const sampled = objects.slice(0, sampleSize);
+            const fieldMap = new Map();
+            for (const obj of sampled) {
+                const body = typeof obj.body === "string" ? JSON.parse(obj.body) : obj.body;
+                if (!body || typeof body !== "object") {
+                    continue;
+                }
+                for (const [key, value] of Object.entries(body)) {
+                    let entry = fieldMap.get(key);
+                    if (!entry) {
+                        entry = { type: this.inferType(value), nullable: false, samples: [] };
+                        fieldMap.set(key, entry);
+                    }
+                    if (value === null || value === undefined) {
+                        entry.nullable = true;
+                    }
+                    else {
+                        const inferred = this.inferType(value);
+                        if (entry.type !== inferred) {
+                            entry.type = "unknown";
+                        }
+                        if (entry.samples.length < 3) {
+                            entry.samples.push(value);
+                        }
+                    }
+                }
+            }
+            result.push({
+                name: col,
+                objectCount: objects.length,
+                fields: Array.from(fieldMap.entries()).map(([name, { type, nullable, samples }]) => ({
+                    name,
+                    type,
+                    nullable,
+                    sampleValues: samples,
+                })),
+            });
+        }
+        return result;
+    }
+    inferType(value) {
+        if (value === null || value === undefined) {
+            return "null";
+        }
+        if (typeof value === "boolean") {
+            return "boolean";
+        }
+        if (typeof value === "number") {
+            return "number";
+        }
+        if (typeof value === "string") {
+            if (value.length > 10 &&
+                (value.includes("T") || value.includes("-")) &&
+                !Number.isNaN(Date.parse(value))) {
+                return "date";
+            }
+            return "string";
+        }
+        if (Array.isArray(value)) {
+            return "array";
+        }
+        if (typeof value === "object") {
+            return "object";
+        }
+        return "unknown";
+    }
+    computeAggregate(objects, function_, field) {
+        switch (function_) {
+            case "count":
+                return objects.length;
+            case "sum":
+                return objects.reduce((sum, obj) => sum + (Number(obj[field ?? ""]) || 0), 0);
+            case "avg": {
+                const values = objects
+                    .map((obj) => Number(obj[field ?? ""]) || 0)
+                    .filter((v) => !Number.isNaN(v));
+                return values.length > 0 ? values.reduce((a, b) => a + b, 0) / values.length : 0;
+            }
+            case "min": {
+                const values = objects
+                    .map((obj) => Number(obj[field ?? ""]) || 0)
+                    .filter((v) => !Number.isNaN(v));
+                return values.length > 0 ? Math.min(...values) : 0;
+            }
+            case "max": {
+                const values = objects
+                    .map((obj) => Number(obj[field ?? ""]) || 0)
+                    .filter((v) => !Number.isNaN(v));
+                return values.length > 0 ? Math.max(...values) : 0;
+            }
+            default:
+                return 0;
+        }
+    }
+    getTimeBucketFormat(bucket) {
+        switch (bucket) {
+            case "hour":
+                return "YYYY-MM-DDTHH:00:00Z";
+            case "day":
+                return "YYYY-MM-DD";
+            case "week":
+                return "YYYY-[W]WW";
+            case "month":
+                return "YYYY-MM";
+            default:
+                return "YYYY-MM-DD";
+        }
+    }
+    formatTimestamp(ts, format) {
+        const date = new Date(ts);
+        if (Number.isNaN(date.getTime())) {
+            return ts;
+        }
+        const pad = (n) => String(n).padStart(2, "0");
+        const year = date.getUTCFullYear();
+        const month = pad(date.getUTCMonth() + 1);
+        const day = pad(date.getUTCDate());
+        const hours = pad(date.getUTCHours());
+        const weekNum = Math.ceil((date.getUTCDate() - date.getUTCDay() + 1) / 7);
+        return format
+            .replace("YYYY", String(year))
+            .replace("MM", month)
+            .replace("DD", day)
+            .replace("HH", hours)
+            .replace("[W]WW", `W${String(weekNum).padStart(2, "0")}`);
+    }
+    async close() {
+        // no-op for in-memory
+    }
+    walCheckpoint() {
+        throw new Error("WAL checkpoint is not supported for in-memory storage");
+    }
+    getCollection(collection) {
+        const records = this.collections.get(collection) ?? new Map();
+        this.collections.set(collection, records);
+        return records;
+    }
+    getQueue(queue) {
+        const jobs = this.queues.get(queue) ?? [];
+        this.queues.set(queue, jobs);
+        return jobs;
+    }
+    findJob(queue, jobId) {
+        return this.queues.get(queue)?.find((job) => job.id === jobId) ?? null;
+    }
+    releaseExpiredLeases(queue) {
+        const now = new Date().toISOString();
+        for (const job of this.queues.get(queue) ?? []) {
+            if (job.status === "leased" && job.leaseExpiresAt && job.leaseExpiresAt <= now) {
+                job.status = "ready";
+                job.leasedAt = undefined;
+                job.leaseExpiresAt = undefined;
+            }
+        }
+    }
+    cloneJob(job) {
+        return {
+            ...job,
+            payload: {
+                ...job.payload,
+            },
+        };
+    }
+}
+function cosineSimilarity(a, b) {
+    if (a.length !== b.length || a.length === 0) {
+        return 0;
+    }
+    let dot = 0;
+    let normA = 0;
+    let normB = 0;
+    for (const [i, ai] of a.entries()) {
+        const bi = b[i];
+        if (bi === undefined) {
+            break;
+        }
+        dot += ai * bi;
+        normA += ai * ai;
+        normB += bi * bi;
+    }
+    if (normA === 0 || normB === 0) {
+        return 0;
+    }
+    return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}