totem-llm 0.1.0

package/server/models/modelRouter.js

@@ -0,0 +1,259 @@
+const { Prisma } = require("@prisma/client");
+const prisma = require("../utils/prisma");
+const { ModelRouterRule } = require("./modelRouterRule");
+
+const ModelRouter = {
+  validations: {
+    name: (value) => {
+      if (!value || typeof value !== "string") return null;
+      return String(value).trim().slice(0, 255);
+    },
+    description: (value) => {
+      if (!value || typeof value !== "string") return null;
+      return String(value).trim();
+    },
+    fallback_provider: (value) => {
+      if (!value || typeof value !== "string") return null;
+      return String(value);
+    },
+    fallback_model: (value) => {
+      if (!value || typeof value !== "string") return null;
+      return String(value);
+    },
+    cooldown_seconds: (value) => {
+      const num = Number(value);
+      if (isNaN(num) || num < 0 || num > 3600) return null;
+      return Math.round(num);
+    },
+  },
+
+  create: async function (data = {}, creatorId = null) {
+    const name = this.validations.name(data.name);
+    if (!name) return { router: null, error: "Name is required." };
+
+    const fallback_provider = this.validations.fallback_provider(
+      data.fallback_provider
+    );
+    const fallback_model = this.validations.fallback_model(data.fallback_model);
+    if (!fallback_provider || !fallback_model)
+      return {
+        router: null,
+        error: "Fallback provider and model are required.",
+      };
+
+    const { ModelRouterService } = require("../utils/router");
+    const cooldown_seconds =
+      data.cooldown_seconds != null
+        ? this.validations.cooldown_seconds(data.cooldown_seconds)
+        : ModelRouterService.DEFAULT_STICKY_MS;
+
+    try {
+      const router = await prisma.model_routers.create({
+        data: {
+          name,
+          description: this.validations.description(data.description),
+          fallback_provider,
+          fallback_model,
+          cooldown_seconds: cooldown_seconds ?? 30,
+          created_by: creatorId ? Number(creatorId) : null,
+        },
+      });
+      return { router, error: null };
+    } catch (error) {
+      console.error(error.message);
+      // P2002 is the unique constraint violation error code
+      if (
+        error instanceof Prisma.PrismaClientKnownRequestError &&
+        error.code === "P2002"
+      )
+        return {
+          router: null,
+          error: "A router with that name already exists.",
+        };
+      return { router: null, error: error.message };
+    }
+  },
+
+  get: async function (clause = {}) {
+    try {
+      const router = await prisma.model_routers.findFirst({
+        where: clause,
+      });
+      return router || null;
+    } catch (error) {
+      console.error(error.message);
+      return null;
+    }
+  },
+
+  getWithRules: async function (clause = {}) {
+    try {
+      const router = await prisma.model_routers.findFirst({
+        where: clause,
+        include: {
+          rules: {
+            orderBy: { priority: "asc" },
+          },
+        },
+      });
+      if (!router) return null;
+      return { ...router, rules: router.rules.map(ModelRouterRule._hydrate) };
+    } catch (error) {
+      console.error(error.message);
+      return null;
+    }
+  },
+
+  getWithRulesAndCount: async function (clause = {}) {
+    try {
+      const router = await prisma.model_routers.findFirst({
+        where: clause,
+        include: {
+          rules: {
+            orderBy: { priority: "asc" },
+          },
+        },
+      });
+      if (!router) return null;
+      const workspaceCount = await this.workspaceCount(router.id);
+      return {
+        ...router,
+        rules: router.rules.map(ModelRouterRule._hydrate),
+        workspaceCount,
+      };
+    } catch (error) {
+      console.error(error.message);
+      return null;
+    }
+  },
+
+  where: async function (clause = {}, limit = null, orderBy = null) {
+    try {
+      const results = await prisma.model_routers.findMany({
+        where: clause,
+        ...(limit !== null ? { take: limit } : {}),
+        ...(orderBy !== null ? { orderBy } : { orderBy: { createdAt: "asc" } }),
+      });
+      return results;
+    } catch (error) {
+      console.error(error.message);
+      return [];
+    }
+  },
+
+  /**
+   * Get all model routers with their rule and workspace counts.
+   * @returns {Promise<Array<{id: number, name: string, description: string, fallback_provider: string, fallback_model: string, cooldown_seconds: number, createdAt: Date, ruleCount: number, workspaceCount: number}>>}
+   */
+  getAllWithCounts: async function () {
+    try {
+      const routers = await prisma.model_routers.findMany({
+        orderBy: { createdAt: "asc" },
+        include: {
+          _count: {
+            select: {
+              rules: true,
+            },
+          },
+        },
+      });
+      const results = await Promise.all(
+        routers.map(async ({ _count, ...router }) => ({
+          ...router,
+          ruleCount: _count.rules,
+          workspaceCount: await this.workspaceCount(router.id),
+        }))
+      );
+      return results;
+    } catch (error) {
+      console.error(error.message);
+      return [];
+    }
+  },
+
+  update: async function (id = null, data = {}) {
+    if (!id) throw new Error("No router id provided for update");
+
+    const updates = {};
+    if (data.name !== undefined) {
+      const name = this.validations.name(data.name);
+      if (!name) return { router: null, error: "Name cannot be empty." };
+      updates.name = name;
+    }
+    if (data.description !== undefined)
+      updates.description = this.validations.description(data.description);
+    if (data.fallback_provider !== undefined) {
+      const provider = this.validations.fallback_provider(
+        data.fallback_provider
+      );
+      if (!provider)
+        return { router: null, error: "Fallback provider is required." };
+      updates.fallback_provider = provider;
+    }
+    if (data.fallback_model !== undefined) {
+      const model = this.validations.fallback_model(data.fallback_model);
+      if (!model) return { router: null, error: "Fallback model is required." };
+      updates.fallback_model = model;
+    }
+    if (data.cooldown_seconds !== undefined) {
+      const cooldown = this.validations.cooldown_seconds(data.cooldown_seconds);
+      if (cooldown === null)
+        return {
+          router: null,
+          error: "Cooldown must be a number between 0 and 3600.",
+        };
+      updates.cooldown_seconds = cooldown;
+    }
+
+    if (Object.keys(updates).length === 0)
+      return { router: { id }, error: "No valid fields to update." };
+
+    try {
+      const router = await prisma.model_routers.update({
+        where: { id: Number(id) },
+        data: updates,
+      });
+      return { router, error: null };
+    } catch (error) {
+      console.error(error.message);
+      // P2002 is the unique constraint violation error code
+      if (
+        error instanceof Prisma.PrismaClientKnownRequestError &&
+        error.code === "P2002"
+      )
+        return {
+          router: null,
+          error: "A router with that name already exists.",
+        };
+      return { router: null, error: error.message };
+    }
+  },
+
+  delete: async function (id = null) {
+    if (!id) return false;
+
+    try {
+      await prisma.model_routers.delete({
+        where: { id: Number(id) },
+      });
+      return true;
+    } catch (error) {
+      console.error(error.message);
+      return false;
+    }
+  },
+
+  workspaceCount: async function (routerId) {
+    try {
+      const count = await prisma.workspaces.count({
+        where: { router_id: Number(routerId) },
+      });
+      return count;
+    } catch (error) {
+      console.error(error.message);
+      return 0;
+    }
+  },
+};
+
+module.exports = { ModelRouter };

package/server/models/modelRouterRule.js

@@ -0,0 +1,336 @@
+const { Prisma } = require("@prisma/client");
+const prisma = require("../utils/prisma");
+const { safeJsonParse } = require("../utils/http");
+
+const VALID_TYPES = ["calculated", "llm"];
+const VALID_PROPERTIES = [
+  "promptContent",
+  "conversationTokenCount",
+  "conversationMessageCount",
+  "currentHour",
+  "hasImageAttachment",
+];
+const VALID_COMPARATORS = [
+  "contains",
+  "matches",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "eq",
+  "neq",
+  "between",
+];
+const VALID_CONDITION_LOGIC = ["AND"];
+const TITLE_REGEX = /^[a-z0-9_]+$/;
+
+const ModelRouterRule = {
+  VALID_TYPES,
+  VALID_PROPERTIES,
+  VALID_COMPARATORS,
+  VALID_CONDITION_LOGIC,
+
+  create: async function (routerId, data = {}, creatorId = null) {
+    if (!routerId) return { rule: null, error: "Router ID is required." };
+
+    const title = this._validateTitle(data.title);
+    if (!title)
+      return {
+        rule: null,
+        error: "Title is required and must be lowercase with underscores only.",
+      };
+
+    const type = VALID_TYPES.includes(data.type) ? data.type : null;
+    if (!type)
+      return {
+        rule: null,
+        error: `Type must be one of: ${VALID_TYPES.join(", ")}`,
+      };
+
+    let conditionLogic = null;
+    let serializedConditions = null;
+
+    if (type === "calculated") {
+      const validated = this._validateConditions(
+        data.condition_logic,
+        data.conditions
+      );
+      if (validated.error) return { rule: null, error: validated.error };
+      conditionLogic = validated.condition_logic;
+      serializedConditions = validated.serialized;
+    } else if (type === "llm") {
+      if (!data.description || !data.description.trim())
+        return {
+          rule: null,
+          error:
+            "Description is required for LLM rules. Describe when this rule should match.",
+        };
+    }
+
+    if (!data.route_provider || !data.route_model)
+      return {
+        rule: null,
+        error: "Route provider and model are required.",
+      };
+
+    try {
+      const rule = await prisma.model_router_rules.create({
+        data: {
+          router_id: Number(routerId),
+          enabled: true, // new rules are always enabled
+          priority: Number(data.priority),
+          type,
+          title,
+          description: data.description || null,
+          condition_logic: conditionLogic,
+          conditions: serializedConditions,
+          route_provider: String(data.route_provider),
+          route_model: String(data.route_model),
+          created_by: creatorId ? Number(creatorId) : null,
+        },
+      });
+      return { rule: this._hydrate(rule), error: null };
+    } catch (error) {
+      console.error(error.message);
+      return (
+        handleUniqueConstraintError(error) || {
+          rule: null,
+          error: error.message,
+        }
+      );
+    }
+  },
+
+  get: async function (clause = {}) {
+    try {
+      const rule = await prisma.model_router_rules.findFirst({
+        where: clause,
+      });
+      return this._hydrate(rule);
+    } catch (error) {
+      console.error(error.message);
+      return null;
+    }
+  },
+
+  where: async function (clause = {}, limit = null, orderBy = null) {
+    try {
+      const results = await prisma.model_router_rules.findMany({
+        where: clause,
+        ...(limit !== null ? { take: limit } : {}),
+        ...(orderBy !== null ? { orderBy } : {}),
+      });
+      return results.map((r) => this._hydrate(r));
+    } catch (error) {
+      console.error(error.message);
+      return [];
+    }
+  },
+
+  /**
+   * Get all rules for a given router, ordered by priority.
+   * -> delegate to the where method
+   * @param {number} routerId
+   * @returns {Promise<Array<{id: number, title: string, description: string, enabled: boolean, priority: number, type: string, route_provider: string, route_model: string, created_by: number, createdAt: Date, lastUpdatedAt: Date}>>}
+   */
+  forRouter: async function (routerId) {
+    return this.where({ router_id: Number(routerId) }, null, {
+      priority: "asc",
+    });
+  },
+
+  update: async function (id = null, data = {}) {
+    if (!id) throw new Error("No rule id provided for update");
+
+    const updates = {};
+
+    if (data.title !== undefined) {
+      const title = this._validateTitle(data.title);
+      if (!title)
+        return {
+          rule: null,
+          error: "Title must be lowercase with underscores only.",
+        };
+      updates.title = title;
+    }
+
+    const simpleFields = [
+      ["enabled", (v) => Boolean(v)],
+      ["priority", (v) => Number(v)],
+      ["description", (v) => v || null],
+      ["route_provider", (v) => String(v)],
+      ["route_model", (v) => String(v)],
+    ];
+    for (const [key, map] of simpleFields) {
+      if (data[key] !== undefined) updates[key] = map(data[key]);
+    }
+
+    const typeErr = assignEnum(updates, data, "type", VALID_TYPES, "Type");
+    if (typeErr) return typeErr;
+
+    // Conditions are only meaningful for calculated rules. When either
+    // condition_logic or conditions is provided we revalidate the pair
+    // together so we never persist a half-updated rule.
+    if (data.condition_logic !== undefined || data.conditions !== undefined) {
+      const effectiveType = updates.type || data.type;
+      if (effectiveType === "llm") {
+        updates.condition_logic = null;
+        updates.conditions = null;
+      } else {
+        const validated = this._validateConditions(
+          data.condition_logic,
+          data.conditions
+        );
+        if (validated.error) return { rule: null, error: validated.error };
+        updates.condition_logic = validated.condition_logic;
+        updates.conditions = validated.serialized;
+      }
+    }
+
+    if (Object.keys(updates).length === 0)
+      return { rule: { id }, error: "No valid fields to update." };
+
+    try {
+      const rule = await prisma.model_router_rules.update({
+        where: { id: Number(id) },
+        data: updates,
+      });
+      return { rule: this._hydrate(rule), error: null };
+    } catch (error) {
+      console.error(error.message);
+      return (
+        handleUniqueConstraintError(error) || {
+          rule: null,
+          error: error.message,
+        }
+      );
+    }
+  },
+
+  delete: async function (id = null) {
+    if (!id) return false;
+    try {
+      await prisma.model_router_rules.delete({
+        where: { id: Number(id) },
+      });
+      return true;
+    } catch (error) {
+      console.error(error.message);
+      return false;
+    }
+  },
+
+  /**
+   * Bulk update priorities for rules within a router.
+   * @param {Array<{id: number, priority: number}>} ruleUpdates
+   */
+  reorderRules: async function (ruleUpdates = []) {
+    try {
+      await prisma.$transaction(
+        ruleUpdates.map(({ id, priority }) =>
+          prisma.model_router_rules.update({
+            where: { id: Number(id) },
+            data: { priority: Number(priority) },
+          })
+        )
+      );
+      return { success: true, error: null };
+    } catch (error) {
+      console.error(error.message);
+      return { success: false, error: error.message };
+    }
+  },
+
+  _validateTitle: function (title) {
+    if (!title || typeof title !== "string") return null;
+    const cleaned = title.trim().toLowerCase();
+    if (!TITLE_REGEX.test(cleaned)) return null;
+    return cleaned;
+  },
+
+  /**
+   * Validate a (condition_logic, conditions[]) pair for calculated rules.
+   * Returns either `{ error }` or `{ condition_logic, serialized }`.
+   */
+  _validateConditions: function (logic, conditions) {
+    if (!VALID_CONDITION_LOGIC.includes(logic))
+      return {
+        error: `Condition logic must be one of: ${VALID_CONDITION_LOGIC.join(", ")}`,
+      };
+    if (!Array.isArray(conditions) || conditions.length === 0)
+      return { error: "At least one condition is required." };
+
+    const normalized = [];
+    for (const [i, c] of conditions.entries()) {
+      const cond = c || {};
+      if (!VALID_PROPERTIES.includes(cond.property))
+        return {
+          error: `Condition ${i + 1}: property must be one of: ${VALID_PROPERTIES.join(", ")}`,
+        };
+      if (!VALID_COMPARATORS.includes(cond.comparator))
+        return {
+          error: `Condition ${i + 1}: comparator must be one of: ${VALID_COMPARATORS.join(", ")}`,
+        };
+      if (
+        cond.value === undefined ||
+        cond.value === null ||
+        String(cond.value) === ""
+      )
+        return { error: `Condition ${i + 1}: value is required.` };
+      normalized.push({
+        property: cond.property,
+        comparator: cond.comparator,
+        value: String(cond.value),
+      });
+    }
+
+    return {
+      condition_logic: logic,
+      serialized: JSON.stringify(normalized),
+    };
+  },
+
+  /**
+   * Parse the stored JSON `conditions` string into an array so every consumer
+   * (API responses, evaluator, UI) works with the same shape. Safe on null and
+   * on rule types that don't use conditions.
+   */
+  _hydrate: function (rule) {
+    if (!rule) return null;
+    return { ...rule, conditions: safeJsonParse(rule.conditions, null) };
+  },
+};
+
+function assignEnum(updates, data, key, validList, label) {
+  if (data[key] === undefined) return null;
+  if (!validList.includes(data[key]))
+    return {
+      rule: null,
+      error: `${label} must be one of: ${validList.join(", ")}`,
+    };
+  updates[key] = data[key];
+  return null;
+}
+
+function handleUniqueConstraintError(error) {
+  if (
+    !(error instanceof Prisma.PrismaClientKnownRequestError) ||
+    error.code !== "P2002"
+  )
+    return null;
+
+  const target = error.meta?.target;
+  if (target?.includes("title"))
+    return {
+      rule: null,
+      error: "A rule with that title already exists on this router.",
+    };
+  if (target?.includes("priority"))
+    return {
+      rule: null,
+      error: "A rule with that priority already exists on this router.",
+    };
+  return { rule: null, error: "Duplicate rule constraint violated." };
+}
+
+module.exports = { ModelRouterRule };

package/server/models/passwordRecovery.js

@@ -0,0 +1,115 @@
+const { v4 } = require("uuid");
+const prisma = require("../utils/prisma");
+const bcrypt = require("bcryptjs");
+
+const RecoveryCode = {
+  tablename: "recovery_codes",
+  writable: [],
+  create: async function (userId, code) {
+    try {
+      const codeHash = await bcrypt.hash(code, 10);
+      const recoveryCode = await prisma.recovery_codes.create({
+        data: { user_id: userId, code_hash: codeHash },
+      });
+      return { recoveryCode, error: null };
+    } catch (error) {
+      console.error("FAILED TO CREATE RECOVERY CODE.", error.message);
+      return { recoveryCode: null, error: error.message };
+    }
+  },
+  createMany: async function (data) {
+    try {
+      const recoveryCodes = await prisma.$transaction(
+        data.map((recoveryCode) =>
+          prisma.recovery_codes.create({ data: recoveryCode })
+        )
+      );
+      return { recoveryCodes, error: null };
+    } catch (error) {
+      console.error("FAILED TO CREATE RECOVERY CODES.", error.message);
+      return { recoveryCodes: null, error: error.message };
+    }
+  },
+  findFirst: async function (clause = {}) {
+    try {
+      const recoveryCode = await prisma.recovery_codes.findFirst({
+        where: clause,
+      });
+      return recoveryCode;
+    } catch (error) {
+      console.error("FAILED TO FIND RECOVERY CODE.", error.message);
+      return null;
+    }
+  },
+  findMany: async function (clause = {}) {
+    try {
+      const recoveryCodes = await prisma.recovery_codes.findMany({
+        where: clause,
+      });
+      return recoveryCodes;
+    } catch (error) {
+      console.error("FAILED TO FIND RECOVERY CODES.", error.message);
+      return null;
+    }
+  },
+  deleteMany: async function (clause = {}) {
+    try {
+      await prisma.recovery_codes.deleteMany({ where: clause });
+      return true;
+    } catch (error) {
+      console.error("FAILED TO DELETE RECOVERY CODES.", error.message);
+      return false;
+    }
+  },
+  hashesForUser: async function (userId = null) {
+    if (!userId) return [];
+    return (await this.findMany({ user_id: userId })).map(
+      (recovery) => recovery.code_hash
+    );
+  },
+};
+
+const PasswordResetToken = {
+  tablename: "password_reset_tokens",
+  resetExpiryMs: 600_000, // 10 minutes in ms;
+  writable: [],
+  calcExpiry: function () {
+    return new Date(Date.now() + this.resetExpiryMs);
+  },
+  create: async function (userId) {
+    try {
+      const passwordResetToken = await prisma.password_reset_tokens.create({
+        data: { user_id: userId, token: v4(), expiresAt: this.calcExpiry() },
+      });
+      return { passwordResetToken, error: null };
+    } catch (error) {
+      console.error("FAILED TO CREATE PASSWORD RESET TOKEN.", error.message);
+      return { passwordResetToken: null, error: error.message };
+    }
+  },
+  findUnique: async function (clause = {}) {
+    try {
+      const passwordResetToken = await prisma.password_reset_tokens.findUnique({
+        where: clause,
+      });
+      return passwordResetToken;
+    } catch (error) {
+      console.error("FAILED TO FIND PASSWORD RESET TOKEN.", error.message);
+      return null;
+    }
+  },
+  deleteMany: async function (clause = {}) {
+    try {
+      await prisma.password_reset_tokens.deleteMany({ where: clause });
+      return true;
+    } catch (error) {
+      console.error("FAILED TO DELETE PASSWORD RESET TOKEN.", error.message);
+      return false;
+    }
+  },
+};
+
+module.exports = {
+  RecoveryCode,
+  PasswordResetToken,
+};