@lvce-editor/auth-worker 1.0.0 → 1.2.0

package/dist/authWorkerMain.js

@@ -956,8 +956,15 @@ const create = rpcId => {
   };
 };
 
+const OpenerWorker = 4561;
 const RendererWorker = 1;
 
+const {
+  invoke} = create(OpenerWorker);
+const openUrl = async (url, platform) => {
+  return invoke('Open.openUrl', url, platform);
+};
+
 const {
   set
 } = create(RendererWorker);
@@ -973,8 +980,290 @@ const initialize = async platform => {
   // TODO
 };
 
+const trailingSlashesRegex = /\/+$/;
+const trimTrailingSlashes = value => {
+  return value.replace(trailingSlashesRegex, '');
+};
+
+const getBackendAuthUrl = (backendUrl, path) => {
+  return `${trimTrailingSlashes(backendUrl)}${path}`;
+};
+
+const getBackendLoginUrl = backendUrl => {
+  return getBackendAuthUrl(backendUrl, '/auth/login');
+};
+
+const getLoggedOutBackendAuthState = (authErrorMessage = '') => {
+  return {
+    authAccessToken: '',
+    authErrorMessage,
+    userName: '',
+    userState: 'loggedOut',
+    userSubscriptionPlan: '',
+    userUsedTokens: 0
+  };
+};
+
+const getBackendLogoutUrl = backendUrl => {
+  return getBackendAuthUrl(backendUrl, '/auth/logout');
+};
+
+const logoutFromBackend = async backendUrl => {
+  if (!backendUrl) {
+    return;
+  }
+  try {
+    await fetch(getBackendLogoutUrl(backendUrl), {
+      credentials: 'include',
+      headers: {
+        Accept: 'application/json'
+      },
+      method: 'POST'
+    });
+  } catch {
+    // Ignore logout failures and still clear local auth state.
+  }
+};
+
+const getBackendRefreshUrl = backendUrl => {
+  return getBackendAuthUrl(backendUrl, '/auth/refresh');
+};
+
+const delay = async ms => {
+  await new Promise(resolve => setTimeout(resolve, ms));
+};
+
+let nextLoginResponse;
+let nextRefreshResponse;
+const setNextLoginResponse = response => {
+  nextLoginResponse = response;
+};
+const setNextRefreshResponse = response => {
+  nextRefreshResponse = response;
+};
+const clear = () => {
+  nextLoginResponse = undefined;
+  nextRefreshResponse = undefined;
+};
+const hasPendingMockLoginResponse = () => {
+  return !!nextLoginResponse;
+};
+const hasPendingMockRefreshResponse = () => {
+  return !!nextRefreshResponse;
+};
+const consumeNextLoginResponse = async () => {
+  if (!nextLoginResponse) {
+    return undefined;
+  }
+  const response = nextLoginResponse;
+  nextLoginResponse = undefined;
+  if (response.delay > 0) {
+    await delay(response.delay);
+  }
+  if (response.type === 'error') {
+    throw new Error(response.message);
+  }
+  return response.response;
+};
+const consumeNextRefreshResponse = async () => {
+  if (!nextRefreshResponse) {
+    return undefined;
+  }
+  const response = nextRefreshResponse;
+  nextRefreshResponse = undefined;
+  if (response.delay > 0) {
+    await new Promise(resolve => setTimeout(resolve, response.delay));
+  }
+  if (response.type === 'error') {
+    throw new Error(response.message);
+  }
+  return response.response;
+};
+
+const isObject = value => {
+  return !!value && typeof value === 'object';
+};
+
+const isBackendAuthResponse = value => {
+  return isObject(value);
+};
+
+const getNumber = (value, fallback = 0) => {
+  return typeof value === 'number' ? value : fallback;
+};
+
+const getString = (value, fallback = '') => {
+  return typeof value === 'string' ? value : fallback;
+};
+
+const toBackendAuthState = value => {
+  return {
+    authAccessToken: getString(value.accessToken),
+    authErrorMessage: getString(value.error),
+    userName: getString(value.userName),
+    userState: value.accessToken ? 'loggedIn' : 'loggedOut',
+    userSubscriptionPlan: getString(value.subscriptionPlan),
+    userUsedTokens: getNumber(value.usedTokens)
+  };
+};
+
+const parseBackendAuthResponse = value => {
+  if (!isBackendAuthResponse(value)) {
+    return getLoggedOutBackendAuthState('Backend returned an invalid authentication response.');
+  }
+  return toBackendAuthState(value);
+};
+
+const syncBackendAuth = async backendUrl => {
+  if (!backendUrl) {
+    return getLoggedOutBackendAuthState('Backend URL is missing.');
+  }
+  try {
+    if (hasPendingMockRefreshResponse()) {
+      const mockResponse = await consumeNextRefreshResponse();
+      return parseBackendAuthResponse(mockResponse);
+    }
+    const response = await fetch(getBackendRefreshUrl(backendUrl), {
+      credentials: 'include',
+      headers: {
+        Accept: 'application/json'
+      },
+      method: 'POST'
+    });
+    if (response.status === 401 || response.status === 403) {
+      return getLoggedOutBackendAuthState();
+    }
+    let payload = undefined;
+    try {
+      payload = await response.json();
+    } catch {
+      payload = undefined;
+    }
+    if (!response.ok) {
+      const parsed = parseBackendAuthResponse(payload);
+      return getLoggedOutBackendAuthState(parsed.authErrorMessage || 'Backend authentication failed.');
+    }
+    const parsed = parseBackendAuthResponse(payload);
+    if (parsed.authErrorMessage) {
+      return getLoggedOutBackendAuthState(parsed.authErrorMessage);
+    }
+    if (!parsed.authAccessToken) {
+      return getLoggedOutBackendAuthState();
+    }
+    return parsed;
+  } catch (error) {
+    const authErrorMessage = error instanceof Error && error.message ? error.message : 'Backend authentication failed.';
+    return getLoggedOutBackendAuthState(authErrorMessage);
+  }
+};
+
+const waitForBackendLogin = async (backendUrl, timeoutMs = 30_000, pollIntervalMs = 1000) => {
+  const deadline = Date.now() + timeoutMs;
+  let lastErrorMessage = '';
+  while (Date.now() < deadline) {
+    const authState = await syncBackendAuth(backendUrl);
+    if (authState.userState === 'loggedIn') {
+      return authState;
+    }
+    if (authState.authErrorMessage) {
+      lastErrorMessage = authState.authErrorMessage;
+    }
+    await delay(pollIntervalMs);
+  }
+  return getLoggedOutBackendAuthState(lastErrorMessage);
+};
+
+const getLoggedInState = (state, response) => {
+  const accessToken = typeof response.accessToken === 'string' ? response.accessToken : '';
+  return {
+    ...state,
+    authAccessToken: accessToken,
+    authErrorMessage: '',
+    userName: typeof response.userName === 'string' ? response.userName : state.userName,
+    userState: accessToken ? 'loggedIn' : 'loggedOut',
+    userSubscriptionPlan: typeof response.subscriptionPlan === 'string' ? response.subscriptionPlan : state.userSubscriptionPlan,
+    userUsedTokens: typeof response.usedTokens === 'number' ? response.usedTokens : state.userUsedTokens
+  };
+};
+
+const isLoginResponse = value => {
+  if (!value || typeof value !== 'object') {
+    return false;
+  }
+  return true;
+};
+
+const handleClickLogin = async state => {
+  if (!state.backendUrl) {
+    return {
+      ...state,
+      authErrorMessage: 'Backend URL is missing.',
+      userState: 'loggedOut'
+    };
+  }
+  const signingInState = {
+    ...state,
+    authErrorMessage: '',
+    userState: 'loggingIn'
+  };
+  try {
+    if (hasPendingMockLoginResponse()) {
+      const response = await consumeNextLoginResponse();
+      if (!isLoginResponse(response)) {
+        return {
+          ...signingInState,
+          authErrorMessage: 'Backend returned an invalid login response.',
+          userState: 'loggedOut'
+        };
+      }
+      if (typeof response.error === 'string' && response.error) {
+        return {
+          ...signingInState,
+          authErrorMessage: response.error,
+          userState: 'loggedOut'
+        };
+      }
+      return getLoggedInState(signingInState, response);
+    }
+    await openUrl(getBackendLoginUrl(state.backendUrl), state.platform);
+    const authState = await waitForBackendLogin(state.backendUrl);
+    return {
+      ...signingInState,
+      ...authState
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error && error.message ? error.message : 'Backend authentication failed.';
+    return {
+      ...signingInState,
+      ...getLoggedOutBackendAuthState(errorMessage)
+    };
+  }
+};
+
+const logout = async state => {
+  const loggingOutState = {
+    authErrorMessage: '',
+    userState: 'loggingOut'
+  };
+  await logoutFromBackend(state.backendUrl);
+  return {
+    ...loggingOutState,
+    ...getLoggedOutBackendAuthState()
+  };
+};
+
 const commandMap = {
-  'AUth.initialize': initialize,
+  'Auth.clearMocks': clear,
+  'Auth.consumeNextLoginResponse': consumeNextLoginResponse,
+  'Auth.consumeNextRefreshResponse': consumeNextRefreshResponse,
+  'Auth.hasPendingMockLoginResponse': hasPendingMockLoginResponse,
+  'Auth.hasPendingMockRefreshResponse': hasPendingMockRefreshResponse,
+  'Auth.initialize': initialize,
+  'Auth.login': handleClickLogin,
+  'Auth.logout': logout,
+  'Auth.setNextLoginResponse': setNextLoginResponse,
+  'Auth.setNextRefreshResponse': setNextRefreshResponse,
+  'Auth.syncBackendAuth': syncBackendAuth,
   'HandleMessagePort.handleMessagePort': handleMessagePort
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/auth-worker",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Auth Worker",
   "repository": {
     "type": "git",