Files
artcraft/frontend/libs/api/src/lib/UsersApi.ts
T
Brandon Thomas 0004726a36 ArtCraft Desktop (fresh start)
This is a fresh start for the `artcraft` repo.

The old monorepo, which included our web API gateway, job services, SRE
tools, various frontends, and more has moved to `artcraft-services`

You can find the full git history here:

https://github.com/storytold/artcraft-services

This change was motivated by the fact that the entire git history was
hundreds of gigabytes in size, which is unwieldy for anyone not in the
core team that doesn't care about support services outside of the core
artcraft app.

We wanted to keep this repo in its well-known place since we already
have users and activity here.

Please update your remotes to either `artcraft-services` or make a fresh
clone of this repo.

History can be found at the artcraft-services repo.
2026-09-11 14:19:51 -04:00

468 lines
12 KiB
TypeScript

import { ApiManager, ApiResponse, buildSessionHeaders, storeSignedSession, clearSignedSession } from "./ApiManager.js";
import { UserInfo } from "./models/Users.js";
import { FetchProxy as fetch } from "@storyteller/tauri-utils";
interface SignupRequest {
username: string;
email_address: string;
password: string;
password_confirmation: string;
signup_source?: string;
maybe_referral_url?: string;
maybe_landing_url?: string;
maybe_referral_username?: string;
maybe_referral_code?: string;
}
export class UsersApi extends ApiManager {
private async authFetch<B, T>(
endpoint: string,
{
method,
body,
}: {
method: string;
body?: B;
},
): Promise<T> {
const bodyInString = JSON.stringify(body);
const response = await fetch(endpoint, {
method,
headers: buildSessionHeaders({
Accept: "application/json",
"Content-Type": "application/json",
}),
credentials: "include",
body: bodyInString,
});
const text = await response.text();
try {
const responseData = JSON.parse(text);
return responseData as T;
} catch (e) {
console.error("Failed to parse response as JSON:", text);
throw new Error(text || `Request failed with status ${response.status}`);
}
}
public GetSession(): Promise<
ApiResponse<{
loggedIn: boolean;
user?: UserInfo;
onboarding?: {
email_not_set: boolean;
email_not_confirmed: boolean;
password_not_set: boolean;
username_not_customized: boolean;
};
}>
> {
const endpoint = `${this.getApiSchemeAndHost()}/v1/session`;
return this.get<{
success: boolean;
logged_in: boolean;
user?: UserInfo & {
onboarding?: {
email_not_set: boolean;
email_not_confirmed: boolean;
password_not_set: boolean;
username_not_customized: boolean;
};
};
error_message?: string;
}>({ endpoint: endpoint })
.then((response) => ({
success: response.success,
data: {
loggedIn: response.logged_in,
user: response.user,
onboarding: response.user?.onboarding,
},
}))
.catch((err) => {
return {
success: false,
errorMessage: err.message,
};
});
}
public GetUserProfile(username: string): Promise<
ApiResponse<{
user?: UserInfo;
}>
> {
const endpoint = `${this.getApiSchemeAndHost()}/v1/user/${username}/profile`;
console.log("endpoint", endpoint);
return this.get<{
success: boolean;
user?: UserInfo;
error_message?: string;
}>({ endpoint: endpoint })
.then((response) => ({
success: response.success,
data: {
user: response.user,
},
}))
.catch((err) => {
return {
success: false,
errorMessage: err.message,
};
});
}
public async Login({
usernameOrEmail,
password,
}: {
usernameOrEmail: string;
password: string;
}): Promise<ApiResponse<{ signedSession?: string }>> {
console.log("libs/api - Logging in with usernameOrEmail:", usernameOrEmail);
const endpoint = `${this.getApiSchemeAndHost()}/v1/login`;
console.log("libs/api - Login endpoint", endpoint);
const body = {
username_or_email: usernameOrEmail,
password: password,
};
try {
const response = await this.authFetch<
{ username_or_email: string; password: string },
{
success: boolean;
signed_session?: string;
error_message?: string;
error_type?: string;
}
>(endpoint, {
method: "POST",
body: body,
});
if (response.success && response.signed_session) {
storeSignedSession(response.signed_session);
}
return {
success: response.success,
data: response.success
? { signedSession: response.signed_session }
: undefined,
errorMessage: response.error_message,
};
} catch (err: any) {
return {
success: false,
errorMessage: err.message,
};
}
}
public Logout(): Promise<ApiResponse<null>> {
clearSignedSession();
const endpoint = `${this.getApiSchemeAndHost()}/v1/logout`;
return this.post<null, { success: boolean; error_message?: string }>({
endpoint: endpoint,
})
.then((response) => ({
success: response.success,
}))
.catch((err) => {
return {
success: false,
errorMessage: err.message,
};
});
}
public async LogWebReferral({
maybeReferralUrl,
}: {
maybeReferralUrl?: string;
}): Promise<ApiResponse<{ success: boolean }>> {
const endpoint = `${this.getApiSchemeAndHost()}/v1/web_referrals/record`;
const body = {
maybe_referral_url: maybeReferralUrl ?? null,
};
try {
const response = await this.authFetch<
{ maybe_referral_url: string | null },
{ success: boolean }
>(endpoint, {
method: "POST",
body,
});
return { success: response.success };
} catch {
return { success: false };
}
}
public async Signup({
username,
email,
password,
passwordConfirmation,
signupSource,
maybeReferralUrl,
maybeLandingUrl,
maybeReferralUsername,
maybeReferralCode,
}: {
username: string;
email: string;
password: string;
passwordConfirmation: string;
signupSource?: string;
maybeReferralUrl?: string;
maybeLandingUrl?: string;
maybeReferralUsername?: string;
maybeReferralCode?: string;
}): Promise<ApiResponse<{ signedSession?: string }>> {
const endpoint = `${this.getApiSchemeAndHost()}/v1/create_account`;
const body: SignupRequest = {
email_address: email,
password,
password_confirmation: passwordConfirmation,
username,
};
if (signupSource) {
body.signup_source = signupSource;
}
if (maybeReferralUrl) {
body.maybe_referral_url = maybeReferralUrl;
}
if (maybeLandingUrl) {
body.maybe_landing_url = maybeLandingUrl;
}
if (maybeReferralUsername) {
body.maybe_referral_username = maybeReferralUsername;
}
if (maybeReferralCode) {
body.maybe_referral_code = maybeReferralCode;
}
try {
const response = await this.authFetch<
SignupRequest,
{
success: boolean;
signed_session?: string;
error_fields?: Record<string, string>;
error_message?: string;
error_type?: string;
}
>(endpoint, {
method: "POST",
body: body,
});
if (response.success && response.signed_session) {
storeSignedSession(response.signed_session);
}
return {
success: response.success,
data: response.success
? { signedSession: response.signed_session }
: undefined,
errorMessage:
response.error_message ||
Object.values(response.error_fields ?? {}).join(", "),
};
} catch (err: any) {
return {
success: false,
errorMessage: err.message,
};
}
}
public async GoogleSSO({
credential,
maybeReferralUrl,
maybeLandingUrl,
maybeReferralUsername,
maybeReferralCode,
}: {
credential: string;
maybeReferralUrl?: string;
maybeLandingUrl?: string;
maybeReferralUsername?: string;
maybeReferralCode?: string;
}): Promise<ApiResponse<{ usernameNotYetCustomized?: boolean }>> {
const endpoint = `${this.getApiSchemeAndHost()}/v1/accounts/google_sso`;
const body: {
google_credential: string;
maybe_referral_url?: string;
maybe_landing_url?: string;
maybe_referral_username?: string;
maybe_referral_code?: string;
} = {
google_credential: credential,
};
if (maybeReferralUrl) {
body.maybe_referral_url = maybeReferralUrl;
}
if (maybeLandingUrl) {
body.maybe_landing_url = maybeLandingUrl;
}
if (maybeReferralUsername) {
body.maybe_referral_username = maybeReferralUsername;
}
if (maybeReferralCode) {
body.maybe_referral_code = maybeReferralCode;
}
try {
const response = await this.authFetch<
{
google_credential: string;
maybe_referral_url?: string;
maybe_landing_url?: string;
maybe_referral_username?: string;
maybe_referral_code?: string;
},
{
success: boolean;
signed_session?: string;
username_not_yet_customized?: boolean;
error_message?: string;
}
>(endpoint, {
method: "POST",
body: body,
});
// Store the signed session so auth survives where the cross-domain
// cookie is blocked (e.g. Safari ITP) — mirrors Login/Signup.
if (response.success && response.signed_session) {
storeSignedSession(response.signed_session);
}
return {
success: response.success,
data: response.success
? { usernameNotYetCustomized: response.username_not_yet_customized }
: undefined,
errorMessage: response.error_message,
};
} catch (err: any) {
return {
success: false,
errorMessage: err.message,
};
}
}
public async ChangePassword({
password,
passwordConfirmation,
}: {
password: string;
passwordConfirmation: string;
}): Promise<ApiResponse<null>> {
const endpoint = `${this.getApiSchemeAndHost()}/v1/user/change_password`;
const body = {
password,
password_confirmation: passwordConfirmation,
};
try {
const response = await this.authFetch<
{ password: string; password_confirmation: string },
{
success: boolean;
error_message?: string;
}
>(endpoint, {
method: "POST",
body: body,
});
return {
success: response.success,
errorMessage: response.error_message,
};
} catch (err: any) {
return {
success: false,
errorMessage: err.message,
};
}
}
public async EditEmail({
emailAddress,
}: {
emailAddress: string;
}): Promise<ApiResponse<null>> {
const endpoint = `${this.getApiSchemeAndHost()}/v1/user/edit_email`;
const body = {
email_address: emailAddress,
};
try {
const response = await this.authFetch<
{ email_address: string },
{
success: boolean;
error_message?: string;
}
>(endpoint, {
method: "POST",
body: body,
});
return {
success: response.success,
errorMessage: response.error_message,
};
} catch (err: any) {
return {
success: false,
errorMessage: err.message,
};
}
}
public async EditUsername({
displayName,
}: {
displayName: string;
}): Promise<ApiResponse<null>> {
const endpoint = `${this.getApiSchemeAndHost()}/v1/user/edit_username`;
const body = {
display_name: displayName,
};
try {
const response = await this.authFetch<
{ display_name: string },
{
success: boolean;
error_message?: string;
}
>(endpoint, {
method: "POST",
body: body,
});
return {
success: response.success,
errorMessage: response.error_message,
};
} catch (err: any) {
return {
success: false,
errorMessage: err.message,
};
}
}
}
(window as any).UsersApi = new UsersApi();