Add local user authentication and admin capabilities

Implement local user authentication with password hashing, add admin roles for user management and audit log viewing, and introduce audit logging for critical actions.

Replit-Commit-Author: Agent
Replit-Commit-Session-Id: 776963d0-f75d-42e2-a57b-cc36bdff8495
Replit-Commit-Checkpoint-Type: full_checkpoint
Replit-Commit-Event-Id: 832a44ff-12ae-4096-8a0d-666ec083d536
Replit-Commit-Screenshot-Url: https://storage.googleapis.com/screenshot-production-us-central1/0683fb79-a27c-485c-9333-5f4b288c4567/776963d0-f75d-42e2-a57b-cc36bdff8495/1p7jhzu
Replit-Helium-Checkpoint-Created: true
This commit is contained in:
cheffe01
2026-05-25 14:11:02 +00:00
parent b8ba53598d
commit c5ca3ca992
44 changed files with 2554 additions and 34 deletions
@@ -9,6 +9,82 @@ export interface HealthStatus {
status: string;
}
export type AuthModeMode = typeof AuthModeMode[keyof typeof AuthModeMode];
export const AuthModeMode = {
oidc: 'oidc',
local: 'local',
} as const;
export interface AuthMode {
mode: AuthModeMode;
}
export interface LocalLoginInput {
username: string;
password: string;
}
export type UserRole = typeof UserRole[keyof typeof UserRole];
export const UserRole = {
admin: 'admin',
user: 'user',
} as const;
export interface User {
id: number;
username: string;
/** @nullable */
email?: string | null;
role: UserRole;
createdAt: string;
}
export type UserCreateInputRole = typeof UserCreateInputRole[keyof typeof UserCreateInputRole];
export const UserCreateInputRole = {
admin: 'admin',
user: 'user',
} as const;
export interface UserCreateInput {
/** @minLength 2 */
username: string;
/** @minLength 6 */
password: string;
email?: string;
role?: UserCreateInputRole;
}
export type UserRoleUpdateRole = typeof UserRoleUpdateRole[keyof typeof UserRoleUpdateRole];
export const UserRoleUpdateRole = {
admin: 'admin',
user: 'user',
} as const;
export interface UserRoleUpdate {
role: UserRoleUpdateRole;
}
export interface AuditLog {
id: number;
entityType: string;
/** @nullable */
entityId?: number | null;
action: string;
userId: string;
username: string;
/** @nullable */
changes?: string | null;
createdAt: string;
}
export interface Tool {
id: number;
name: string;
@@ -18,6 +94,8 @@ export interface Tool {
websiteUrl?: string | null;
/** @nullable */
iconUrl?: string | null;
/** @nullable */
createdBy?: string | null;
features?: string[];
tags?: string[];
createdAt: string;
@@ -33,6 +111,8 @@ export interface ToolWithStats {
websiteUrl?: string | null;
/** @nullable */
iconUrl?: string | null;
/** @nullable */
createdBy?: string | null;
features?: string[];
tags?: string[];
createdAt: string;
@@ -144,6 +224,14 @@ export interface RatingDistribution {
usability: ScoreBucket[];
}
export type AuthUserRole = typeof AuthUserRole[keyof typeof AuthUserRole];
export const AuthUserRole = {
admin: 'admin',
user: 'user',
} as const;
export interface AuthUser {
sub: string;
/** @nullable */
@@ -152,6 +240,8 @@ export interface AuthUser {
name?: string | null;
/** @nullable */
preferredUsername?: string | null;
role?: AuthUserRole;
isLocal?: boolean;
}
export interface ErrorResponse {
@@ -191,3 +281,9 @@ export type GetRatingDistributionParams = {
toolId?: number;
};
export type ListAuditLogsParams = {
entityType?: string;
entityId?: number;
limit?: number;
};
+530 -1
View File
@@ -21,13 +21,17 @@ import type {
import type {
AnalyticsSummary,
AuditLog,
AuthMode,
AuthUser,
CategoryStats,
ErrorResponse,
GetRatingDistributionParams,
GetTopToolsParams,
HealthStatus,
ListAuditLogsParams,
ListToolsParams,
LocalLoginInput,
Rating,
RatingDistribution,
RatingInput,
@@ -35,7 +39,10 @@ import type {
ToolInput,
ToolUpdate,
ToolWithStats,
TopToolEntry
TopToolEntry,
User,
UserCreateInput,
UserRoleUpdate
} from './api.schemas';
import { customFetch } from '../custom-fetch';
@@ -1127,6 +1134,154 @@ export function useListAllFeatures<TData = Awaited<ReturnType<typeof listAllFeat
export const getGetAuthModeUrl = () => {
return `/api/auth/mode`
}
/**
* @summary Get authentication mode (oidc or local)
*/
export const getAuthMode = async ( options?: RequestInit): Promise<AuthMode> => {
return customFetch<AuthMode>(getGetAuthModeUrl(),
{
...options,
method: 'GET'
}
);}
export const getGetAuthModeQueryKey = () => {
return [
`/api/auth/mode`
] as const;
}
export const getGetAuthModeQueryOptions = <TData = Awaited<ReturnType<typeof getAuthMode>>, TError = ErrorType<unknown>>( options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getAuthMode>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {
const {query: queryOptions, request: requestOptions} = options ?? {};
const queryKey = queryOptions?.queryKey ?? getGetAuthModeQueryKey();
const queryFn: QueryFunction<Awaited<ReturnType<typeof getAuthMode>>> = ({ signal }) => getAuthMode({ signal, ...requestOptions });
return { queryKey, queryFn, ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof getAuthMode>>, TError, TData> & { queryKey: QueryKey }
}
export type GetAuthModeQueryResult = NonNullable<Awaited<ReturnType<typeof getAuthMode>>>
export type GetAuthModeQueryError = ErrorType<unknown>
/**
* @summary Get authentication mode (oidc or local)
*/
export function useGetAuthMode<TData = Awaited<ReturnType<typeof getAuthMode>>, TError = ErrorType<unknown>>(
options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getAuthMode>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
const queryOptions = getGetAuthModeQueryOptions(options)
const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & { queryKey: QueryKey };
return { ...query, queryKey: queryOptions.queryKey };
}
export const getLocalLoginUrl = () => {
return `/api/auth/login`
}
/**
* @summary Local username/password login
*/
export const localLogin = async (localLoginInput: LocalLoginInput, options?: RequestInit): Promise<AuthUser> => {
return customFetch<AuthUser>(getLocalLoginUrl(),
{
...options,
method: 'POST',
headers: { 'Content-Type': 'application/json', ...options?.headers },
body: JSON.stringify(
localLoginInput,)
}
);}
export const getLocalLoginMutationOptions = <TError = ErrorType<ErrorResponse>,
TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof localLogin>>, TError,{data: BodyType<LocalLoginInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof localLogin>>, TError,{data: BodyType<LocalLoginInput>}, TContext> => {
const mutationKey = ['localLogin'];
const {mutation: mutationOptions, request: requestOptions} = options ?
options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
options
: {...options, mutation: {...options.mutation, mutationKey}}
: {mutation: { mutationKey, }, request: undefined};
const mutationFn: MutationFunction<Awaited<ReturnType<typeof localLogin>>, {data: BodyType<LocalLoginInput>}> = (props) => {
const {data} = props ?? {};
return localLogin(data,requestOptions)
}
return { mutationFn, ...mutationOptions }}
export type LocalLoginMutationResult = NonNullable<Awaited<ReturnType<typeof localLogin>>>
export type LocalLoginMutationBody = BodyType<LocalLoginInput>
export type LocalLoginMutationError = ErrorType<ErrorResponse>
/**
* @summary Local username/password login
*/
export const useLocalLogin = <TError = ErrorType<ErrorResponse>,
TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof localLogin>>, TError,{data: BodyType<LocalLoginInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationResult<
Awaited<ReturnType<typeof localLogin>>,
TError,
{data: BodyType<LocalLoginInput>},
TContext
> => {
return useMutation(getLocalLoginMutationOptions(options));
}
export const getGetMeUrl = () => {
@@ -1204,3 +1359,377 @@ export function useGetMe<TData = Awaited<ReturnType<typeof getMe>>, TError = Err
export const getListUsersUrl = () => {
return `/api/users`
}
/**
* @summary List all local users (admin only)
*/
export const listUsers = async ( options?: RequestInit): Promise<User[]> => {
return customFetch<User[]>(getListUsersUrl(),
{
...options,
method: 'GET'
}
);}
export const getListUsersQueryKey = () => {
return [
`/api/users`
] as const;
}
export const getListUsersQueryOptions = <TData = Awaited<ReturnType<typeof listUsers>>, TError = ErrorType<ErrorResponse>>( options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listUsers>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {
const {query: queryOptions, request: requestOptions} = options ?? {};
const queryKey = queryOptions?.queryKey ?? getListUsersQueryKey();
const queryFn: QueryFunction<Awaited<ReturnType<typeof listUsers>>> = ({ signal }) => listUsers({ signal, ...requestOptions });
return { queryKey, queryFn, ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof listUsers>>, TError, TData> & { queryKey: QueryKey }
}
export type ListUsersQueryResult = NonNullable<Awaited<ReturnType<typeof listUsers>>>
export type ListUsersQueryError = ErrorType<ErrorResponse>
/**
* @summary List all local users (admin only)
*/
export function useListUsers<TData = Awaited<ReturnType<typeof listUsers>>, TError = ErrorType<ErrorResponse>>(
options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listUsers>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
const queryOptions = getListUsersQueryOptions(options)
const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & { queryKey: QueryKey };
return { ...query, queryKey: queryOptions.queryKey };
}
export const getCreateUserUrl = () => {
return `/api/users`
}
/**
* @summary Create a new local user (admin only)
*/
export const createUser = async (userCreateInput: UserCreateInput, options?: RequestInit): Promise<User> => {
return customFetch<User>(getCreateUserUrl(),
{
...options,
method: 'POST',
headers: { 'Content-Type': 'application/json', ...options?.headers },
body: JSON.stringify(
userCreateInput,)
}
);}
export const getCreateUserMutationOptions = <TError = ErrorType<ErrorResponse>,
TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createUser>>, TError,{data: BodyType<UserCreateInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createUser>>, TError,{data: BodyType<UserCreateInput>}, TContext> => {
const mutationKey = ['createUser'];
const {mutation: mutationOptions, request: requestOptions} = options ?
options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
options
: {...options, mutation: {...options.mutation, mutationKey}}
: {mutation: { mutationKey, }, request: undefined};
const mutationFn: MutationFunction<Awaited<ReturnType<typeof createUser>>, {data: BodyType<UserCreateInput>}> = (props) => {
const {data} = props ?? {};
return createUser(data,requestOptions)
}
return { mutationFn, ...mutationOptions }}
export type CreateUserMutationResult = NonNullable<Awaited<ReturnType<typeof createUser>>>
export type CreateUserMutationBody = BodyType<UserCreateInput>
export type CreateUserMutationError = ErrorType<ErrorResponse>
/**
* @summary Create a new local user (admin only)
*/
export const useCreateUser = <TError = ErrorType<ErrorResponse>,
TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createUser>>, TError,{data: BodyType<UserCreateInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationResult<
Awaited<ReturnType<typeof createUser>>,
TError,
{data: BodyType<UserCreateInput>},
TContext
> => {
return useMutation(getCreateUserMutationOptions(options));
}
export const getUpdateUserUrl = (id: number,) => {
return `/api/users/${id}`
}
/**
* @summary Update user role (admin only)
*/
export const updateUser = async (id: number,
userRoleUpdate: UserRoleUpdate, options?: RequestInit): Promise<User> => {
return customFetch<User>(getUpdateUserUrl(id),
{
...options,
method: 'PATCH',
headers: { 'Content-Type': 'application/json', ...options?.headers },
body: JSON.stringify(
userRoleUpdate,)
}
);}
export const getUpdateUserMutationOptions = <TError = ErrorType<ErrorResponse>,
TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateUser>>, TError,{id: number;data: BodyType<UserRoleUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateUser>>, TError,{id: number;data: BodyType<UserRoleUpdate>}, TContext> => {
const mutationKey = ['updateUser'];
const {mutation: mutationOptions, request: requestOptions} = options ?
options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
options
: {...options, mutation: {...options.mutation, mutationKey}}
: {mutation: { mutationKey, }, request: undefined};
const mutationFn: MutationFunction<Awaited<ReturnType<typeof updateUser>>, {id: number;data: BodyType<UserRoleUpdate>}> = (props) => {
const {id,data} = props ?? {};
return updateUser(id,data,requestOptions)
}
return { mutationFn, ...mutationOptions }}
export type UpdateUserMutationResult = NonNullable<Awaited<ReturnType<typeof updateUser>>>
export type UpdateUserMutationBody = BodyType<UserRoleUpdate>
export type UpdateUserMutationError = ErrorType<ErrorResponse>
/**
* @summary Update user role (admin only)
*/
export const useUpdateUser = <TError = ErrorType<ErrorResponse>,
TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateUser>>, TError,{id: number;data: BodyType<UserRoleUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationResult<
Awaited<ReturnType<typeof updateUser>>,
TError,
{id: number;data: BodyType<UserRoleUpdate>},
TContext
> => {
return useMutation(getUpdateUserMutationOptions(options));
}
export const getDeleteUserUrl = (id: number,) => {
return `/api/users/${id}`
}
/**
* @summary Delete a user (admin only)
*/
export const deleteUser = async (id: number, options?: RequestInit): Promise<void> => {
return customFetch<void>(getDeleteUserUrl(id),
{
...options,
method: 'DELETE'
}
);}
export const getDeleteUserMutationOptions = <TError = ErrorType<unknown>,
TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteUser>>, TError,{id: number}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof deleteUser>>, TError,{id: number}, TContext> => {
const mutationKey = ['deleteUser'];
const {mutation: mutationOptions, request: requestOptions} = options ?
options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
options
: {...options, mutation: {...options.mutation, mutationKey}}
: {mutation: { mutationKey, }, request: undefined};
const mutationFn: MutationFunction<Awaited<ReturnType<typeof deleteUser>>, {id: number}> = (props) => {
const {id} = props ?? {};
return deleteUser(id,requestOptions)
}
return { mutationFn, ...mutationOptions }}
export type DeleteUserMutationResult = NonNullable<Awaited<ReturnType<typeof deleteUser>>>
export type DeleteUserMutationError = ErrorType<unknown>
/**
* @summary Delete a user (admin only)
*/
export const useDeleteUser = <TError = ErrorType<unknown>,
TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteUser>>, TError,{id: number}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationResult<
Awaited<ReturnType<typeof deleteUser>>,
TError,
{id: number},
TContext
> => {
return useMutation(getDeleteUserMutationOptions(options));
}
export const getListAuditLogsUrl = (params?: ListAuditLogsParams,) => {
const normalizedParams = new URLSearchParams();
Object.entries(params || {}).forEach(([key, value]) => {
if (value !== undefined) {
normalizedParams.append(key, value === null ? 'null' : value.toString())
}
});
const stringifiedParams = normalizedParams.toString();
return stringifiedParams.length > 0 ? `/api/audit-logs?${stringifiedParams}` : `/api/audit-logs`
}
/**
* @summary List audit log entries (admin only)
*/
export const listAuditLogs = async (params?: ListAuditLogsParams, options?: RequestInit): Promise<AuditLog[]> => {
return customFetch<AuditLog[]>(getListAuditLogsUrl(params),
{
...options,
method: 'GET'
}
);}
export const getListAuditLogsQueryKey = (params?: ListAuditLogsParams,) => {
return [
`/api/audit-logs`, ...(params ? [params] : [])
] as const;
}
export const getListAuditLogsQueryOptions = <TData = Awaited<ReturnType<typeof listAuditLogs>>, TError = ErrorType<unknown>>(params?: ListAuditLogsParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listAuditLogs>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {
const {query: queryOptions, request: requestOptions} = options ?? {};
const queryKey = queryOptions?.queryKey ?? getListAuditLogsQueryKey(params);
const queryFn: QueryFunction<Awaited<ReturnType<typeof listAuditLogs>>> = ({ signal }) => listAuditLogs(params, { signal, ...requestOptions });
return { queryKey, queryFn, ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof listAuditLogs>>, TError, TData> & { queryKey: QueryKey }
}
export type ListAuditLogsQueryResult = NonNullable<Awaited<ReturnType<typeof listAuditLogs>>>
export type ListAuditLogsQueryError = ErrorType<unknown>
/**
* @summary List audit log entries (admin only)
*/
export function useListAuditLogs<TData = Awaited<ReturnType<typeof listAuditLogs>>, TError = ErrorType<unknown>>(
params?: ListAuditLogsParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listAuditLogs>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
const queryOptions = getListAuditLogsQueryOptions(params,options)
const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & { queryKey: QueryKey };
return { ...query, queryKey: queryOptions.queryKey };
}