baron-sso/adminfront/src/lib/adminApi.ts

import apiClient from "./apiClient";

export type AuditLog = {
  event_id: string;
  timestamp: string;
  user_id: string;
  event_type: string;
  status: string;
  ip_address: string;
  user_agent: string;
  device_id?: string;
  details?: string;
};

export type AuditLogListResponse = {
  items: AuditLog[];
  limit: number;
  cursor?: string;
  next_cursor?: string;
};

export type TenantSummary = {
  id: string;
  name: string;
  slug: string;
  description: string;
  status: string;
  domains?: string[];
  config?: Record<string, unknown>;
  tenantGroupId?: string;
  createdAt: string;
  updatedAt: string;
};

export type TenantCreateRequest = {
  name: string;
  slug?: string;
  description?: string;
  status?: string;
  domains?: string[];
  config?: Record<string, unknown>;
  tenantGroupId?: string;
};

export type TenantListResponse = {
  items: TenantSummary[];
  limit: number;
  offset: number;
  total: number;
};

export type TenantUpdateRequest = {
  name?: string;
  slug?: string;
  description?: string;
  status?: string;
  domains?: string[];
  config?: Record<string, unknown>;
  tenantGroupId?: string;
};

export type ApiKeySummary = {
  id: string;
  name: string;
  client_id: string;
  scopes: string[];
  status: string;
  lastUsedAt?: string;
  createdAt: string;
};

export type ApiKeyListResponse = {
  items: ApiKeySummary[];
  total: number;
};

export type RoleSummary = {
  id: string;
  name: string;
  description: string;
  permissions: string[];
  createdAt: string;
  updatedAt: string;
};

export type RoleListResponse = {
  items: RoleSummary[];
  total: number;
};

export async function fetchAuditLogs(limit = 50, cursor?: string) {
  const { data } = await apiClient.get<AuditLogListResponse>("/v1/audit", {
    params: { limit, cursor },
  });
  return data;
}

// Authentication
export type LoginRequest = {
  loginId: string;
  password?: string;
};

export type LoginResponse = {
  sessionToken: string;
  refreshToken?: string;
  userId?: string;
};

export async function login(payload: LoginRequest) {
  const { data } = await apiClient.post<LoginResponse>(
    "/v1/auth/password/login",
    payload,
  );
  return data;
}

export async function fetchTenants(limit = 50, offset = 0, parentId?: string) {
  const { data } = await apiClient.get<TenantListResponse>(
    "/v1/admin/tenants",
    {
      params: { limit, offset, parentId },
    },
  );
  return data;
}

export async function fetchTenant(tenantId: string) {
  const { data } = await apiClient.get<TenantSummary>(
    `/v1/admin/tenants/${tenantId}`,
  );
  return data;
}

export async function createTenant(payload: TenantCreateRequest) {
  const { data } = await apiClient.post<TenantSummary>(
    "/v1/admin/tenants",
    payload,
  );
  return data;
}

export async function updateTenant(
  tenantId: string,
  payload: TenantUpdateRequest,
) {
  const { data } = await apiClient.put<TenantSummary>(
    `/v1/admin/tenants/${tenantId}`,
    payload,
  );
  return data;
}

export async function deleteTenant(tenantId: string) {
  await apiClient.delete(`/v1/admin/tenants/${tenantId}`);
}

export async function approveTenant(tenantId: string) {
  const { data } = await apiClient.post<TenantSummary>(
    `/v1/admin/tenants/${tenantId}/approve`,
  );
  return data;
}

// User Group Management (Within a Tenant)
export type GroupMember = {
  id: string;
  name: string;
  email: string;
};

export type GroupSummary = {
  id: string;
  tenantId: string;
  name: string;
  description?: string;
  members?: GroupMember[];
  createdAt?: string;
  updatedAt?: string;
};

export type GroupCreateRequest = {
  name: string;
  description?: string;
};

export async function fetchGroups(tenantId: string) {
  const { data } = await apiClient.get<GroupSummary[]>(
    `/v1/admin/tenants/${tenantId}/groups`,
  );
  return data;
}

export async function createGroup(
  tenantId: string,
  payload: GroupCreateRequest,
) {
  const { data } = await apiClient.post<GroupSummary>(
    `/v1/admin/tenants/${tenantId}/groups`,
    payload,
  );
  return data;
}

export async function deleteGroup(groupId: string) {
  await apiClient.delete(`/v1/admin/groups/${groupId}`);
}

export async function addGroupMember(groupId: string, userId: string) {
  await apiClient.post(`/v1/admin/groups/${groupId}/members`, { userId });
}

export async function removeGroupMember(groupId: string, userId: string) {
  await apiClient.delete(`/v1/admin/groups/${groupId}/members/${userId}`);
}

// Tenant Group Management (Global Grouping of Tenants)
export type TenantGroupSummary = {
  id: string;
  name: string;
  slug: string;
  description: string;
  tenants?: TenantSummary[];
  config?: Record<string, any>;
  createdAt: string;
  updatedAt: string;
};

export type TenantGroupListResponse = {
  items: TenantGroupSummary[];
  total: number;
  limit: number;
  offset: number;
};

export async function fetchTenantGroups(limit = 50, offset = 0) {
  const { data } = await apiClient.get<TenantGroupListResponse>(
    "/v1/admin/tenant-groups",
    {
      params: { limit, offset },
    },
  );
  return data;
}

export async function fetchTenantGroup(id: string) {
  const { data } = await apiClient.get<TenantGroupSummary>(
    `/v1/admin/tenant-groups/${id}`,
  );
  return data;
}

export async function createTenantGroup(payload: {
  name: string;
  slug: string;
  description?: string;
}) {
  const { data } = await apiClient.post<TenantGroupSummary>(
    "/v1/admin/tenant-groups",
    payload,
  );
  return data;
}

export async function updateTenantGroup(
  id: string,
  payload: { name: string; description?: string },
) {
  const { data } = await apiClient.put<TenantGroupSummary>(
    `/v1/admin/tenant-groups/${id}`,
    payload,
  );
  return data;
}

export async function deleteTenantGroup(id: string) {
  await apiClient.delete(`/v1/admin/tenant-groups/${id}`);
}

export async function addTenantToGroup(groupId: string, tenantId: string) {
  await apiClient.post(`/v1/admin/tenant-groups/${groupId}/tenants/${tenantId}`);
}

export async function removeTenantFromGroup(groupId: string, tenantId: string) {
  await apiClient.delete(
    `/v1/admin/tenant-groups/${groupId}/tenants/${tenantId}`,
  );
}

export type TenantAdmin = {
  id: string;
  name: string;
  email: string;
};

export async function fetchTenantAdmins(tenantId: string) {
  const { data } = await apiClient.get<TenantAdmin[]>(
    `/v1/admin/tenants/${tenantId}/admins`,
  );
  return data;
}

export async function addTenantAdmin(tenantId: string, userId: string) {
  await apiClient.post(`/v1/admin/tenants/${tenantId}/admins/${userId}`);
}

export async function removeTenantAdmin(tenantId: string, userId: string) {
  await apiClient.delete(`/v1/admin/tenants/${tenantId}/admins/${userId}`);
}

export type GroupAdmin = {
  id: string;
  name: string;
  email: string;
};

export async function fetchGroupAdmins(groupId: string) {
  const { data } = await apiClient.get<GroupAdmin[]>(
    `/v1/admin/tenant-groups/${groupId}/admins`,
  );
  return data;
}

export async function addGroupAdmin(groupId: string, userId: string) {
  await apiClient.post(`/v1/admin/tenant-groups/${groupId}/admins/${userId}`);
}

export async function removeGroupAdmin(groupId: string, userId: string) {
  await apiClient.delete(
    `/v1/admin/tenant-groups/${groupId}/admins/${userId}`,
  );
}

// API Key Management (M2M)
export type ApiKeyCreateRequest = {
  name: string;
  scopes: string[];
};

export type ApiKeyCreateResponse = {
  apiKey: ApiKeySummary;
  clientSecret: string;
};

export async function fetchApiKeys(limit = 50, offset = 0) {
  const { data } = await apiClient.get<ApiKeyListResponse>(
    "/v1/admin/api-keys",
    {
      params: { limit, offset },
    },
  );
  return data;
}

export async function createApiKey(payload: ApiKeyCreateRequest) {
  const { data } = await apiClient.post<ApiKeyCreateResponse>(
    "/v1/admin/api-keys",
    payload,
  );
  return data;
}

export async function deleteApiKey(apiKeyId: string) {
  await apiClient.delete(`/v1/admin/api-keys/${apiKeyId}`);
}

// User Management
export type UserSummary = {
  id: string;
  email: string;
  name: string;
  phone?: string;
  role: string;
  status: string;
  companyCode?: string;
  tenant?: TenantSummary;
  metadata?: Record<string, unknown>;
  department?: string;
  createdAt: string;
  updatedAt: string;
};

export type UserListResponse = {
  items: UserSummary[];
  limit: number;
  offset: number;
  total: number;
};

export type UserCreateRequest = {
  email: string;
  password?: string;
  name: string;
  phone?: string;
  role?: string;
  companyCode?: string;
  department?: string;
};

export type UserCreateResponse = UserSummary & {
  initialPassword?: string;
};

export type UserUpdateRequest = {
  password?: string;
  name?: string;
  phone?: string;
  role?: string;
  status?: string;
  companyCode?: string;
  department?: string;
};

export async function fetchUsers(limit = 50, offset = 0, search?: string) {
  const { data } = await apiClient.get<UserListResponse>("/v1/admin/users", {
    params: { limit, offset, search },
  });
  return data;
}

export async function fetchUser(userId: string) {
  const { data } = await apiClient.get<UserSummary>(
    `/v1/admin/users/${userId}`,
  );
  return data;
}

export async function createUser(payload: UserCreateRequest) {
  const { data } = await apiClient.post<UserCreateResponse>(
    "/v1/admin/users",
    payload,
  );
  return data;
}

export async function updateUser(userId: string, payload: UserUpdateRequest) {
  const { data } = await apiClient.put<UserSummary>(
    `/v1/admin/users/${userId}`,
    payload,
  );
  return data;
}

export async function deleteUser(userId: string) {
  await apiClient.delete(`/v1/admin/users/${userId}`);
}

// Relying Party Management
export type RelyingParty = {
  clientId: string;
  tenantId: string;
  name: string;
  description: string;
  createdAt: string;
  updatedAt: string;
};

export type HydraClientReq = {
  client_id?: string;
  client_name: string;
  client_secret?: string;
  redirect_uris: string[];
  scope?: string;
  token_endpoint_auth_method?: string;
  grant_types?: string[];
  response_types?: string[];
  metadata?: Record<string, unknown>;
};

export async function fetchRelyingParties(tenantId: string) {
  const { data } = await apiClient.get<RelyingParty[]>(
    `/v1/admin/tenants/${tenantId}/relying-parties`,
  );
  return data;
}

export async function fetchAllRelyingParties() {
  const { data } = await apiClient.get<RelyingParty[]>(
    "/v1/admin/relying-parties",
  );
  return data;
}

export async function createRelyingParty(
  tenantId: string,
  payload: HydraClientReq,
) {
  const { data } = await apiClient.post<RelyingParty>(
    `/v1/admin/tenants/${tenantId}/relying-parties`,
    payload,
  );
  return data;
}

export async function fetchRelyingParty(id: string) {
  const { data } = await apiClient.get<{
    relyingParty: RelyingParty;
    oauth2Config: HydraClientReq;
  }>(`/v1/admin/relying-parties/${id}`);
  return data;
}

export async function updateRelyingParty(id: string, payload: HydraClientReq) {
  const { data } = await apiClient.put<RelyingParty>(
    `/v1/admin/relying-parties/${id}`,
    payload,
  );
  return data;
}

export async function deleteRelyingParty(id: string) {

  await apiClient.delete(`/v1/admin/relying-parties/${id}`);

}



export type RPOwner = {

  subject: string;

  name?: string;

  email?: string;

  type: string;

};



export async function fetchRPOwners(clientId: string) {

  const { data } = await apiClient.get<RPOwner[]>(

    `/v1/admin/relying-parties/${clientId}/owners`,

  );

  return data;

}



export async function addRPOwner(clientId: string, subject: string) {

  await apiClient.post(`/v1/admin/relying-parties/${clientId}/owners/${subject}`);

}



export async function removeRPOwner(clientId: string, subject: string) {

  await apiClient.delete(

    `/v1/admin/relying-parties/${clientId}/owners/${subject}`,

  );

}