@jskit-ai/assistant 0.1.4

package/src/server/repositories/conversationsRepository.js

@@ -0,0 +1,244 @@
+import { parsePositiveInteger } from "@jskit-ai/kernel/server/runtime";
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import {
+  parseJsonObject,
+  stringifyJsonObject,
+  toIso,
+  resolveInsertedId
+} from "./repositoryPersistenceUtils.js";
+
+function mapConversationRow(row = {}) {
+  return {
+    id: Number(row.id),
+    workspaceId: Number(row.workspace_id),
+    workspaceSlug: String(row.workspace_slug || ""),
+    workspaceName: String(row.workspace_name || ""),
+    title: String(row.title || "New conversation"),
+    createdByUserId: row.created_by_user_id == null ? null : Number(row.created_by_user_id),
+    createdByUserDisplayName: String(row.created_by_user_display_name || ""),
+    createdByUserEmail: String(row.created_by_user_email || ""),
+    status: String(row.status || "active"),
+    provider: String(row.provider || ""),
+    model: String(row.model || ""),
+    surfaceId: String(row.surface_id || ""),
+    startedAt: toIso(row.started_at),
+    endedAt: row.ended_at ? toIso(row.ended_at) : null,
+    messageCount: Number(row.message_count || 0),
+    metadata: parseJsonObject(row.metadata_json),
+    createdAt: toIso(row.created_at),
+    updatedAt: toIso(row.updated_at)
+  };
+}
+
+function normalizeCursorPagination(pagination = {}, { defaultLimit = 20, maxLimit = 200 } = {}) {
+  const cursor = parsePositiveInteger(pagination.cursor) || 0;
+  const limit = Math.max(1, Math.min(maxLimit, parsePositiveInteger(pagination.limit) || defaultLimit));
+
+  return {
+    cursor,
+    limit
+  };
+}
+
+function createConversationBaseQuery(client) {
+  return client("ai_conversations as c")
+    .leftJoin("workspaces as w", "w.id", "c.workspace_id")
+    .leftJoin("user_profiles as u", "u.id", "c.created_by_user_id")
+    .select(
+      "c.*",
+      client.raw("COALESCE(w.slug, '') AS workspace_slug"),
+      client.raw("COALESCE(w.name, '') AS workspace_name"),
+      client.raw("COALESCE(u.display_name, '') AS created_by_user_display_name"),
+      client.raw("COALESCE(u.email, '') AS created_by_user_email")
+    );
+}
+
+function createConversationsRepository(knex) {
+  if (!knex || typeof knex !== "function") {
+    throw new Error("createConversationsRepository requires knex client.");
+  }
+
+  async function findById(conversationId, options = {}) {
+    const numericConversationId = parsePositiveInteger(conversationId);
+    if (!numericConversationId) {
+      return null;
+    }
+
+    const client = options?.trx || knex;
+    const row = await createConversationBaseQuery(client)
+      .where("c.id", numericConversationId)
+      .first();
+
+    return row ? mapConversationRow(row) : null;
+  }
+
+  async function findByIdForWorkspaceAndUser(conversationId, workspaceId, actorUserId, options = {}) {
+    const numericConversationId = parsePositiveInteger(conversationId);
+    const numericWorkspaceId = parsePositiveInteger(workspaceId);
+    const numericActorUserId = parsePositiveInteger(actorUserId);
+    if (!numericConversationId || !numericWorkspaceId || !numericActorUserId) {
+      return null;
+    }
+
+    const client = options?.trx || knex;
+    const row = await createConversationBaseQuery(client)
+      .where("c.id", numericConversationId)
+      .where("c.workspace_id", numericWorkspaceId)
+      .where("c.created_by_user_id", numericActorUserId)
+      .first();
+
+    return row ? mapConversationRow(row) : null;
+  }
+
+  async function create(payload = {}, options = {}) {
+    const client = options?.trx || knex;
+    const now = new Date();
+    const insertResult = await client("ai_conversations").insert({
+      workspace_id: parsePositiveInteger(payload.workspaceId),
+      created_by_user_id: parsePositiveInteger(payload.createdByUserId) || null,
+      title: normalizeText(payload.title) || "New conversation",
+      status: normalizeText(payload.status).toLowerCase() || "active",
+      provider: normalizeText(payload.provider),
+      model: normalizeText(payload.model),
+      surface_id: normalizeText(payload.surfaceId).toLowerCase() || "admin",
+      message_count: parsePositiveInteger(payload.messageCount) || 0,
+      metadata_json: stringifyJsonObject(payload.metadata),
+      started_at: payload.startedAt ? new Date(payload.startedAt) : now,
+      ended_at: payload.endedAt ? new Date(payload.endedAt) : null,
+      created_at: now,
+      updated_at: now
+    });
+    const id = resolveInsertedId(insertResult);
+    if (!id) {
+      throw new Error("conversationsRepository.create could not resolve inserted id.");
+    }
+
+    return findById(id, {
+      trx: client
+    });
+  }
+
+  async function updateById(conversationId, patch = {}, options = {}) {
+    const numericConversationId = parsePositiveInteger(conversationId);
+    if (!numericConversationId) {
+      return null;
+    }
+
+    const client = options?.trx || knex;
+    const updatePatch = {};
+
+    if (Object.hasOwn(patch, "title")) {
+      updatePatch.title = normalizeText(patch.title) || "New conversation";
+    }
+    if (Object.hasOwn(patch, "status")) {
+      updatePatch.status = normalizeText(patch.status).toLowerCase() || "active";
+    }
+    if (Object.hasOwn(patch, "provider")) {
+      updatePatch.provider = normalizeText(patch.provider);
+    }
+    if (Object.hasOwn(patch, "model")) {
+      updatePatch.model = normalizeText(patch.model);
+    }
+    if (Object.hasOwn(patch, "surfaceId")) {
+      updatePatch.surface_id = normalizeText(patch.surfaceId).toLowerCase() || "admin";
+    }
+    if (Object.hasOwn(patch, "messageCount")) {
+      updatePatch.message_count = Math.max(0, Number(patch.messageCount || 0));
+    }
+    if (Object.hasOwn(patch, "endedAt")) {
+      updatePatch.ended_at = patch.endedAt ? new Date(patch.endedAt) : null;
+    }
+    if (Object.hasOwn(patch, "metadata")) {
+      updatePatch.metadata_json = stringifyJsonObject(patch.metadata);
+    }
+
+    if (Object.keys(updatePatch).length > 0) {
+      updatePatch.updated_at = new Date();
+      await client("ai_conversations").where({ id: numericConversationId }).update(updatePatch);
+    }
+
+    return findById(numericConversationId, {
+      trx: client
+    });
+  }
+
+  async function incrementMessageCount(conversationId, delta = 1, options = {}) {
+    const numericConversationId = parsePositiveInteger(conversationId);
+    if (!numericConversationId) {
+      return null;
+    }
+
+    const client = options?.trx || knex;
+    const incrementBy = Number.isInteger(Number(delta)) ? Number(delta) : 1;
+    await client("ai_conversations")
+      .where({ id: numericConversationId })
+      .update({
+        message_count: client.raw("GREATEST(0, message_count + ?)", [incrementBy]),
+        updated_at: new Date()
+      });
+
+    return findById(numericConversationId, {
+      trx: client
+    });
+  }
+
+  async function listForWorkspaceAndUser(workspaceId, actorUserId, pagination = {}, filters = {}, options = {}) {
+    const numericWorkspaceId = parsePositiveInteger(workspaceId);
+    const numericActorUserId = parsePositiveInteger(actorUserId);
+    if (!numericWorkspaceId || !numericActorUserId) {
+      return {
+        items: [],
+        nextCursor: null
+      };
+    }
+
+    const client = options?.trx || knex;
+    const { cursor, limit } = normalizeCursorPagination(pagination);
+
+    let query = createConversationBaseQuery(client)
+      .where("c.workspace_id", numericWorkspaceId)
+      .where("c.created_by_user_id", numericActorUserId);
+
+    const normalizedStatus = normalizeText(filters.status).toLowerCase();
+    if (normalizedStatus) {
+      query = query.where("c.status", normalizedStatus);
+    }
+    if (cursor > 0) {
+      query = query.where("c.id", "<", cursor);
+    }
+
+    const rows = await query
+      .orderBy("c.id", "desc")
+      .limit(limit + 1);
+
+    const hasMore = rows.length > limit;
+    const pageRows = hasMore ? rows.slice(0, limit) : rows;
+    const items = pageRows.map(mapConversationRow);
+    const nextCursor = hasMore && pageRows.length > 0 ? String(pageRows[pageRows.length - 1].id) : null;
+
+    return {
+      items,
+      nextCursor
+    };
+  }
+
+  async function transaction(callback) {
+    if (typeof knex.transaction !== "function") {
+      return callback(knex);
+    }
+
+    return knex.transaction(callback);
+  }
+
+  return Object.freeze({
+    findById,
+    findByIdForWorkspaceAndUser,
+    create,
+    updateById,
+    incrementMessageCount,
+    listForWorkspaceAndUser,
+    transaction
+  });
+}
+
+export { createConversationsRepository as createRepository, createConversationsRepository };

package/src/server/repositories/messagesRepository.js

@@ -0,0 +1,154 @@
+import { parsePositiveInteger } from "@jskit-ai/kernel/server/runtime";
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import {
+  parseJsonObject,
+  stringifyJsonObject,
+  toIso,
+  resolveInsertedId
+} from "./repositoryPersistenceUtils.js";
+
+function mapMessageRow(row = {}) {
+  return {
+    id: Number(row.id),
+    conversationId: Number(row.conversation_id),
+    workspaceId: Number(row.workspace_id),
+    seq: Number(row.seq),
+    role: String(row.role || ""),
+    kind: String(row.kind || "chat"),
+    clientMessageId: String(row.client_message_id || ""),
+    actorUserId: row.actor_user_id == null ? null : Number(row.actor_user_id),
+    contentText: row.content_text == null ? null : String(row.content_text),
+    metadata: parseJsonObject(row.metadata_json),
+    createdAt: toIso(row.created_at)
+  };
+}
+
+function normalizePagination(pagination = {}, { defaultPage = 1, defaultPageSize = 200, maxPageSize = 500 } = {}) {
+  const page = Math.max(1, parsePositiveInteger(pagination.page) || defaultPage);
+  const pageSize = Math.max(1, Math.min(maxPageSize, parsePositiveInteger(pagination.pageSize) || defaultPageSize));
+
+  return {
+    page,
+    pageSize
+  };
+}
+
+async function resolveNextSequence(client, conversationId) {
+  const row = await client("ai_messages").where({ conversation_id: conversationId }).max({ maxSeq: "seq" }).first();
+  const maxSeq = Number(row?.maxSeq || 0);
+  if (!Number.isInteger(maxSeq) || maxSeq < 0) {
+    return 1;
+  }
+
+  return maxSeq + 1;
+}
+
+function createMessagesRepository(knex) {
+  if (!knex || typeof knex !== "function") {
+    throw new Error("createMessagesRepository requires knex client.");
+  }
+
+  async function findById(messageId, options = {}) {
+    const numericMessageId = parsePositiveInteger(messageId);
+    if (!numericMessageId) {
+      return null;
+    }
+
+    const client = options?.trx || knex;
+    const row = await client("ai_messages").where({ id: numericMessageId }).first();
+    return row ? mapMessageRow(row) : null;
+  }
+
+  async function create(payload = {}, options = {}) {
+    const client = options?.trx || knex;
+    const conversationId = parsePositiveInteger(payload.conversationId);
+    const workspaceId = parsePositiveInteger(payload.workspaceId);
+    if (!conversationId || !workspaceId) {
+      throw new TypeError("messagesRepository.create requires conversationId and workspaceId.");
+    }
+
+    const seq = parsePositiveInteger(payload.seq) || (await resolveNextSequence(client, conversationId));
+    const insertResult = await client("ai_messages").insert({
+      conversation_id: conversationId,
+      workspace_id: workspaceId,
+      seq,
+      role: normalizeText(payload.role).toLowerCase(),
+      kind: normalizeText(payload.kind).toLowerCase() || "chat",
+      client_message_id: normalizeText(payload.clientMessageId),
+      actor_user_id: parsePositiveInteger(payload.actorUserId) || null,
+      content_text: payload.contentText == null ? null : String(payload.contentText),
+      metadata_json: stringifyJsonObject(payload.metadata),
+      created_at: payload.createdAt ? new Date(payload.createdAt) : new Date()
+    });
+    const id = resolveInsertedId(insertResult);
+    if (!id) {
+      throw new Error("messagesRepository.create could not resolve inserted id.");
+    }
+
+    return findById(id, {
+      trx: client
+    });
+  }
+
+  async function countByConversationForWorkspace(conversationId, workspaceId, options = {}) {
+    const numericConversationId = parsePositiveInteger(conversationId);
+    const numericWorkspaceId = parsePositiveInteger(workspaceId);
+    if (!numericConversationId || !numericWorkspaceId) {
+      return 0;
+    }
+
+    const client = options?.trx || knex;
+    const row = await client("ai_messages")
+      .where({
+        conversation_id: numericConversationId,
+        workspace_id: numericWorkspaceId
+      })
+      .count({ total: "*" })
+      .first();
+
+    const total = Number(row?.total || 0);
+    return Number.isFinite(total) && total > 0 ? total : 0;
+  }
+
+  async function listByConversationForWorkspace(conversationId, workspaceId, pagination = {}, options = {}) {
+    const numericConversationId = parsePositiveInteger(conversationId);
+    const numericWorkspaceId = parsePositiveInteger(workspaceId);
+    if (!numericConversationId || !numericWorkspaceId) {
+      return [];
+    }
+
+    const client = options?.trx || knex;
+    const { page, pageSize } = normalizePagination(pagination);
+    const offset = (page - 1) * pageSize;
+
+    const rows = await client("ai_messages")
+      .where({
+        conversation_id: numericConversationId,
+        workspace_id: numericWorkspaceId
+      })
+      .orderBy("seq", "asc")
+      .orderBy("id", "asc")
+      .limit(pageSize)
+      .offset(offset);
+
+    return rows.map(mapMessageRow);
+  }
+
+  async function transaction(callback) {
+    if (typeof knex.transaction !== "function") {
+      return callback(knex);
+    }
+
+    return knex.transaction(callback);
+  }
+
+  return Object.freeze({
+    findById,
+    create,
+    countByConversationForWorkspace,
+    listByConversationForWorkspace,
+    transaction
+  });
+}
+
+export { createMessagesRepository as createRepository, createMessagesRepository };

package/src/server/repositories/repositoryPersistenceUtils.js

@@ -0,0 +1,63 @@
+function parseJsonObject(value) {
+  if (value == null) {
+    return {};
+  }
+
+  try {
+    const parsed = typeof value === "string" ? JSON.parse(value) : value;
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return {};
+    }
+
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+
+function stringifyJsonObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+
+  return JSON.stringify(value);
+}
+
+function toIso(value) {
+  if (!value) {
+    return "";
+  }
+
+  const date = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    return "";
+  }
+
+  return date.toISOString();
+}
+
+function resolveInsertedId(insertResult) {
+  if (Array.isArray(insertResult) && insertResult.length > 0) {
+    const first = insertResult[0];
+    if (first && typeof first === "object" && !Array.isArray(first)) {
+      const objectId = Number(first.id);
+      if (Number.isInteger(objectId) && objectId > 0) {
+        return objectId;
+      }
+    }
+
+    const scalarId = Number(first);
+    if (Number.isInteger(scalarId) && scalarId > 0) {
+      return scalarId;
+    }
+  }
+
+  const directId = Number(insertResult);
+  if (Number.isInteger(directId) && directId > 0) {
+    return directId;
+  }
+
+  return 0;
+}
+
+export { parseJsonObject, stringifyJsonObject, toIso, resolveInsertedId };

package/src/server/services/assistantSettingsService.js

@@ -0,0 +1,153 @@
+import { parsePositiveInteger } from "@jskit-ai/kernel/server/runtime";
+import { normalizeObjectInput } from "@jskit-ai/kernel/shared/validators";
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { pickOwnProperties } from "@jskit-ai/kernel/shared/support";
+import {
+  ASSISTANT_CONSOLE_SETTINGS_CHANGED_EVENT,
+  ASSISTANT_WORKSPACE_SETTINGS_CHANGED_EVENT
+} from "../../shared/settingsEvents.js";
+
+const serviceEvents = Object.freeze({
+  updateConsoleSettings: Object.freeze([
+    Object.freeze({
+      type: "entity.changed",
+      source: "assistant",
+      entity: "console.settings",
+      operation: "updated",
+      entityId: 1,
+      realtime: Object.freeze({
+        event: ASSISTANT_CONSOLE_SETTINGS_CHANGED_EVENT,
+        audience: "all_users"
+      })
+    })
+  ]),
+  updateWorkspaceSettings: Object.freeze([
+    Object.freeze({
+      type: "entity.changed",
+      source: "assistant",
+      entity: "workspace.settings",
+      operation: "updated",
+      entityId: ({ args }) => args?.[0]?.id || null,
+      realtime: Object.freeze({
+        event: ASSISTANT_WORKSPACE_SETTINGS_CHANGED_EVENT,
+        audience: "event_scope",
+        payload: ({ args }) => ({
+          workspaceSlug: String(args?.[0]?.slug || "").trim()
+        })
+      })
+    })
+  ])
+});
+
+function normalizeSurface(value) {
+  return normalizeText(value).toLowerCase();
+}
+
+function mapConsoleResponse(record = {}) {
+  return {
+    settings: {
+      workspaceSurfacePrompt: String(record.workspaceSurfacePrompt || "")
+    }
+  };
+}
+
+function mapWorkspaceResponse(record = {}) {
+  return {
+    settings: {
+      appSurfacePrompt: String(record.appSurfacePrompt || "")
+    }
+  };
+}
+
+function createService({ assistantSettingsRepository, consoleService } = {}) {
+  if (!assistantSettingsRepository || typeof assistantSettingsRepository.ensureConsoleSettings !== "function") {
+    throw new Error("assistantSettingsService requires assistantSettingsRepository.ensureConsoleSettings().");
+  }
+  if (!assistantSettingsRepository || typeof assistantSettingsRepository.ensureWorkspaceSettings !== "function") {
+    throw new Error("assistantSettingsService requires assistantSettingsRepository.ensureWorkspaceSettings().");
+  }
+  if (!assistantSettingsRepository || typeof assistantSettingsRepository.updateConsoleSettings !== "function") {
+    throw new Error("assistantSettingsService requires assistantSettingsRepository.updateConsoleSettings().");
+  }
+  if (!assistantSettingsRepository || typeof assistantSettingsRepository.updateWorkspaceSettings !== "function") {
+    throw new Error("assistantSettingsService requires assistantSettingsRepository.updateWorkspaceSettings().");
+  }
+  if (!consoleService || typeof consoleService.requireConsoleOwner !== "function") {
+    throw new Error("assistantSettingsService requires consoleService.requireConsoleOwner().");
+  }
+
+  async function getConsoleSettings(options = {}) {
+    await consoleService.requireConsoleOwner(options?.context, options);
+    const settings = await assistantSettingsRepository.ensureConsoleSettings(options);
+    return mapConsoleResponse(settings);
+  }
+
+  async function updateConsoleSettings(payload = {}, options = {}) {
+    await consoleService.requireConsoleOwner(options?.context, options);
+    const source = normalizeObjectInput(payload);
+    const patch = pickOwnProperties(source, ["workspaceSurfacePrompt"]);
+    if (Object.keys(patch).length < 1) {
+      const settings = await assistantSettingsRepository.ensureConsoleSettings(options);
+      return mapConsoleResponse(settings);
+    }
+    const settings = await assistantSettingsRepository.updateConsoleSettings({
+      workspaceSurfacePrompt: String(patch.workspaceSurfacePrompt || "")
+    }, options);
+    return mapConsoleResponse(settings);
+  }
+
+  async function getWorkspaceSettings(workspace, options = {}) {
+    const workspaceId = parsePositiveInteger(workspace?.id);
+    if (!workspaceId) {
+      throw new Error("assistantSettingsService.getWorkspaceSettings requires workspace.id.");
+    }
+
+    const settings = await assistantSettingsRepository.ensureWorkspaceSettings(workspaceId, options);
+    return mapWorkspaceResponse(settings);
+  }
+
+  async function updateWorkspaceSettings(workspace, payload = {}, options = {}) {
+    const workspaceId = parsePositiveInteger(workspace?.id);
+    if (!workspaceId) {
+      throw new Error("assistantSettingsService.updateWorkspaceSettings requires workspace.id.");
+    }
+
+    const source = normalizeObjectInput(payload);
+    const patch = pickOwnProperties(source, ["appSurfacePrompt"]);
+    if (Object.keys(patch).length < 1) {
+      const settings = await assistantSettingsRepository.ensureWorkspaceSettings(workspaceId, options);
+      return mapWorkspaceResponse(settings);
+    }
+    const settings = await assistantSettingsRepository.updateWorkspaceSettings(
+      workspaceId,
+      {
+        appSurfacePrompt: String(patch.appSurfacePrompt || "")
+      },
+      options
+    );
+
+    return mapWorkspaceResponse(settings);
+  }
+
+  async function resolveSystemPrompt(workspace, { surface = "" } = {}, options = {}) {
+    const normalizedSurface = normalizeSurface(surface);
+
+    if (normalizedSurface === "app") {
+      const workspaceSettings = await getWorkspaceSettings(workspace, options);
+      return String(workspaceSettings?.settings?.appSurfacePrompt || "");
+    }
+
+    const consoleSettings = await assistantSettingsRepository.ensureConsoleSettings(options);
+    return String(consoleSettings.workspaceSurfacePrompt || "");
+  }
+
+  return Object.freeze({
+    getConsoleSettings,
+    updateConsoleSettings,
+    getWorkspaceSettings,
+    updateWorkspaceSettings,
+    resolveSystemPrompt
+  });
+}
+
+export { createService, serviceEvents };