@raclettejs/core 0.0.1

package/services/frontend/src/core/setup/plugin-system/registration/index.ts

@@ -0,0 +1,181 @@
+import logger from "@racletteCore/lib/logger"
+import { getPluginWidgets } from "@racletteOrchestrator/helpers/staticWidgetRegistry"
+import { discoverAllPlugins } from "../discovery"
+import {
+  registeredPlugins,
+  addRegisteredPlugin,
+  addPluginPathMapping,
+} from "../state"
+import {
+  wrapLogApi,
+  wrapFileApi,
+  wrapEventbusApi,
+  wrapSocketApi,
+} from "../api/wrappers"
+import {
+  installPluginData,
+  handlePluginOperations,
+  updateTranslations,
+} from "../api/plugin-data"
+import { loadPluginDefinition } from "./loader"
+import { handlePluginError } from "./error-handling"
+import type { CorePluginApi, RegisteredPlugin } from "@racletteCore"
+import { DEFAULT_ERROR_FLAGS } from "../constants"
+import type { DiscoveredPlugin, PluginApi } from "../types"
+
+/**
+ * Main plugin registration function
+ */
+export const registerPlugins = async (
+  corePluginApi: CorePluginApi,
+  errorFlags: number = DEFAULT_ERROR_FLAGS,
+): Promise<{ [key: string]: RegisteredPlugin }> => {
+  let registeredCount = 0
+
+  try {
+    // Discover all plugins
+    const allPlugins = await discoverAllPlugins()
+
+    logger.pluginRegistrar(`Found ${allPlugins.length} plugins total`)
+
+    // Register each plugin
+    for (const plugin of allPlugins) {
+      try {
+        const success = await loadAndRegisterPlugin(
+          plugin,
+          corePluginApi,
+          errorFlags,
+        )
+
+        if (success) {
+          registeredCount++
+          logger.pluginRegistrar(
+            `Successfully registered ${plugin.type} plugin: ${plugin.pluginKey}`,
+          )
+        }
+      } catch (error) {
+        const errorMsg = `Error registering ${plugin.type} plugin ${plugin.pluginKey}: ${(error as Error).message}`
+        handlePluginError(errorMsg, plugin.type, errorFlags)
+      }
+    }
+
+    logger.pluginRegistrar(`Total plugins registered: ${registeredCount}`)
+    return registeredPlugins
+  } catch (error) {
+    logger.pluginRegistrar("Critical error during plugin registration:", error)
+    throw error
+  }
+}
+
+/**
+ * Load and register a single plugin
+ */
+export const loadAndRegisterPlugin = async (
+  plugin: DiscoveredPlugin,
+  corePluginApi: CorePluginApi,
+  errorFlags: number,
+): Promise<boolean> => {
+  try {
+    // Load plugin definition from frontend directory
+    const pluginDefinition = await loadPluginDefinition(plugin.frontendPath)
+    if (!pluginDefinition) {
+      const error = `No plugin definition found for ${plugin.pluginKey}`
+      handlePluginError(error, plugin.type, errorFlags)
+      return false
+    }
+
+    // Initialize plugin entry
+    if (!registeredPlugins[plugin.pluginKey]) {
+      const newPlugin: RegisteredPlugin = {
+        author: plugin.metadata.author,
+        pluginKey: plugin.pluginKey,
+        pluginType: plugin.type,
+        path: plugin.pluginPath,
+        widgets: getPluginWidgets(plugin.frontendPath),
+        options: {},
+      }
+      addRegisteredPlugin(plugin.pluginKey, newPlugin)
+    }
+
+    const currentPlugin = registeredPlugins[plugin.pluginKey]
+    addPluginPathMapping(plugin.pluginPath, plugin.pluginKey)
+
+    let pluginApi: Partial<PluginApi> & { [key: string]: unknown } = {}
+
+    // Initialize plugin API components
+    if (corePluginApi.$log) {
+      pluginApi = wrapLogApi(corePluginApi.$log, plugin.pluginKey, pluginApi)
+    }
+
+    if (corePluginApi.$file) {
+      pluginApi = wrapFileApi(corePluginApi.$file, pluginApi)
+    }
+
+    if (corePluginApi.$eventbus) {
+      currentPlugin.initEventbus = () =>
+        wrapEventbusApi(corePluginApi.$eventbus, pluginApi)
+    }
+
+    const handleOperations = handlePluginOperations(
+      plugin.pluginKey,
+      pluginApi.$log,
+    )
+
+    if (pluginDefinition.i18n) {
+      updateTranslations(
+        plugin.pluginKey,
+        pluginDefinition.i18n,
+        pluginApi.$log,
+      )
+    }
+
+    currentPlugin.initCud = (
+      pluginObservableWrapper: any,
+      instanceId: string,
+      actionIdOverride = "",
+    ) => {
+      return handleOperations(
+        actionIdOverride,
+        pluginObservableWrapper,
+        instanceId,
+        pluginDefinition.data,
+      )
+    }
+
+    currentPlugin.initSocket = () => {
+      return wrapSocketApi(currentPlugin, corePluginApi.$socket)
+    }
+
+    // Run plugin install function if it exists
+    if (
+      pluginDefinition.install &&
+      typeof pluginDefinition.install === "function"
+    ) {
+      pluginApi.$log?.("called plugin install func")
+      const customEndpoints = await pluginDefinition.install(
+        installPluginData(corePluginApi.$store, pluginApi.$log),
+        corePluginApi,
+      )
+
+      if (
+        customEndpoints &&
+        typeof customEndpoints === "object" &&
+        Object.keys(customEndpoints)?.length
+      ) {
+        pluginApi.$log?.("added custom Endpoints", customEndpoints)
+        pluginApi = { ...pluginApi, ...customEndpoints }
+      }
+    }
+
+    pluginApi.$log?.("Registered plugin", registeredPlugins[plugin.pluginKey])
+    registeredPlugins[plugin.pluginKey].$api = pluginApi
+
+    return true
+  } catch (error) {
+    logger.pluginRegistrar(`Error loading plugin ${plugin.pluginKey}:`, error)
+    return false
+  }
+}
+
+export * from "./loader"
+export * from "./error-handling"

package/services/frontend/src/core/setup/plugin-system/registration/loader.ts

@@ -0,0 +1,86 @@
+import { mergeDeepRight } from "ramda"
+import logger from "@racletteCore/lib/logger"
+import type { PluginFrontendDefinition } from "../types"
+
+/**
+ * Load and merge plugin definition from frontend directory
+ */
+export const loadPluginDefinition = async (
+  frontendPath: string,
+): Promise<Partial<PluginFrontendDefinition>> => {
+  let indexModule: Partial<PluginFrontendDefinition> = {}
+  let generatedConfig: { data?: PluginFrontendDefinition["data"] } = {}
+
+  // Create static globs for all possible index and config files
+  const indexGlob = import.meta.glob(
+    [
+      "/src/plugins/**/frontend/index.ts",
+      "/src/corePlugins/**/frontend/index.ts",
+      "/src/workbenchPlugins/**/frontend/index.ts",
+    ],
+    { eager: false },
+  )
+
+  const configGlob = import.meta.glob(
+    [
+      "/src/plugins/**/frontend/generated-config.ts",
+      "/src/corePlugins/**/frontend/generated-config.ts",
+      "/src/workbenchPlugins/**/frontend/generated-config.ts",
+    ],
+    {
+      eager: false,
+    },
+  )
+
+  // Try to find and load index.ts
+  const indexPath = `${frontendPath}/index.ts`
+  const matchingIndexFile = Object.keys(indexGlob).find(
+    (path) => path === indexPath,
+  )
+
+  if (matchingIndexFile) {
+    try {
+      const importedModule = await indexGlob[matchingIndexFile]()
+      indexModule = (importedModule as any)?.default || {}
+      logger.pluginRegistrar("Loaded index.ts from", indexPath)
+    } catch (error) {
+      logger.pluginRegistrar(`Error loading index.ts from ${indexPath}:`, error)
+    }
+  } else {
+    logger.pluginRegistrar(`No index.ts found at`, indexPath)
+  }
+
+  // Try to find and load generated-config.ts
+  const configPath = `${frontendPath}/generated-config.ts`
+  const matchingConfigFile = Object.keys(configGlob).find(
+    (path) => path === configPath,
+  )
+
+  if (matchingConfigFile) {
+    try {
+      const importedGenerated = await configGlob[matchingConfigFile]()
+      generatedConfig = (importedGenerated as any)?.default || {}
+
+      logger.pluginRegistrar("Loaded generated-config.ts from", configPath)
+    } catch (error) {
+      logger.pluginRegistrar(
+        `Error loading generated-config.ts from ${configPath}:`,
+        error,
+      )
+    }
+  } else {
+    logger.pluginRegistrar(`No generated-config.ts found at `, configPath)
+  }
+
+  // Merge configurations (generated-config as base, index overrides)
+  const mergedDefinition = {
+    ...indexModule,
+    data: mergeDeepRight(generatedConfig.data ?? {}, indexModule.data ?? {}),
+  }
+
+  return mergedDefinition
+}
+
+export const defineRaclettePluginFrontend = (
+  pluginClientDefinition: Partial<PluginFrontendDefinition>,
+): Partial<PluginFrontendDefinition> => pluginClientDefinition

package/services/frontend/src/core/setup/plugin-system/state/index.ts

@@ -0,0 +1,43 @@
+import type { OrchestratorPlugin } from "../types"
+import type { RegisteredPlugin } from "@racletteCore"
+
+// Global state management
+export const registeredPlugins: { [key: string]: RegisteredPlugin } = {}
+
+export const pluginPathMapping: { [path: string]: string } = {}
+
+export const pluginDataTypes: { [key: string]: any } = {}
+
+export const orchestratorPlugins: OrchestratorPlugin[] = []
+
+export const pluginReadOperations: { [key: string]: any } = {}
+
+// State manipulation helpers
+export const addRegisteredPlugin = (
+  key: string,
+  plugin: RegisteredPlugin,
+): void => {
+  registeredPlugins[key] = plugin
+}
+
+export const getRegisteredPlugin = (
+  key: string,
+): RegisteredPlugin | undefined => {
+  return registeredPlugins[key]
+}
+
+export const addPluginPathMapping = (path: string, key: string): void => {
+  pluginPathMapping[path] = key
+}
+
+export const addPluginDataType = (key: string, dataType: any): void => {
+  pluginDataTypes[key] = dataType
+}
+
+export const addOrchestratorPlugin = (plugin: OrchestratorPlugin): void => {
+  orchestratorPlugins.push(plugin)
+}
+
+export const addPluginReadOperation = (key: string, operation: any): any => {
+  return (pluginReadOperations[key] = operation)
+}

package/services/frontend/src/core/setup/plugin-system/types/index.ts

@@ -0,0 +1,56 @@
+import type { Plugin } from "vue"
+
+import type { PluginApi } from "@racletteOrchestrator"
+import type { PluginMetadata } from "@core"
+
+// Plugin types
+export enum PluginType {
+  CORE = "core",
+  NPM = "npm",
+  APP = "app",
+}
+
+// Interface for discovered plugin info
+export interface DiscoveredPlugin {
+  configPath: string
+  pluginPath: string
+  frontendPath: string
+  type: PluginType
+  metadata: PluginMetadata
+  pluginKey: string
+}
+
+export type RouteConfig = {
+  method: string
+  storeActionType?: string
+  actionId?: string
+  target?: string | ((params: any) => string)
+  dataTypeName?: string
+}
+
+export type Operations = Record<string, RouteConfig>
+
+export interface PluginSocketApi {
+  registeredListeners: Array<{
+    channelName: string
+    handlerFn: Function
+  }>
+  on: (eventName: string, handlerFn: Function) => void
+  off: (eventIdentity: string, handlerFn: Function) => void
+  emit: (eventName: string, eventPayload: any) => void
+  once: (eventName: string, handlerFn: Function) => void
+}
+
+export interface TranslationUpdate {
+  [locale: string]: {
+    [key: string]: any
+  }
+}
+
+export interface OrchestratorPlugin {
+  dependency: Plugin
+  options: Record<string, string>
+}
+
+// Re-export types from dependencies
+export type { PluginApi, PluginMetadata }

package/services/frontend/src/core/setup/plugin-system/utils/operations.ts

@@ -0,0 +1,92 @@
+import { readOperationTypesList } from "@racletteCore/constants/ApiClient"
+import { CUD_HTTP_METHODS, CUD_OPERATION_TYPES } from "../constants"
+import type { CoreCudOperationType, CoreReadOperationType } from "@racletteCore"
+import type { RouteConfig, Operations } from "../types"
+import { replaceUrlParams } from "@racletteCore/lib/uriParser"
+
+// Helper functions for better readability
+export const isCudHttpMethod = (method: string): boolean =>
+  CUD_HTTP_METHODS.includes(method as any)
+
+export const isCudOperationType = (
+  storeActionType: string,
+): storeActionType is CoreCudOperationType =>
+  CUD_OPERATION_TYPES.has(storeActionType as CoreCudOperationType)
+
+export const isCudOperation = (routeConfig: RouteConfig): boolean => {
+  // If there's a storeActionType, check it first
+  if (routeConfig.storeActionType) {
+    // If it's explicitly a read operation type, it's not CUD
+    if (
+      readOperationTypesList.includes(
+        routeConfig.storeActionType as CoreReadOperationType,
+      )
+    ) {
+      return false
+    }
+    // If it's explicitly a CUD operation type, it is CUD
+    if (isCudOperationType(routeConfig.storeActionType)) {
+      return true
+    }
+    // If storeActionType is neither read nor CUD type, fall back to HTTP method
+  }
+
+  // Default to HTTP method-based classification
+  return isCudHttpMethod(routeConfig.method)
+}
+
+export const splitOperations = <T extends Operations>(
+  operations: T,
+): {
+  cudOperations: Partial<T>
+  readOperations: Partial<T>
+} => {
+  const entries = Object.entries(operations)
+
+  const cudEntries = entries.filter(([, routeConfig]) =>
+    isCudOperation(routeConfig),
+  )
+  const readEntries = entries.filter(
+    ([, routeConfig]) => !isCudOperation(routeConfig),
+  )
+
+  return {
+    cudOperations: Object.fromEntries(cudEntries) as Partial<T>,
+    readOperations: Object.fromEntries(readEntries) as Partial<T>,
+  }
+}
+
+export const createPluginActionId = (
+  dataType: string,
+  actionId: string,
+): string => `${dataType}-${actionId}`
+
+export const validatePluginMetadata = (metadata: any): boolean => {
+  return (
+    metadata &&
+    typeof metadata.name === "string" &&
+    typeof metadata.author === "string"
+  )
+}
+export const handleOperationTarget = (
+  target: String | Function,
+  params: Object,
+): String => {
+  let _target = target || ""
+  if (typeof _target === "function") _target = target(params)
+  if (_target && _target.includes(":"))
+    _target = replaceUrlParams(_target, params)
+  return _target
+}
+export const prefixOperationTarget = (
+  target: String,
+  prefix: String,
+): String => {
+  let validTarget = target || ""
+  if (target && target.indexOf("/") === 0) {
+    validTarget = `${prefix}${target}`
+  } else {
+    validTarget = `${prefix}/${target}`
+  }
+  return validTarget
+}

package/services/frontend/src/core/setup/sessionHandler.ts

@@ -0,0 +1,52 @@
+/**
+ * Session management such as
+ * - getUserToken
+ * - setUserToken
+ *
+ */
+import { setHttpToken } from "@racletteCore/lib/httpClient"
+import { getCookie } from "@racletteCore/lib/dataHelper"
+import log from "../lib/logger"
+// TODO use this file in the files we currently do authentication in instead of the inline code in ie main.ts
+const AUTH_TOKEN_KEY = "authToken"
+
+const getUserToken = () => {
+  const token = getCookie(AUTH_TOKEN_KEY)
+
+  return token
+}
+
+const setUserToken = (api, socket, token) => {
+  document.cookie = `${AUTH_TOKEN_KEY}=${token}; Secure; SameSite=Lax; max-age=86400; Path=/`
+  // set token in http client
+  setHttpToken(token)
+}
+
+const checkUserToken = async (api, socket, store) => {
+  const token = getUserToken()
+
+  if (!token) {
+    return false
+  }
+  // set token in client
+  setUserToken(api, socket, token)
+  // check if token is valid
+  try {
+    const user = await api.get("/core/user/check-token")
+
+    // early return if no result
+    if (!user || user.data === "") {
+      return false
+    }
+    // save received user object to store
+    store.dispatch({ type: "user/set", payload: user.data })
+
+    return user
+  } catch (e) {
+    log.api("sessionHandler/checkUserToken", e?.response?.data)
+
+    return false
+  }
+}
+
+export { getUserToken, setUserToken, checkUserToken, AUTH_TOKEN_KEY }

package/services/frontend/src/core/setup/socket.ts

@@ -0,0 +1,37 @@
+/**
+ * Create socket connection
+ */
+import io from "socket.io-client"
+import { getUserToken } from "./sessionHandler"
+import log from "@racletteCore/lib/logger"
+
+/**
+ * createSocket returns an instance of a custom SocketClient
+ * @param {string} host - our socket endpoint
+ * @param {string} appSessionId - The id for the current application - server session
+ * @param {object} opts - socket.io options
+ */
+
+const createSocket = (host, appSessionId, opts = {}) => {
+  log.socket("createSocket", { host, appSessionId, opts })
+  const token = getUserToken()
+  const defaults = {
+    cors: {
+      origin: /localhost/,
+    },
+    transports: ["polling", "websocket"],
+    withCredentials: true,
+    auth: {
+      token: token,
+    },
+    extraHeaders: {
+      "app-session-id": appSessionId,
+    },
+  }
+  const socket = io(host, { ...defaults, ...opts })
+
+  return socket
+}
+
+export default createSocket
+export { createSocket }

package/services/frontend/src/core/setup/socketClient.ts

@@ -0,0 +1,35 @@
+/**
+ * Send messages to the socket server
+ * Listens to the event bus and emits accordingly messages to the socket server.
+ */
+import log from "@racletteCore/lib/logger"
+import { getUserToken } from "./sessionHandler"
+import configService from "@racletteCore/lib/configService"
+const registerSocketClient = ($socket, $eventbus) => {
+  $eventbus.on("socket_joinRoom", (roomId?: string) => {
+    const { requireAuthentication } = configService.getConfig()?.global ?? {
+      requireAuthentication: true,
+    }
+
+    let token: string | null = null
+
+    if (requireAuthentication) {
+      token = getUserToken()
+
+      if (!token) {
+        return log.socket("emitJoin", "no token")
+      }
+    }
+
+    log.socket("emitJoin", { roomId, token })
+    $socket.emit("join", { roomId, token })
+  })
+
+  $eventbus.on("socket_leaveRoom", (roomId) => {
+    log.socket("emitLeave", { roomId })
+    $socket.emit("leave", roomId)
+  })
+}
+
+export default registerSocketClient
+export { registerSocketClient }