@objy/server 0.0.0-stage → 0.1.0

package/src/system-secrets.js

@@ -0,0 +1,107 @@
+import { randomBytes } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+
+const DEFAULT_KEY = "system/secrets.json";
+const DEFAULT_PREFIX = "objydb";
+
+export async function resolveSystemSecrets({
+  jwtSecret,
+  clusterSecret,
+  storage,
+  prefix = DEFAULT_PREFIX,
+  localPath,
+} = {}) {
+  const configured = {
+    jwtSecret: optionalSecret(jwtSecret),
+    clusterSecret: optionalSecret(clusterSecret),
+  };
+  if (configured.jwtSecret && configured.clusterSecret) return configured;
+
+  const store = storage
+    ? new ObjectSecretStore(storage, `${normalizePrefix(prefix)}/${DEFAULT_KEY}`)
+    : new FileSecretStore(localPath);
+  let stored = await store.load();
+  if (!stored) {
+    const candidate = {
+      version: 1,
+      jwtSecret: configured.jwtSecret || randomSecret(),
+      clusterSecret: configured.clusterSecret || randomSecret(),
+      createdAt: new Date().toISOString(),
+    };
+    await store.create(candidate);
+    stored = await store.load();
+  }
+
+  const resolved = {
+    jwtSecret: configured.jwtSecret || stored?.jwtSecret,
+    clusterSecret: configured.clusterSecret || stored?.clusterSecret,
+  };
+  if (!resolved.jwtSecret || !resolved.clusterSecret) {
+    throw new Error("stored OBJY DB secrets are invalid");
+  }
+  return resolved;
+}
+
+export function randomSecret(bytes = 32) {
+  return randomBytes(bytes).toString("base64url");
+}
+
+class ObjectSecretStore {
+  constructor(storage, key) {
+    this.storage = storage;
+    this.key = key;
+  }
+
+  async load() {
+    const raw = await this.storage.get(this.key);
+    return raw ? parseSecrets(raw) : null;
+  }
+
+  async create(value) {
+    return this.storage.putIfAbsent(this.key, JSON.stringify(value), "application/json");
+  }
+}
+
+class FileSecretStore {
+  constructor(path) {
+    if (!path) throw new Error("local system secret path is required");
+    this.path = path;
+  }
+
+  async load() {
+    try {
+      return parseSecrets(await readFile(this.path, "utf8"));
+    } catch (err) {
+      if (err.code === "ENOENT") return null;
+      throw err;
+    }
+  }
+
+  async create(value) {
+    await mkdir(dirname(this.path), { recursive: true, mode: 0o700 });
+    try {
+      await writeFile(this.path, `${JSON.stringify(value, null, 2)}\n`, { flag: "wx", mode: 0o600 });
+      return true;
+    } catch (err) {
+      if (err.code === "EEXIST") return false;
+      throw err;
+    }
+  }
+}
+
+function parseSecrets(raw) {
+  const value = JSON.parse(raw);
+  if (value?.version !== 1 || !optionalSecret(value.jwtSecret) || !optionalSecret(value.clusterSecret)) {
+    throw new Error("stored OBJY DB secrets are invalid");
+  }
+  return value;
+}
+
+function optionalSecret(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+
+function normalizePrefix(value) {
+  return String(value || "").replace(/^\/+|\/+$/g, "");
+}

package/src/vector.js

@@ -0,0 +1,83 @@
+export const DEFAULT_VECTOR_FIELD = "_vec";
+
+export class VectorIndexWarmingError extends Error {
+  constructor({ database, collection, indexKey = "all", indexStatus = "warming" } = {}) {
+    super("vector index warming");
+    this.name = "VectorIndexWarmingError";
+    this.code = "VECTOR_INDEX_WARMING";
+    this.status = 503;
+    this.body = {
+      error: "vector index warming",
+      ...(database ? { database } : {}),
+      ...(collection ? { collection } : {}),
+      indexKey,
+      indexStatus,
+    };
+  }
+}
+
+export function isValidVector(value) {
+  return Array.isArray(value) &&
+    value.length > 0 &&
+    value.every((entry) => typeof entry === "number" && Number.isFinite(entry));
+}
+
+export function cloneVector(value) {
+  return isValidVector(value) ? [...value] : null;
+}
+
+export function cosine(a, b) {
+  if (!isValidVector(a) || !isValidVector(b) || a.length !== b.length) return 0;
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
+  }
+  if (na === 0 || nb === 0) return 0;
+  return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+
+export function rankBySimilarity(rows, queryVec, {
+  limit = 20,
+  getVec,
+  idOf = (row) => row?.id,
+} = {}) {
+  if (!isValidVector(queryVec) || typeof getVec !== "function") return [];
+  const scored = [];
+  for (const row of rows || []) {
+    const id = idOf(row);
+    if (id === undefined || id === null) continue;
+    const vec = getVec(String(id));
+    if (!isValidVector(vec) || vec.length !== queryVec.length) continue;
+    scored.push({ row, score: cosine(queryVec, vec) });
+  }
+  scored.sort((left, right) => right.score - left.score);
+  return scored.slice(0, Math.max(0, limit)).map(({ row, score }) => ({ ...row, _score: score }));
+}
+
+export function normalizeVectorConfig(config = {}) {
+  if (config === false || config.enabled === false) {
+    return { enabled: false, field: null, hnsw: normalizeHnswConfig({}) };
+  }
+  return {
+    enabled: true,
+    field: typeof config.field === "string" && config.field.length > 0 ? config.field : DEFAULT_VECTOR_FIELD,
+    hnsw: normalizeHnswConfig(config.hnsw),
+  };
+}
+
+function normalizeHnswConfig(config = {}) {
+  return {
+    M: positiveInt(config.M, 16),
+    efConstruction: positiveInt(config.efConstruction, 200),
+    efSearch: positiveInt(config.efSearch, 0),
+  };
+}
+
+function positiveInt(value, fallback) {
+  const n = Number(value);
+  return Number.isInteger(n) && n > 0 ? n : fallback;
+}