accounts-frontend/packages/app/services/api/oauth.ts

201 lines
5.2 KiB
TypeScript
Raw Normal View History

2019-12-07 16:58:52 +05:30
/* eslint-disable @typescript-eslint/camelcase */
import { ApplicationType } from 'app/components/dev/apps';
import request from 'app/services/request';
export type Scope =
| 'minecraft_server_session'
| 'offline_access'
| 'account_info'
| 'account_email';
2019-12-07 16:58:52 +05:30
export type Client = {
id: string;
name: string;
description: string;
};
export type OauthAppResponse = {
2019-12-07 16:58:52 +05:30
clientId: string;
clientSecret: string;
type: ApplicationType;
name: string;
websiteUrl: string;
createdAt: number;
// fields for 'application' type
2019-12-07 16:58:52 +05:30
countUsers?: number;
description?: string;
redirectUri?: string;
// fields for 'minecraft-server' type
2019-12-07 16:58:52 +05:30
minecraftServerIp?: string;
};
2018-05-03 10:45:09 +05:30
type OauthRequestData = {
2019-12-07 16:58:52 +05:30
client_id: string;
redirect_uri: string;
response_type: string;
description?: string;
2019-12-07 16:58:52 +05:30
scope: string;
prompt: string;
login_hint?: string;
state?: string;
2018-05-03 10:45:09 +05:30
};
export type OauthData = {
2019-12-07 16:58:52 +05:30
clientId: string;
redirectUrl: string;
responseType: string;
description?: string;
2019-12-07 16:58:52 +05:30
scope: string;
prompt: string; // comma separated list of 'none' | 'consent' | 'select_account';
loginHint?: string;
state?: string;
2018-05-03 10:45:09 +05:30
};
type FormPayloads = {
2019-12-07 16:58:52 +05:30
name?: string;
description?: string;
websiteUrl?: string;
redirectUri?: string;
minecraftServerIp?: string;
};
const api = {
validate(oauthData: OauthData) {
return request
2019-12-07 16:58:52 +05:30
.get<{
session: {
scopes: Scope[];
};
client: Client;
oAuth: {};
}>('/api/oauth2/v1/validate', getOAuthRequest(oauthData))
.catch(handleOauthParamsValidation);
},
complete(
oauthData: OauthData,
params: { accept?: boolean } = {},
): Promise<{
2019-12-07 16:58:52 +05:30
success: boolean;
redirectUri: string;
}> {
const query = request.buildQuery(getOAuthRequest(oauthData));
return request
.post<{
2019-12-07 16:58:52 +05:30
success: boolean;
redirectUri: string;
}>(
`/api/oauth2/v1/complete?${query}`,
typeof params.accept === 'undefined' ? {} : { accept: params.accept },
)
.catch((resp = {}) => {
if (resp.statusCode === 401 && resp.error === 'access_denied') {
// user declined permissions
return {
success: false,
redirectUri: resp.redirectUri,
originalResponse: resp.originalResponse,
};
}
if (resp.status === 401 && resp.name === 'Unauthorized') {
2019-12-07 16:58:52 +05:30
const error: { [key: string]: any } = new Error('Unauthorized');
error.unauthorized = true;
throw error;
}
if (resp.statusCode === 401 && resp.error === 'accept_required') {
2019-12-07 16:58:52 +05:30
const error: { [key: string]: any } = new Error(
'Permissions accept required',
);
error.acceptRequired = true;
throw error;
}
return handleOauthParamsValidation(resp);
});
},
create(type: string, formParams: FormPayloads) {
2019-12-07 16:58:52 +05:30
return request.post<{ success: boolean; data: OauthAppResponse }>(
`/api/v1/oauth2/${type}`,
formParams,
);
},
update(clientId: string, formParams: FormPayloads) {
2019-12-07 16:58:52 +05:30
return request.put<{ success: boolean; data: OauthAppResponse }>(
`/api/v1/oauth2/${clientId}`,
formParams,
);
},
getApp(clientId: string) {
return request.get<OauthAppResponse>(`/api/v1/oauth2/${clientId}`);
},
getAppsByUser(userId: number): Promise<OauthAppResponse[]> {
return request.get(`/api/v1/accounts/${userId}/oauth2/clients`);
},
reset(clientId: string, regenerateSecret: boolean = false) {
2019-12-07 16:58:52 +05:30
return request.post<{ success: boolean; data: OauthAppResponse }>(
`/api/v1/oauth2/${clientId}/reset${
regenerateSecret ? '?regenerateSecret' : ''
}`,
);
},
delete(clientId: string) {
return request.delete<{ success: boolean }>(`/api/v1/oauth2/${clientId}`);
},
};
2019-12-07 16:58:52 +05:30
if ('Cypress' in window) {
(window as any).oauthApi = api;
}
export default api;
/**
* @param {object} oauthData
* @param {string} oauthData.clientId
* @param {string} oauthData.redirectUrl
* @param {string} oauthData.responseType
* @param {string} oauthData.description
* @param {string} oauthData.scope
* @param {string} oauthData.state
*
* @returns {object}
*/
2018-05-03 10:45:09 +05:30
function getOAuthRequest(oauthData: OauthData): OauthRequestData {
return {
client_id: oauthData.clientId,
redirect_uri: oauthData.redirectUrl,
response_type: oauthData.responseType,
description: oauthData.description,
scope: oauthData.scope,
prompt: oauthData.prompt,
login_hint: oauthData.loginHint,
state: oauthData.state,
};
}
2019-12-07 16:58:52 +05:30
function handleOauthParamsValidation(resp: { [key: string]: any } = {}) {
if (resp.statusCode === 400 && resp.error === 'invalid_request') {
resp.userMessage = `Invalid request (${resp.parameter} required).`;
} else if (
resp.statusCode === 400 &&
resp.error === 'unsupported_response_type'
) {
resp.userMessage = `Invalid response type '${resp.parameter}'.`;
} else if (resp.statusCode === 400 && resp.error === 'invalid_scope') {
resp.userMessage = `Invalid scope '${resp.parameter}'.`;
} else if (resp.statusCode === 401 && resp.error === 'invalid_client') {
resp.userMessage = 'Can not find application you are trying to authorize.';
}
return Promise.reject(resp);
}