wyxrouter 0.4.71

package/src/lib/db/repos/connectionsRepo.js

@@ -0,0 +1,226 @@
+import { v4 as uuidv4 } from "uuid";
+import { getAdapter } from "../driver.js";
+import { parseJson, stringifyJson } from "../helpers/jsonCol.js";
+
+const OPTIONAL_FIELDS = [
+  "displayName", "email", "globalPriority", "defaultModel",
+  "accessToken", "refreshToken", "expiresAt", "tokenType",
+  "scope", "projectId", "apiKey", "testStatus",
+  "lastTested", "lastError", "lastErrorAt", "rateLimitedUntil", "expiresIn", "errorCode",
+  "consecutiveUseCount",
+];
+
+function rowToConn(row) {
+  if (!row) return null;
+  const extra = parseJson(row.data, {});
+  return {
+    ...extra,
+    id: row.id,
+    provider: row.provider,
+    authType: row.authType,
+    name: row.name,
+    email: row.email,
+    priority: row.priority,
+    isActive: row.isActive === 1 || row.isActive === true,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  };
+}
+
+function connToRow(c) {
+  const { id, provider, authType, name, email, priority, isActive, createdAt, updatedAt, ...rest } = c;
+  return {
+    id,
+    provider,
+    authType,
+    name: name ?? null,
+    email: email ?? null,
+    priority: priority ?? null,
+    isActive: isActive === false ? 0 : 1,
+    data: stringifyJson(rest),
+    createdAt,
+    updatedAt,
+  };
+}
+
+function upsert(db, c) {
+  const r = connToRow(c);
+  db.run(
+    `INSERT INTO providerConnections(id, provider, authType, name, email, priority, isActive, data, createdAt, updatedAt)
+     VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(id) DO UPDATE SET
+       provider=excluded.provider, authType=excluded.authType, name=excluded.name,
+       email=excluded.email, priority=excluded.priority, isActive=excluded.isActive,
+       data=excluded.data, updatedAt=excluded.updatedAt`,
+    [r.id, r.provider, r.authType, r.name, r.email, r.priority, r.isActive, r.data, r.createdAt, r.updatedAt]
+  );
+}
+
+export async function getProviderConnections(filter = {}) {
+  const db = await getAdapter();
+  const where = [];
+  const params = [];
+  if (filter.provider) { where.push("provider = ?"); params.push(filter.provider); }
+  if (filter.isActive !== undefined) { where.push("isActive = ?"); params.push(filter.isActive ? 1 : 0); }
+  const sql = `SELECT * FROM providerConnections${where.length ? ` WHERE ${where.join(" AND ")}` : ""}`;
+  const rows = db.all(sql, params);
+  const list = rows.map(rowToConn);
+  list.sort((a, b) => (a.priority || 999) - (b.priority || 999));
+  return list;
+}
+
+export async function getProviderConnectionById(id) {
+  const db = await getAdapter();
+  const row = db.get(`SELECT * FROM providerConnections WHERE id = ?`, [id]);
+  return rowToConn(row);
+}
+
+// Internal sync reorder — must be called INSIDE a transaction
+function reorderInTx(db, providerId) {
+  const list = db.all(`SELECT * FROM providerConnections WHERE provider = ?`, [providerId]).map(rowToConn);
+  list.sort((a, b) => {
+    const pDiff = (a.priority || 0) - (b.priority || 0);
+    if (pDiff !== 0) return pDiff;
+    return new Date(b.updatedAt || 0) - new Date(a.updatedAt || 0);
+  });
+  list.forEach((c, i) => {
+    db.run(`UPDATE providerConnections SET priority = ? WHERE id = ?`, [i + 1, c.id]);
+  });
+}
+
+export async function createProviderConnection(data) {
+  const db = await getAdapter();
+  const now = new Date().toISOString();
+  let result;
+
+  db.transaction(() => {
+    const all = db.all(`SELECT * FROM providerConnections WHERE provider = ?`, [data.provider]).map(rowToConn);
+
+    let existing = null;
+    if (data.authType === "oauth" && data.email) {
+      const incomingWs = data.providerSpecificData?.chatgptAccountId;
+      existing = all.find(c => {
+        if (c.authType !== "oauth" || c.email !== data.email) return false;
+        // If both sides have a workspace ID, they must match for dedup
+        const existingWs = c.providerSpecificData?.chatgptAccountId;
+        if (incomingWs && existingWs) return incomingWs === existingWs;
+        return true; // fallback: email-only match for non-workspace providers
+      });
+    } else if (data.authType === "apikey" && data.name) {
+      existing = all.find(c => c.authType === "apikey" && c.name === data.name);
+    }
+    // access_token: never dedup — user manages duplicates manually
+
+    if (existing) {
+      const merged = { ...existing, ...data, updatedAt: now };
+      upsert(db, merged);
+      result = merged;
+      return;
+    }
+
+    let connectionName = data.name || null;
+    if (!connectionName && (data.authType === "oauth" || data.authType === "access_token")) {
+      connectionName = data.email || `Account ${all.length + 1}`;
+    }
+    let connectionPriority = data.priority;
+    if (!connectionPriority) {
+      connectionPriority = all.reduce((m, c) => Math.max(m, c.priority || 0), 0) + 1;
+    }
+
+    const conn = {
+      id: uuidv4(),
+      provider: data.provider,
+      authType: data.authType || "oauth",
+      name: connectionName,
+      priority: connectionPriority,
+      isActive: data.isActive !== undefined ? data.isActive : true,
+      createdAt: now,
+      updatedAt: now,
+    };
+    for (const f of OPTIONAL_FIELDS) {
+      if (data[f] !== undefined && data[f] !== null) conn[f] = data[f];
+    }
+    if (data.providerSpecificData && Object.keys(data.providerSpecificData).length > 0) {
+      conn.providerSpecificData = data.providerSpecificData;
+    }
+    if (data.email !== undefined) conn.email = data.email;
+
+    upsert(db, conn);
+    reorderInTx(db, data.provider);
+    result = conn;
+  });
+
+  return result;
+}
+
+// Critical: OAuth refresh token race — atomic merge inside transaction
+export async function updateProviderConnection(id, data) {
+  const db = await getAdapter();
+  let result;
+  db.transaction(() => {
+    const row = db.get(`SELECT * FROM providerConnections WHERE id = ?`, [id]);
+    if (!row) { result = null; return; }
+    const existing = rowToConn(row);
+    const merged = { ...existing, ...data, updatedAt: new Date().toISOString() };
+    upsert(db, merged);
+    if (data.priority !== undefined) reorderInTx(db, existing.provider);
+    result = merged;
+  });
+  return result;
+}
+
+export async function deleteProviderConnection(id) {
+  const db = await getAdapter();
+  let ok = false;
+  db.transaction(() => {
+    const row = db.get(`SELECT provider FROM providerConnections WHERE id = ?`, [id]);
+    if (!row) return;
+    db.run(`DELETE FROM providerConnections WHERE id = ?`, [id]);
+    reorderInTx(db, row.provider);
+    ok = true;
+  });
+  return ok;
+}
+
+export async function deleteProviderConnectionsByProvider(providerId) {
+  const db = await getAdapter();
+  const before = db.get(`SELECT COUNT(*) AS n FROM providerConnections WHERE provider = ?`, [providerId]);
+  db.run(`DELETE FROM providerConnections WHERE provider = ?`, [providerId]);
+  return before?.n || 0;
+}
+
+export async function reorderProviderConnections(providerId) {
+  const db = await getAdapter();
+  db.transaction(() => reorderInTx(db, providerId));
+}
+
+export async function cleanupProviderConnections() {
+  const db = await getAdapter();
+  const fieldsToCheck = [
+    "displayName", "email", "globalPriority", "defaultModel",
+    "accessToken", "refreshToken", "expiresAt", "tokenType",
+    "scope", "projectId", "apiKey", "testStatus",
+    "lastTested", "lastError", "lastErrorAt", "rateLimitedUntil", "expiresIn",
+    "consecutiveUseCount",
+  ];
+  let cleaned = 0;
+  db.transaction(() => {
+    const rows = db.all(`SELECT * FROM providerConnections`);
+    for (const row of rows) {
+      const conn = rowToConn(row);
+      let dirty = false;
+      for (const f of fieldsToCheck) {
+        if (conn[f] === null || conn[f] === undefined) {
+          if (f in conn) { delete conn[f]; cleaned++; dirty = true; }
+        }
+      }
+      if (conn.providerSpecificData && Object.keys(conn.providerSpecificData).length === 0) {
+        delete conn.providerSpecificData;
+        cleaned++;
+        dirty = true;
+      }
+      if (dirty) upsert(db, conn);
+    }
+  });
+  return cleaned;
+}

package/src/lib/db/repos/disabledModelsRepo.js

@@ -0,0 +1,56 @@
+import { getAdapter } from "../driver.js";
+import { parseJson, stringifyJson } from "../helpers/jsonCol.js";
+
+const SCOPE = "disabledModels";
+
+export async function getDisabledModels() {
+  const db = await getAdapter();
+  const rows = db.all(`SELECT key, value FROM kv WHERE scope = ?`, [SCOPE]);
+  const out = {};
+  for (const r of rows) out[r.key] = parseJson(r.value, []);
+  return out;
+}
+
+export async function getDisabledByProvider(providerAlias) {
+  const db = await getAdapter();
+  const row = db.get(`SELECT value FROM kv WHERE scope = ? AND key = ?`, [SCOPE, providerAlias]);
+  return row ? (parseJson(row.value, []) || []) : [];
+}
+
+// Atomic read-merge-write inside a transaction (no JS yield mid-transaction).
+export async function disableModels(providerAlias, ids) {
+  if (!providerAlias || !Array.isArray(ids)) return;
+  const db = await getAdapter();
+  db.transaction(() => {
+    const row = db.get(`SELECT value FROM kv WHERE scope = ? AND key = ?`, [SCOPE, providerAlias]);
+    const current = row ? (parseJson(row.value, []) || []) : [];
+    const merged = [...new Set([...current, ...ids])];
+    db.run(
+      `INSERT INTO kv(scope, key, value) VALUES(?, ?, ?) ON CONFLICT(scope, key) DO UPDATE SET value = excluded.value`,
+      [SCOPE, providerAlias, stringifyJson(merged)]
+    );
+  });
+}
+
+export async function enableModels(providerAlias, ids) {
+  if (!providerAlias) return;
+  const db = await getAdapter();
+  db.transaction(() => {
+    if (!Array.isArray(ids) || ids.length === 0) {
+      db.run(`DELETE FROM kv WHERE scope = ? AND key = ?`, [SCOPE, providerAlias]);
+      return;
+    }
+    const row = db.get(`SELECT value FROM kv WHERE scope = ? AND key = ?`, [SCOPE, providerAlias]);
+    const current = row ? (parseJson(row.value, []) || []) : [];
+    const removeSet = new Set(ids);
+    const next = current.filter((id) => !removeSet.has(id));
+    if (next.length === 0) {
+      db.run(`DELETE FROM kv WHERE scope = ? AND key = ?`, [SCOPE, providerAlias]);
+    } else {
+      db.run(
+        `INSERT INTO kv(scope, key, value) VALUES(?, ?, ?) ON CONFLICT(scope, key) DO UPDATE SET value = excluded.value`,
+        [SCOPE, providerAlias, stringifyJson(next)]
+      );
+    }
+  });
+}

package/src/lib/db/repos/nodesRepo.js

@@ -0,0 +1,95 @@
+import { v4 as uuidv4 } from "uuid";
+import { getAdapter } from "../driver.js";
+import { parseJson, stringifyJson } from "../helpers/jsonCol.js";
+
+function rowToNode(row) {
+  if (!row) return null;
+  const extra = parseJson(row.data, {});
+  return {
+    ...extra,
+    id: row.id,
+    type: row.type,
+    name: row.name,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  };
+}
+
+function nodeToRow(n) {
+  const { id, type, name, createdAt, updatedAt, ...rest } = n;
+  return {
+    id,
+    type: type ?? null,
+    name: name ?? null,
+    data: stringifyJson(rest),
+    createdAt,
+    updatedAt,
+  };
+}
+
+function upsert(db, n) {
+  const r = nodeToRow(n);
+  db.run(
+    `INSERT INTO providerNodes(id, type, name, data, createdAt, updatedAt)
+     VALUES(?, ?, ?, ?, ?, ?)
+     ON CONFLICT(id) DO UPDATE SET
+       type=excluded.type, name=excluded.name, data=excluded.data, updatedAt=excluded.updatedAt`,
+    [r.id, r.type, r.name, r.data, r.createdAt, r.updatedAt]
+  );
+}
+
+export async function getProviderNodes(filter = {}) {
+  const db = await getAdapter();
+  const where = [];
+  const params = [];
+  if (filter.type) { where.push("type = ?"); params.push(filter.type); }
+  const sql = `SELECT * FROM providerNodes${where.length ? ` WHERE ${where.join(" AND ")}` : ""}`;
+  return db.all(sql, params).map(rowToNode);
+}
+
+export async function getProviderNodeById(id) {
+  const db = await getAdapter();
+  return rowToNode(db.get(`SELECT * FROM providerNodes WHERE id = ?`, [id]));
+}
+
+export async function createProviderNode(data) {
+  const db = await getAdapter();
+  const now = new Date().toISOString();
+  const node = {
+    id: data.id || uuidv4(),
+    type: data.type,
+    name: data.name,
+    prefix: data.prefix,
+    apiType: data.apiType,
+    baseUrl: data.baseUrl,
+    createdAt: now,
+    updatedAt: now,
+  };
+  upsert(db, node);
+  return node;
+}
+
+export async function updateProviderNode(id, data) {
+  const db = await getAdapter();
+  let result = null;
+  db.transaction(() => {
+    const row = db.get(`SELECT * FROM providerNodes WHERE id = ?`, [id]);
+    if (!row) return;
+    const merged = { ...rowToNode(row), ...data, updatedAt: new Date().toISOString() };
+    upsert(db, merged);
+    result = merged;
+  });
+  return result;
+}
+
+export async function deleteProviderNode(id) {
+  const db = await getAdapter();
+  let removed = null;
+  db.transaction(() => {
+    const row = db.get(`SELECT * FROM providerNodes WHERE id = ?`, [id]);
+    if (!row) return;
+    removed = rowToNode(row);
+    db.run(`DELETE FROM providerNodes WHERE id = ?`, [id]);
+  });
+  return removed;
+}

package/src/lib/db/repos/pricingRepo.js

@@ -0,0 +1,108 @@
+import { getAdapter } from "../driver.js";
+import { parseJson, stringifyJson } from "../helpers/jsonCol.js";
+import { makeKv } from "../helpers/kvStore.js";
+
+const pricingKv = makeKv("pricing");
+const CACHE_TTL_MS = 5000;
+
+let cache = { value: null, expiresAt: 0 };
+
+function invalidate() {
+  cache = { value: null, expiresAt: 0 };
+}
+
+async function getUserPricing() {
+  return await pricingKv.getAll();
+}
+
+export async function getPricing() {
+  const now = Date.now();
+  if (cache.value && cache.expiresAt > now) return cache.value;
+
+  const userPricing = await getUserPricing();
+  const { PROVIDER_PRICING } = await import("@/shared/constants/pricing.js");
+  const merged = {};
+
+  for (const [provider, models] of Object.entries(PROVIDER_PRICING)) {
+    merged[provider] = { ...models };
+    if (userPricing[provider]) {
+      for (const [model, pricing] of Object.entries(userPricing[provider])) {
+        merged[provider][model] = merged[provider][model]
+          ? { ...merged[provider][model], ...pricing }
+          : pricing;
+      }
+    }
+  }
+
+  for (const [provider, models] of Object.entries(userPricing)) {
+    if (!merged[provider]) {
+      merged[provider] = { ...models };
+    } else {
+      for (const [model, pricing] of Object.entries(models)) {
+        if (!merged[provider][model]) merged[provider][model] = pricing;
+      }
+    }
+  }
+
+  cache = { value: merged, expiresAt: now + CACHE_TTL_MS };
+  return merged;
+}
+
+export async function getPricingForModel(provider, model) {
+  if (!model) return null;
+  const userPricing = await getUserPricing();
+  if (provider && userPricing[provider]?.[model]) return userPricing[provider][model];
+  const { getPricingForModel: resolveConst } = await import("@/shared/constants/pricing.js");
+  return resolveConst(provider, model);
+}
+
+// Atomic merge inside transaction (per-provider read-modify-write)
+export async function updatePricing(pricingData) {
+  const db = await getAdapter();
+  db.transaction(() => {
+    for (const [provider, models] of Object.entries(pricingData)) {
+      const row = db.get(`SELECT value FROM kv WHERE scope = 'pricing' AND key = ?`, [provider]);
+      const current = row ? (parseJson(row.value, {}) || {}) : {};
+      const merged = { ...current };
+      for (const [model, pricing] of Object.entries(models)) {
+        merged[model] = pricing;
+      }
+      db.run(
+        `INSERT INTO kv(scope, key, value) VALUES('pricing', ?, ?) ON CONFLICT(scope, key) DO UPDATE SET value = excluded.value`,
+        [provider, stringifyJson(merged)]
+      );
+    }
+  });
+  invalidate();
+  return await getUserPricing();
+}
+
+export async function resetPricing(provider, model) {
+  if (!provider) return await getUserPricing();
+  const db = await getAdapter();
+  db.transaction(() => {
+    if (!model) {
+      db.run(`DELETE FROM kv WHERE scope = 'pricing' AND key = ?`, [provider]);
+      return;
+    }
+    const row = db.get(`SELECT value FROM kv WHERE scope = 'pricing' AND key = ?`, [provider]);
+    const current = row ? (parseJson(row.value, {}) || {}) : {};
+    delete current[model];
+    if (Object.keys(current).length === 0) {
+      db.run(`DELETE FROM kv WHERE scope = 'pricing' AND key = ?`, [provider]);
+    } else {
+      db.run(
+        `INSERT INTO kv(scope, key, value) VALUES('pricing', ?, ?) ON CONFLICT(scope, key) DO UPDATE SET value = excluded.value`,
+        [provider, stringifyJson(current)]
+      );
+    }
+  });
+  invalidate();
+  return await getUserPricing();
+}
+
+export async function resetAllPricing() {
+  await pricingKv.clear();
+  invalidate();
+  return {};
+}

package/src/lib/db/repos/proxyPoolsRepo.js

@@ -0,0 +1,103 @@
+import { v4 as uuidv4 } from "uuid";
+import { getAdapter } from "../driver.js";
+import { parseJson, stringifyJson } from "../helpers/jsonCol.js";
+
+function rowToPool(row) {
+  if (!row) return null;
+  const extra = parseJson(row.data, {});
+  return {
+    ...extra,
+    id: row.id,
+    isActive: row.isActive === 1 || row.isActive === true,
+    testStatus: row.testStatus,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  };
+}
+
+function poolToRow(p) {
+  const { id, isActive, testStatus, createdAt, updatedAt, ...rest } = p;
+  return {
+    id,
+    isActive: isActive === false ? 0 : 1,
+    testStatus: testStatus ?? null,
+    data: stringifyJson(rest),
+    createdAt,
+    updatedAt,
+  };
+}
+
+function upsert(db, p) {
+  const r = poolToRow(p);
+  db.run(
+    `INSERT INTO proxyPools(id, isActive, testStatus, data, createdAt, updatedAt)
+     VALUES(?, ?, ?, ?, ?, ?)
+     ON CONFLICT(id) DO UPDATE SET
+       isActive=excluded.isActive, testStatus=excluded.testStatus,
+       data=excluded.data, updatedAt=excluded.updatedAt`,
+    [r.id, r.isActive, r.testStatus, r.data, r.createdAt, r.updatedAt]
+  );
+}
+
+export async function getProxyPools(filter = {}) {
+  const db = await getAdapter();
+  const where = [];
+  const params = [];
+  if (filter.isActive !== undefined) { where.push("isActive = ?"); params.push(filter.isActive ? 1 : 0); }
+  if (filter.testStatus) { where.push("testStatus = ?"); params.push(filter.testStatus); }
+  const sql = `SELECT * FROM proxyPools${where.length ? ` WHERE ${where.join(" AND ")}` : ""}`;
+  const list = db.all(sql, params).map(rowToPool);
+  list.sort((a, b) => new Date(b.updatedAt || 0) - new Date(a.updatedAt || 0));
+  return list;
+}
+
+export async function getProxyPoolById(id) {
+  const db = await getAdapter();
+  return rowToPool(db.get(`SELECT * FROM proxyPools WHERE id = ?`, [id]));
+}
+
+export async function createProxyPool(data) {
+  const db = await getAdapter();
+  const now = new Date().toISOString();
+  const pool = {
+    id: data.id || uuidv4(),
+    name: data.name,
+    proxyUrl: data.proxyUrl,
+    noProxy: data.noProxy || "",
+    type: data.type || "http",
+    isActive: data.isActive !== undefined ? data.isActive : true,
+    strictProxy: data.strictProxy === true,
+    testStatus: data.testStatus || "unknown",
+    lastTestedAt: data.lastTestedAt || null,
+    lastError: data.lastError || null,
+    createdAt: now,
+    updatedAt: now,
+  };
+  upsert(db, pool);
+  return pool;
+}
+
+export async function updateProxyPool(id, data) {
+  const db = await getAdapter();
+  let result = null;
+  db.transaction(() => {
+    const row = db.get(`SELECT * FROM proxyPools WHERE id = ?`, [id]);
+    if (!row) return;
+    const merged = { ...rowToPool(row), ...data, updatedAt: new Date().toISOString() };
+    upsert(db, merged);
+    result = merged;
+  });
+  return result;
+}
+
+export async function deleteProxyPool(id) {
+  const db = await getAdapter();
+  let removed = null;
+  db.transaction(() => {
+    const row = db.get(`SELECT * FROM proxyPools WHERE id = ?`, [id]);
+    if (!row) return;
+    removed = rowToPool(row);
+    db.run(`DELETE FROM proxyPools WHERE id = ?`, [id]);
+  });
+  return removed;
+}