@jskit-ai/users-core 0.1.48 → 0.1.49

package/src/server/common/formatters/workspaceFormatter.js

@@ -1,53 +0,0 @@
-import { resolveWorkspaceThemePalettes } from "../../../shared/settings.js";
-import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
-import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
-
-function mapWorkspaceSummary(workspace, membership) {
-  return {
-    id: normalizeRecordId(workspace.id, { fallback: "" }),
-    slug: normalizeText(workspace.slug),
-    name: normalizeText(workspace.name),
-    avatarUrl: normalizeText(workspace.avatarUrl),
-    roleSid: normalizeLowerText(membership?.roleSid || "member") || "member",
-    isAccessible: normalizeLowerText(membership?.status || "active") === "active"
-  };
-}
-
-function mapWorkspaceSettingsPublic(workspaceSettings, { workspaceInvitationsEnabled = true } = {}) {
-  const source = workspaceSettings && typeof workspaceSettings === "object" ? workspaceSettings : {};
-  const invitesAvailable = workspaceInvitationsEnabled === true;
-  const invitesEnabled = invitesAvailable && source.invitesEnabled !== false;
-  const themePalettes = resolveWorkspaceThemePalettes(source);
-
-  return {
-    lightPrimaryColor: themePalettes.light.color,
-    lightSecondaryColor: themePalettes.light.secondaryColor,
-    lightSurfaceColor: themePalettes.light.surfaceColor,
-    lightSurfaceVariantColor: themePalettes.light.surfaceVariantColor,
-    darkPrimaryColor: themePalettes.dark.color,
-    darkSecondaryColor: themePalettes.dark.secondaryColor,
-    darkSurfaceColor: themePalettes.dark.surfaceColor,
-    darkSurfaceVariantColor: themePalettes.dark.surfaceVariantColor,
-    invitesEnabled,
-    invitesAvailable,
-    invitesEffective: invitesAvailable && invitesEnabled
-  };
-}
-
-function mapMembershipSummary(membership, workspace) {
-  if (!membership) {
-    return null;
-  }
-
-  return {
-    workspaceId: normalizeRecordId(workspace?.id || membership.workspaceId, { fallback: "" }),
-    roleSid: normalizeLowerText(membership.roleSid || "member") || "member",
-    status: normalizeLowerText(membership.status || "active") || "active"
-  };
-}
-
-export {
-  mapMembershipSummary,
-  mapWorkspaceSettingsPublic,
-  mapWorkspaceSummary
-};

package/src/server/common/repositories/workspaceInvitesRepository.js

@@ -1,208 +0,0 @@
-import { resolveInsertedRecordId } from "@jskit-ai/database-runtime/shared";
-import {
-  normalizeLowerText,
-  normalizeDbRecordId,
-  normalizeRecordId,
-  normalizeText,
-  toIsoString,
-  toNullableIso,
-  toNullableDateTime,
-  nowDb,
-  isDuplicateEntryError,
-  createWithTransaction
-} from "./repositoryUtils.js";
-
-function mapRow(row) {
-  if (!row) {
-    return null;
-  }
-
-  return {
-    id: normalizeDbRecordId(row.id, { fallback: "" }),
-    workspaceId: normalizeDbRecordId(row.workspace_id, { fallback: "" }),
-    email: normalizeLowerText(row.email),
-    roleSid: normalizeLowerText(row.role_sid || "member") || "member",
-    status: normalizeLowerText(row.status || "pending") || "pending",
-    tokenHash: normalizeText(row.token_hash),
-    invitedByUserId: row.invited_by_user_id == null ? null : normalizeDbRecordId(row.invited_by_user_id, { fallback: null }),
-    expiresAt: toNullableIso(row.expires_at),
-    acceptedAt: toNullableIso(row.accepted_at),
-    revokedAt: toNullableIso(row.revoked_at),
-    createdAt: toIsoString(row.created_at),
-    updatedAt: toIsoString(row.updated_at),
-    workspaceSlug: row.workspace_slug ? normalizeText(row.workspace_slug) : undefined,
-    workspaceName: row.workspace_name ? normalizeText(row.workspace_name) : undefined,
-    workspaceAvatarUrl: row.workspace_avatar_url ? normalizeText(row.workspace_avatar_url) : undefined
-  };
-}
-
-const WORKSPACE_INVITE_WITH_WORKSPACE_SELECT = Object.freeze([
-  "wi.*",
-  "w.slug as workspace_slug",
-  "w.name as workspace_name",
-  "w.avatar_url as workspace_avatar_url"
-]);
-
-function createRepository(knex) {
-  if (typeof knex !== "function") {
-    throw new TypeError("workspaceInvitesRepository requires knex.");
-  }
-  const withTransaction = createWithTransaction(knex);
-
-  async function findPendingByTokenHash(tokenHash, options = {}) {
-    const client = options?.trx || knex;
-    const row = await client("workspace_invites")
-      .where({ token_hash: normalizeText(tokenHash), status: "pending" })
-      .first();
-    return mapRow(row);
-  }
-
-  async function listPendingByEmail(email, options = {}) {
-    const client = options?.trx || knex;
-    const normalizedEmail = normalizeLowerText(email);
-    if (!normalizedEmail) {
-      return [];
-    }
-
-    const rows = await client("workspace_invites as wi")
-      .join("workspaces as w", "w.id", "wi.workspace_id")
-      .where({ "wi.email": normalizedEmail, "wi.status": "pending" })
-      .orderBy("wi.created_at", "desc")
-      .select(WORKSPACE_INVITE_WITH_WORKSPACE_SELECT);
-
-    return rows.map(mapRow).filter(Boolean);
-  }
-
-  async function listPendingByWorkspaceIdWithWorkspace(workspaceId, options = {}) {
-    const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
-    if (!normalizedWorkspaceId) {
-      return [];
-    }
-
-    const client = options?.trx || knex;
-    const rows = await client("workspace_invites as wi")
-      .join("workspaces as w", "w.id", "wi.workspace_id")
-      .where({ "wi.workspace_id": normalizedWorkspaceId, "wi.status": "pending" })
-      .orderBy("wi.created_at", "desc")
-      .select(WORKSPACE_INVITE_WITH_WORKSPACE_SELECT);
-
-    return rows.map(mapRow).filter(Boolean);
-  }
-
-  async function insert(payload = {}, options = {}) {
-    const client = options?.trx || knex;
-    const source = payload && typeof payload === "object" ? payload : {};
-    const workspaceId = normalizeRecordId(source.workspaceId, { fallback: null });
-    if (!workspaceId) {
-      throw new TypeError("workspaceInvitesRepository.insert requires workspaceId.");
-    }
-
-    const insertPayload = {
-      workspace_id: workspaceId,
-      email: normalizeLowerText(source.email),
-      role_sid: normalizeLowerText(source.roleSid || "member") || "member",
-      status: normalizeLowerText(source.status || "pending") || "pending",
-      token_hash: normalizeText(source.tokenHash),
-      invited_by_user_id: source.invitedByUserId == null ? null : normalizeRecordId(source.invitedByUserId, { fallback: null }),
-      expires_at: toNullableDateTime(source.expiresAt),
-      accepted_at: null,
-      revoked_at: null,
-      created_at: nowDb(),
-      updated_at: nowDb()
-    };
-
-    try {
-      const result = await client("workspace_invites").insert(insertPayload);
-      const insertedId = resolveInsertedRecordId(result, { fallback: null });
-      if (insertedId) {
-        const row = await client("workspace_invites").where({ id: insertedId }).first();
-        return mapRow(row);
-      }
-    } catch (error) {
-      if (!isDuplicateEntryError(error)) {
-        throw error;
-      }
-    }
-
-    const row = await client("workspace_invites")
-      .where({ workspace_id: insertPayload.workspace_id, email: insertPayload.email, status: "pending" })
-      .orderBy("id", "desc")
-      .first();
-    return mapRow(row);
-  }
-
-  async function expirePendingByWorkspaceIdAndEmail(workspaceId, email, options = {}) {
-    const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
-    if (!normalizedWorkspaceId) {
-      return;
-    }
-
-    const client = options?.trx || knex;
-    await client("workspace_invites")
-      .where({ workspace_id: normalizedWorkspaceId, email: normalizeLowerText(email), status: "pending" })
-      .update({
-        status: "expired",
-        updated_at: nowDb()
-      });
-  }
-
-  async function markAcceptedById(inviteId, options = {}) {
-    const normalizedInviteId = normalizeRecordId(inviteId, { fallback: null });
-    if (!normalizedInviteId) {
-      return;
-    }
-
-    const client = options?.trx || knex;
-    await client("workspace_invites")
-      .where({ id: normalizedInviteId })
-      .update({
-        status: "accepted",
-        accepted_at: nowDb(),
-        updated_at: nowDb()
-      });
-  }
-
-  async function revokeById(inviteId, options = {}) {
-    const normalizedInviteId = normalizeRecordId(inviteId, { fallback: null });
-    if (!normalizedInviteId) {
-      return;
-    }
-
-    const client = options?.trx || knex;
-    await client("workspace_invites")
-      .where({ id: normalizedInviteId })
-      .update({
-        status: "revoked",
-        revoked_at: nowDb(),
-        updated_at: nowDb()
-      });
-  }
-
-  async function findPendingByIdForWorkspace(inviteId, workspaceId, options = {}) {
-    const normalizedInviteId = normalizeRecordId(inviteId, { fallback: null });
-    const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
-    if (!normalizedInviteId || !normalizedWorkspaceId) {
-      return null;
-    }
-
-    const client = options?.trx || knex;
-    const row = await client("workspace_invites")
-      .where({ id: normalizedInviteId, workspace_id: normalizedWorkspaceId, status: "pending" })
-      .first();
-    return mapRow(row);
-  }
-
-  return Object.freeze({
-    withTransaction,
-    findPendingByTokenHash,
-    listPendingByEmail,
-    listPendingByWorkspaceIdWithWorkspace,
-    insert,
-    expirePendingByWorkspaceIdAndEmail,
-    markAcceptedById,
-    revokeById,
-    findPendingByIdForWorkspace
-  });
-}
-
-export { createRepository, mapRow };

package/src/server/common/repositories/workspaceMembershipsRepository.js

@@ -1,190 +0,0 @@
-import {
-  normalizeLowerText,
-  normalizeRecordId,
-  normalizeDbRecordId,
-  normalizeText,
-  toIsoString,
-  nowDb,
-  isDuplicateEntryError,
-  createWithTransaction
-} from "./repositoryUtils.js";
-import { OWNER_ROLE_ID } from "../../../shared/roles.js";
-
-function mapRow(row) {
-  if (!row) {
-    return null;
-  }
-
-  return {
-    id: normalizeDbRecordId(row.id, { fallback: "" }),
-    workspaceId: normalizeDbRecordId(row.workspace_id, { fallback: "" }),
-    userId: normalizeDbRecordId(row.user_id, { fallback: "" }),
-    roleSid: normalizeLowerText(row.role_sid || "member") || "member",
-    status: normalizeLowerText(row.status || "active") || "active",
-    createdAt: toIsoString(row.created_at),
-    updatedAt: toIsoString(row.updated_at)
-  };
-}
-
-function mapMemberSummaryRow(row) {
-  if (!row) {
-    return null;
-  }
-
-  return {
-    userId: normalizeDbRecordId(row.user_id, { fallback: "" }),
-    roleSid: normalizeLowerText(row.role_sid || "member") || "member",
-    status: normalizeLowerText(row.status || "active") || "active",
-    displayName: normalizeText(row.display_name),
-    email: normalizeLowerText(row.email)
-  };
-}
-
-function createRepository(knex) {
-  if (typeof knex !== "function") {
-    throw new TypeError("workspaceMembershipsRepository requires knex.");
-  }
-  const withTransaction = createWithTransaction(knex);
-
-  async function findByWorkspaceIdAndUserId(workspaceId, userId, options = {}) {
-    const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
-    const normalizedUserId = normalizeRecordId(userId, { fallback: null });
-    if (!normalizedWorkspaceId || !normalizedUserId) {
-      return null;
-    }
-
-    const client = options?.trx || knex;
-    const row = await client("workspace_memberships")
-      .where({ workspace_id: normalizedWorkspaceId, user_id: normalizedUserId })
-      .first();
-    return mapRow(row);
-  }
-
-  async function ensureOwnerMembership(workspaceId, userId, options = {}) {
-    const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
-    const normalizedUserId = normalizeRecordId(userId, { fallback: null });
-    if (!normalizedWorkspaceId || !normalizedUserId) {
-      throw new TypeError("workspaceMembershipsRepository.ensureOwnerMembership requires workspaceId and userId.");
-    }
-
-    const client = options?.trx || knex;
-    const existing = await findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, { trx: client });
-    if (existing) {
-      if (existing.roleSid !== OWNER_ROLE_ID || existing.status !== "active") {
-        await client("workspace_memberships")
-          .where({ workspace_id: normalizedWorkspaceId, user_id: normalizedUserId })
-          .update({
-            role_sid: OWNER_ROLE_ID,
-            status: "active",
-            updated_at: nowDb()
-          });
-      }
-      return findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, { trx: client });
-    }
-
-    try {
-      await client("workspace_memberships").insert({
-        workspace_id: normalizedWorkspaceId,
-        user_id: normalizedUserId,
-        role_sid: OWNER_ROLE_ID,
-        status: "active",
-        created_at: nowDb(),
-        updated_at: nowDb()
-      });
-    } catch (error) {
-      if (!isDuplicateEntryError(error)) {
-        throw error;
-      }
-    }
-
-    return findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, { trx: client });
-  }
-
-  async function upsertMembership(workspaceId, userId, patch = {}, options = {}) {
-    const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
-    const normalizedUserId = normalizeRecordId(userId, { fallback: null });
-    if (!normalizedWorkspaceId || !normalizedUserId) {
-      throw new TypeError("workspaceMembershipsRepository.upsertMembership requires workspaceId and userId.");
-    }
-
-    const client = options?.trx || knex;
-    const existing = await findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, { trx: client });
-    const roleSid = normalizeLowerText(patch.roleSid || existing?.roleSid || "member") || "member";
-    const status = normalizeLowerText(patch.status || existing?.status || "active") || "active";
-
-    if (!existing) {
-      await client("workspace_memberships").insert({
-        workspace_id: normalizedWorkspaceId,
-        user_id: normalizedUserId,
-        role_sid: roleSid,
-        status,
-        created_at: nowDb(),
-        updated_at: nowDb()
-      });
-      return findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, { trx: client });
-    }
-
-    await client("workspace_memberships")
-      .where({ workspace_id: normalizedWorkspaceId, user_id: normalizedUserId })
-      .update({
-        role_sid: roleSid,
-        status,
-        updated_at: nowDb()
-      });
-
-    return findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, { trx: client });
-  }
-
-  async function listActiveByWorkspaceId(workspaceId, options = {}) {
-    const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
-    if (!normalizedWorkspaceId) {
-      return [];
-    }
-
-    const client = options?.trx || knex;
-    const rows = await client("workspace_memberships as wm")
-      .join("users as up", "up.id", "wm.user_id")
-      .where({ "wm.workspace_id": normalizedWorkspaceId, "wm.status": "active" })
-      .orderBy("up.display_name", "asc")
-      .select([
-        "wm.user_id",
-        "wm.role_sid",
-        "wm.status",
-        "up.display_name",
-        "up.email"
-      ]);
-
-    return rows.map(mapMemberSummaryRow).filter(Boolean);
-  }
-
-  async function listActiveWorkspaceIdsByUserId(userId, options = {}) {
-    const normalizedUserId = normalizeRecordId(userId, { fallback: null });
-    if (!normalizedUserId) {
-      return [];
-    }
-
-    const client = options?.trx || knex;
-    const rows = await client("workspace_memberships")
-      .where({
-        user_id: normalizedUserId,
-        status: "active"
-      })
-      .select("workspace_id")
-      .orderBy("workspace_id", "asc");
-
-    return rows
-      .map((row) => normalizeDbRecordId(row.workspace_id, { fallback: null }))
-      .filter(Boolean);
-  }
-
-  return Object.freeze({
-    withTransaction,
-    findByWorkspaceIdAndUserId,
-    ensureOwnerMembership,
-    upsertMembership,
-    listActiveByWorkspaceId,
-    listActiveWorkspaceIdsByUserId
-  });
-}
-
-export { createRepository, mapRow, mapMemberSummaryRow };

package/src/server/common/repositories/workspacesRepository.js

@@ -1,202 +0,0 @@
-import { resolveInsertedRecordId } from "@jskit-ai/database-runtime/shared";
-import {
-  normalizeDbRecordId,
-  normalizeRecordId,
-  normalizeText,
-  normalizeLowerText,
-  toIsoString,
-  toNullableIso,
-  nowDb,
-  isDuplicateEntryError,
-  createWithTransaction
-} from "./repositoryUtils.js";
-
-function mapRow(row) {
-  if (!row) {
-    return null;
-  }
-
-  return {
-    id: normalizeDbRecordId(row.id, { fallback: "" }),
-    slug: normalizeText(row.slug),
-    name: normalizeText(row.name),
-    ownerUserId: normalizeDbRecordId(row.owner_user_id, { fallback: "" }),
-    isPersonal: Boolean(row.is_personal),
-    avatarUrl: row.avatar_url ? normalizeText(row.avatar_url) : "",
-    createdAt: toIsoString(row.created_at),
-    updatedAt: toIsoString(row.updated_at),
-    deletedAt: toNullableIso(row.deleted_at)
-  };
-}
-
-function mapMembershipWorkspaceRow(row) {
-  if (!row) {
-    return null;
-  }
-
-  return {
-    ...mapRow(row),
-    roleSid: normalizeLowerText(row.role_sid || "member"),
-    membershipStatus: normalizeLowerText(row.membership_status || "active") || "active"
-  };
-}
-
-function createRepository(knex) {
-  if (typeof knex !== "function") {
-    throw new TypeError("workspacesRepository requires knex.");
-  }
-  const withTransaction = createWithTransaction(knex);
-
-  function workspaceSelectColumns({ includeMembership = false } = {}) {
-    const columns = [
-      "w.id",
-      "w.slug",
-      "w.name",
-      "w.owner_user_id",
-      "w.is_personal",
-      "w.avatar_url",
-      "w.created_at",
-      "w.updated_at",
-      "w.deleted_at"
-    ];
-    if (includeMembership) {
-      columns.push("wm.role_sid", "wm.status as membership_status");
-    }
-    return columns;
-  }
-
-  async function findById(workspaceId, options = {}) {
-    const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
-    if (!normalizedWorkspaceId) {
-      return null;
-    }
-
-    const client = options?.trx || knex;
-    const row = await client("workspaces as w")
-      .where({ "w.id": normalizedWorkspaceId })
-      .select(workspaceSelectColumns())
-      .first();
-    return mapRow(row);
-  }
-
-  async function findBySlug(slug, options = {}) {
-    const client = options?.trx || knex;
-    const normalizedSlug = normalizeLowerText(slug);
-    if (!normalizedSlug) {
-      return null;
-    }
-
-    const row = await client("workspaces as w")
-      .where({ "w.slug": normalizedSlug })
-      .select(workspaceSelectColumns())
-      .first();
-    return mapRow(row);
-  }
-
-  async function findPersonalByOwnerUserId(userId, options = {}) {
-    const normalizedUserId = normalizeRecordId(userId, { fallback: null });
-    if (!normalizedUserId) {
-      return null;
-    }
-
-    const client = options?.trx || knex;
-    const row = await client("workspaces as w")
-      .where({ "w.owner_user_id": normalizedUserId, "w.is_personal": 1 })
-      .orderBy("w.id", "asc")
-      .select(workspaceSelectColumns())
-      .first();
-    return mapRow(row);
-  }
-
-  async function insert(payload = {}, options = {}) {
-    const client = options?.trx || knex;
-    const source = payload && typeof payload === "object" ? payload : {};
-    const ownerUserId = normalizeRecordId(source.ownerUserId, { fallback: null });
-    if (!ownerUserId) {
-      throw new TypeError("workspacesRepository.insert requires ownerUserId.");
-    }
-
-    const insertPayload = {
-      slug: normalizeLowerText(source.slug),
-      name: normalizeText(source.name),
-      owner_user_id: ownerUserId,
-      is_personal: source.isPersonal ? 1 : 0,
-      avatar_url: normalizeText(source.avatarUrl),
-      created_at: nowDb(),
-      updated_at: nowDb(),
-      deleted_at: null
-    };
-
-    try {
-      const result = await client("workspaces").insert(insertPayload);
-      const insertedId = resolveInsertedRecordId(result, { fallback: null });
-      if (insertedId) {
-        return findById(insertedId, { trx: client });
-      }
-      const bySlug = await findBySlug(insertPayload.slug, { trx: client });
-      return bySlug;
-    } catch (error) {
-      if (!isDuplicateEntryError(error)) {
-        throw error;
-      }
-      const bySlug = await findBySlug(insertPayload.slug, { trx: client });
-      if (bySlug) {
-        return bySlug;
-      }
-      throw error;
-    }
-  }
-
-  async function updateById(workspaceId, patch = {}, options = {}) {
-    const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
-    if (!normalizedWorkspaceId) {
-      return null;
-    }
-
-    const client = options?.trx || knex;
-    const source = patch && typeof patch === "object" ? patch : {};
-    const dbPatch = {
-      updated_at: nowDb()
-    };
-
-    if (Object.hasOwn(source, "name")) {
-      dbPatch.name = normalizeText(source.name);
-    }
-    if (Object.hasOwn(source, "avatarUrl")) {
-      dbPatch.avatar_url = normalizeText(source.avatarUrl);
-    }
-
-    await client("workspaces").where({ id: normalizedWorkspaceId }).update(dbPatch);
-    return findById(normalizedWorkspaceId, { trx: client });
-  }
-
-  async function listForUserId(userId, options = {}) {
-    const normalizedUserId = normalizeRecordId(userId, { fallback: null });
-    if (!normalizedUserId) {
-      return [];
-    }
-
-    const client = options?.trx || knex;
-    const rows = await client("workspace_memberships as wm")
-      .join("workspaces as w", "w.id", "wm.workspace_id")
-      .where({ "wm.user_id": normalizedUserId })
-      .whereNull("w.deleted_at")
-      .orderBy("w.is_personal", "desc")
-      .orderBy("w.id", "asc")
-      .select(workspaceSelectColumns({ includeMembership: true }));
-
-    return rows.map(mapMembershipWorkspaceRow).filter(Boolean);
-  }
-
-  return Object.freeze({
-    withTransaction,
-    findById,
-    findBySlug,
-    findPersonalByOwnerUserId,
-    insert,
-    updateById,
-    listForUserId
-  });
-}
-
-export { createRepository, mapRow, mapMembershipWorkspaceRow };