@raclettejs/core 0.0.1

package/services/frontend/src/core/lib/userNotifier.ts

@@ -0,0 +1,351 @@
+import { analyzeOperationResults } from "@racletteCore/lib/dataHelper"
+import configService from "@racletteCore/lib/configService"
+import { $eventbus, $store } from "@racletteCore/main"
+import type { SnackbarMessage } from "@racletteOrchestrator/components/snackbar/SnackStack.vue"
+/**
+ * userNotifier
+ */
+const shouldBePrevented = (notificationType: string, filter: any) => {
+  let prevent = false
+  const preventNotifications = configService.getPreventNotifications()
+  const preventType = preventNotifications[notificationType]
+  if (preventType) {
+    if (filter) {
+      for (const [key, value] of Object.entries(filter)) {
+        if (prevent) return
+        if (preventType[key] === value) {
+          prevent = true
+        }
+      }
+    }
+  }
+  return prevent
+}
+const setServerDisconnected = () => {
+  $store.dispatch({
+    type: "backend/socket/status",
+    payload: { status: 0 },
+  })
+  $store.dispatch({
+    type: "backend/search/status",
+    payload: { status: 0 },
+  })
+}
+
+const dataCreate = (isAnswerToOwnRequest, isSystemAction, items) => {
+  items.forEach((item) => {
+    if (isAnswerToOwnRequest) {
+      $eventbus.emit("ui_addToSnackBar", {
+        i18n: "core.dataCreate$displayName$type",
+        content: { displayName: item._displayName, type: item._type },
+        color: "success",
+      })
+    } else {
+      $store.dispatch({
+        type: "notifications/add",
+        payload: {
+          event: "dataCreate",
+          message: {
+            i18n: "core.dataCreate$displayName$type",
+            content: { displayName: item._displayName, type: item._type },
+          },
+          item: item._id,
+          type: item._type,
+          updatedBy: item._source.updatedBy,
+        },
+      })
+    }
+  })
+}
+
+const dataUpdate = (isAnswerToOwnRequest, isSystemAction, items) => {
+  items.forEach((item) => {
+    if (isAnswerToOwnRequest) {
+      $eventbus.emit("ui_addToSnackBar", {
+        i18n: "core.dataUpdate$displayName$type",
+        content: { displayName: item._displayName, type: item._type },
+        color: "success",
+      })
+    } else {
+      $store.dispatch({
+        type: "notifications/add",
+        payload: {
+          event: "dataUpdate",
+          message: {
+            i18n: "core.dataUpdate$displayName$type",
+            content: { displayName: item._displayName, type: item._type },
+          },
+          item: item._id,
+          type: item._type,
+          updatedBy: item._source.updatedBy,
+        },
+      })
+    }
+  })
+}
+
+const projectUpdate = (isAnswerToOwnRequest, isSystemAction, items) => {
+  items.forEach((item) => {
+    const displayValues = item._source
+
+    if (isAnswerToOwnRequest) {
+      $eventbus.emit("ui_addToSnackBar", {
+        i18n: "core.projectUpdate$shorttitle",
+        content: { shorttitle: displayValues.shorttitle },
+        color: "success",
+      })
+    } else {
+      $store.dispatch({
+        type: "notifications/add",
+        payload: {
+          event: "projectUpdate",
+          message: {
+            i18n: "core.projectUpdate$shorttitle",
+            content: { shorttitle: displayValues.shorttitle },
+          },
+          item: item._id,
+          type: item._type,
+          updatedBy: item._source.updatedBy || "system",
+        },
+      })
+    }
+  })
+
+  $eventbus.emit("ui_addToSnackBar", {
+    i18n: "core.reloadPageHint",
+    color: "info",
+  })
+}
+
+const projectConfigUpdate = (isAnswerToOwnRequest, isSystemAction, items) =>
+  $eventbus.emit("ui_addToSnackBar", {
+    i18n: "core.reloadPageHint",
+    color: "info",
+  })
+
+const userConfigUpdate = (isAnswerToOwnRequest, isSystemAction, items) =>
+  $eventbus.emit("ui_addToSnackBar", {
+    i18n: "core.reloadPageHint",
+    color: "info",
+  })
+
+const dataDelete = (isAnswerToOwnRequest, isSystemAction, deletedItems) =>
+  deletedItems.forEach((item) => {
+    if (isAnswerToOwnRequest) {
+      $eventbus.emit("ui_addToSnackBar", {
+        i18n: "core.dataDelete$displayName$type",
+        content: { displayName: item._displayName, type: item._type },
+        color: "success",
+      })
+    } else {
+      $store.dispatch({
+        type: "notifications/add",
+        payload: {
+          event: "dataDelete",
+          message: {
+            i18n: "core.dataDelete$displayName$type",
+            content: { displayName: item._displayName, type: item._type },
+          },
+          item: item._id,
+          type: item._type,
+          updatedBy: item._source.updatedBy,
+        },
+      })
+    }
+  })
+
+const dataMove = (isAnswerToOwnRequest, isSystemAction, items) => {
+  items.forEach((item) => {
+    if (isAnswerToOwnRequest) {
+      $eventbus.emit("ui_addToSnackBar", {
+        i18n: "core.dataMove$displayName$type",
+        content: { displayName: item._displayName, type: item._type },
+        color: "success",
+      })
+    } else {
+      $store.dispatch({
+        type: "notifications/add",
+        payload: {
+          event: "dataMove",
+          message: {
+            i18n: "core.dataMove$displayName$type",
+            content: { displayName: item._displayName, type: item._type },
+          },
+          item: item._id,
+          type: item._type,
+          updatedBy: item._source.updatedBy,
+        },
+      })
+    }
+  })
+}
+
+const batchRetrieved = (count, trigger) =>
+  $store.dispatch({
+    type: "notifications/add",
+    payload: {
+      event: "dataSync",
+      message: {
+        i18n: "core.batch$CountSynced",
+        content: { count },
+      },
+      updatedBy: trigger,
+    },
+  })
+const checkToken = (payload) => {
+  const { status, response } = payload
+  if (shouldBePrevented("checkToken", { status })) {
+    return
+  }
+  const firstName = response?.firstname || "system"
+
+  if (status === 200) {
+    const message = {
+      i18n: "core.authentication.welcomeBack$name",
+      content: {
+        name: `${firstName}`,
+      },
+      color: "green",
+    }
+    $eventbus.emit("ui_addToSnackBar", message)
+    $store.dispatch({
+      type: "notifications/add",
+      payload: {
+        event: "checkToken",
+        message,
+        updatedBy: "system",
+      },
+    })
+  }
+  if (status === 401) {
+    const message = {
+      i18n: "core.authentication." + response.code,
+      color: "error",
+    }
+    $eventbus.emit("ui_addToSnackBar", message)
+    $store.dispatch({
+      type: "notifications/add",
+      payload: {
+        event: "checkToken",
+        message,
+        updatedBy: "system",
+      },
+    })
+  }
+  if (status === 500) {
+    let message
+    if (response.code) {
+      message = {
+        i18n: "core.authentication." + response.code,
+        color: "error",
+      }
+    } else {
+      message = {
+        message: response.message,
+        color: "error",
+      }
+    }
+    $eventbus.emit("ui_addToSnackBar", message)
+    $store.dispatch({
+      type: "notifications/add",
+      payload: {
+        event: "checkToken",
+        message,
+        updatedBy: "system",
+      },
+    })
+  }
+}
+const newVersionAvailable = () =>
+  $eventbus.emit("ui_addToSnackBar", {
+    i18n: "core.versionUpdate",
+    color: "info",
+    timeout: -1,
+  })
+
+const dataMergeResponse = (isAnswerToOwnRequest, res) => {
+  const analysisResult = analyzeOperationResults(res.operations)
+
+  Object.keys(analysisResult).forEach((operation) => {
+    const currentOperation = analysisResult[operation]
+
+    if (currentOperation.failure) {
+      Object.keys(currentOperation.failure).forEach((type) =>
+        $eventbus.emit("ui_addToSnackBar", {
+          i18n: "core.dataSync." + operation + ".$docCountOf$docTypeHaveFailed",
+          content: {
+            docCount: currentOperation.failure[type],
+            docType: type,
+          },
+          color: "error",
+        }),
+      )
+    }
+    if (currentOperation.success) {
+      Object.keys(currentOperation.success).forEach((type) =>
+        $eventbus.emit("ui_addToSnackBar", {
+          i18n:
+            "core.dataSync." +
+            operation +
+            ".$docCountOf$docTypeHaveBeenHandled",
+          content: {
+            docCount: currentOperation.success[type],
+            docType: type,
+          },
+          color: "success",
+        }),
+      )
+    }
+  })
+  if (res.totals.received === res.totals.succeeded) {
+  }
+  if (res.totals.received === res.totals.failed) {
+  }
+  if (
+    res.totals.received &&
+    res.totals.failed > 0 &&
+    res.totals.succeeded > 0
+  ) {
+    $eventbus.emit("ui_addToSnackBar", {
+      i18n: "core.dataSync.$docCountOf$docTypeHaveFailed$docCount1HaveSucceeded",
+      content: {
+        docCount: res.totals.failed,
+        type: res.docType,
+        docCount1: res.totals.succeeded,
+      },
+      color: "error",
+    })
+  }
+}
+
+const add = (message: string | string[], color = "info") => {
+  if (Array.isArray(message)) {
+    message.forEach((text) =>
+      $eventbus.emit("ui_addToSnackBar", {
+        message: text,
+        color,
+      } satisfies SnackbarMessage),
+    )
+  } else {
+    $eventbus.emit("ui_addToSnackBar", {
+      message,
+      color,
+    } satisfies SnackbarMessage)
+  }
+}
+
+export {
+  add,
+  dataCreate,
+  dataUpdate,
+  dataDelete,
+  dataMove,
+  batchRetrieved,
+  dataMergeResponse,
+  projectUpdate,
+  projectConfigUpdate,
+  userConfigUpdate,
+  newVersionAvailable,
+  setServerDisconnected,
+  checkToken,
+}

package/services/frontend/src/core/main.ts

@@ -0,0 +1,279 @@
+import { nanoid } from "nanoid"
+import getEnvVariable from "@racletteCore/lib/getEnvVariable"
+import {
+  httpClient,
+  configureClient,
+  configureHttpInterceptors,
+  apiHealthcheck,
+  setHttpToken,
+} from "@racletteCore/lib/httpClient"
+
+import { chadsayFE } from "@racletteCore"
+import createStore, { registerStoreEffects } from "@racletteCore/store"
+import type { RacletteStore, CorePluginApi } from "@racletteCore"
+import type { AxiosError, AxiosInstance } from "axios"
+import createSocket from "@racletteCore/setup/socket"
+import EventEmitter from "@racletteCore/lib/eventEmitter"
+import {
+  eventWhitelist,
+  eventWildcards,
+} from "@racletteCore/lib/eventWhitelist"
+import type { Socket } from "socket.io-client"
+import registerSocketEvents from "@racletteCore/setup/socketEvents"
+import registerSocketClient from "@racletteCore/setup/socketClient"
+import { AUTH_TOKEN_KEY } from "@racletteCore/setup/sessionHandler"
+import $log from "@racletteCore/lib/logger"
+import { awaitTime } from "@racletteCore/lib/dataHelper"
+import type { User } from "@shared/types/core/User.types"
+import { checkToken } from "@racletteCore/lib/userNotifier"
+import configService from "@racletteCore/lib/configService"
+import {
+  registerPlugins,
+  registeredPlugins,
+} from "@racletteCore/setup/plugin-system"
+
+const SOCKET_URL = getEnvVariable("RACLETTE_SOCKET_URL")
+const API_BASE_URL = getEnvVariable("RACLETTE_SERVER_BASE_URL")
+
+export type CreateAppResponse = {
+  authenticated: boolean
+  setupComplete: boolean
+  error?: string
+  login?: (loginParameters: {
+    email: string
+    password: string
+  }) => Promise<LoginResponse>
+  spaceId?: string
+  code?: string
+}
+export type LoginResponse = {
+  success: boolean
+  token?: string
+  error?: string
+  message?: string
+  redirect?: () => void
+}
+
+const appSessionId = nanoid()
+const eventbus: EventEmitter = new EventEmitter(eventWhitelist, eventWildcards)
+let axiosClient: AxiosInstance
+let socket: Socket
+let corePluginApi: CorePluginApi
+let store: RacletteStore = createStore(eventbus, appSessionId)
+const initPluginRegistration = async () => {
+  if (corePluginApi && !Object.keys(registeredPlugins).length) {
+    await registerPlugins(corePluginApi)
+  }
+}
+const createRacletteApp = async (
+  options = { requireAuth: true },
+): Promise<CreateAppResponse> => {
+  setupHttpClient()
+
+  let user: User | null = null
+  await configService.init()
+  if (options.requireAuth) {
+    const { authenticated, error, user: _user, code } = await checkAuthStatus()
+
+    if (!authenticated) {
+      return {
+        authenticated,
+        error,
+        setupComplete: false,
+        login: generateLoginCallback(),
+        code,
+      }
+    }
+
+    user = _user!
+  }
+
+  await setupDependencies()
+
+  store.dispatch({ type: "user/set", payload: user })
+
+  // does the core really need to communicate with itself via eventbus?
+  eventbus.emit("socket_joinRoom")
+
+  return new Promise<CreateAppResponse>(async (resolve, reject) => {
+    eventbus.on("ui_setupProject", (spaceId: string) => {
+      resolve({
+        authenticated: true,
+        setupComplete: true,
+        spaceId,
+      })
+      console.log(chadsayFE("Raclette is up and running!"))
+    })
+    await awaitTime(2000)
+    reject("timeouted")
+  })
+}
+
+const setupHttpClient = () => {
+  axiosClient = httpClient.axios
+  const token = getCookie(AUTH_TOKEN_KEY)
+
+  configureClient(API_BASE_URL, appSessionId, token)
+}
+
+const handleSuccessfulLogin = (token) => {
+  const expiryDate = new Date()
+
+  const expiryDays = configService.getAuthTokenExpiryDays()
+  expiryDate.setDate(expiryDate.getDate() + expiryDays)
+  document.cookie = `${AUTH_TOKEN_KEY}=${token}; expires=${expiryDate.toUTCString()}; path=/; SameSite=Strict`
+
+  setHttpToken(token)
+}
+
+const generateLoginCallback =
+  () =>
+  async (
+    loginParameters: { email: string; password: string },
+    callbackUrl?: string,
+  ): Promise<LoginResponse> => {
+    try {
+      const _callbackUrl = callbackUrl || window.location.origin
+
+      // Make the login request to the backend
+      const response = await axiosClient.post(
+        "/core/user/login",
+        loginParameters,
+      )
+
+      if (response.data && response.data.token) {
+        const { token } = response.data
+
+        // store token
+        handleSuccessfulLogin(token)
+
+        // Setup all dependencies now that we have authentication
+        setupDependencies()
+
+        store.dispatch({ type: "user/set", payload: response.data.user })
+
+        eventbus.emit("socket_joinRoom")
+
+        // Return success with token & redirect function
+        return {
+          success: true,
+          token: token,
+          redirect: () => {
+            // If we're in the same origin, we keep the history
+            if (
+              _callbackUrl.startsWith(window.location.origin) ||
+              _callbackUrl.startsWith("/")
+            ) {
+              window.location.href = _callbackUrl
+            } else {
+              // Otherwise do a full page reload to the callback URL
+              window.location.replace(_callbackUrl)
+            }
+          },
+        }
+      } else {
+        // Handle successful response but missing token
+        return {
+          success: false,
+          // TODO: Constants would be nice here
+          error: new Error("Invalid response: Token not found"),
+          message: "Authentication failed: Invalid server response",
+        }
+      }
+    } catch (error: unknown) {
+      const axiosError = error as AxiosError<{
+        error?: string
+        message?: string
+      }>
+
+      // Extract error message from response if available
+      // TODO: Constants would be nice here
+      const errorMessage =
+        axiosError.response?.data?.message ||
+        axiosError.response?.data?.error ||
+        "Authentication failed"
+
+      return {
+        success: false,
+        error,
+        message: errorMessage,
+      }
+    }
+  }
+
+const getCookie = (name: string): string | null => {
+  const match = document.cookie.match(new RegExp("(^| )" + name + "=([^;]+)"))
+
+  return match ? match[2] : null
+}
+
+const checkAuthStatus = async (): Promise<{
+  authenticated: boolean
+  error?: string
+  user?: User
+  code?: string
+}> => {
+  try {
+    const { status, data: user } = await axiosClient.get(
+      "/core/user/check-token",
+    )
+    checkToken({ status, response: user })
+    return { authenticated: status === 200, user }
+  } catch (error: unknown) {
+    const axiosError = error as AxiosError<{
+      error?: string
+      message?: string
+      code?: string
+    }>
+
+    console.error("Auth validation failed:", axiosError)
+
+    checkToken({
+      status: axiosError.status,
+      response: axiosError?.response?.data,
+    })
+    return {
+      authenticated: false,
+      error: axiosError.response?.data.error,
+      code: axiosError.response?.data.code,
+    }
+  }
+}
+
+const setupDependencies = async () => {
+  registerStoreEffects(store)
+
+  // api client - remaining config
+  configureHttpInterceptors(store)
+  apiHealthcheck(store)
+
+  // socket
+  socket = createSocket(SOCKET_URL, appSessionId)
+
+  registerSocketEvents(socket, store, eventbus)
+  // listen to eventbus and send messages to the socket server
+  registerSocketClient(socket, eventbus)
+
+  // TODO: improve this code
+  corePluginApi = {
+    $store: store,
+    $api: httpClient,
+    $eventbus: eventbus,
+    $socket: socket,
+    $log,
+  }
+
+  return { appSessionId, store, httpClient, eventbus, socket }
+}
+
+export default createRacletteApp
+
+export {
+  appSessionId,
+  store as $store,
+  httpClient as $api,
+  eventbus as $eventbus,
+  socket as $socket,
+  corePluginApi,
+  initPluginRegistration,
+}