@raclettejs/core 0.0.1

package/services/frontend/src/core/setup/plugin-system/api/plugin-data.ts

@@ -0,0 +1,204 @@
+import { getInstanceActionId } from "@shared/helper/pluginHelper"
+import { i18nInstance } from "@racletteOrchestrator"
+import { v4 as uuidv4 } from "uuid"
+import type { Plugin } from "vue"
+import type {
+  CustomStoreActionsPayload,
+  PluginFrontendDefinition,
+  RacletteStore,
+} from "@racletteCore"
+import type { PluginApi } from "../types"
+import {
+  pluginDataTypes,
+  registeredPlugins,
+  addPluginDataType,
+  addPluginReadOperation,
+  addOrchestratorPlugin,
+} from "../state"
+import {
+  splitOperations,
+  createPluginActionId,
+  handleOperationTarget,
+  prefixOperationTarget,
+} from "../utils/operations"
+
+export const installPluginData = (
+  store: RacletteStore,
+  log: PluginApi["$log"],
+) => ({
+  addDataType: () => log("addDataType not implemented"),
+  addNodeDependency: (dependency: Plugin, options: Record<string, string>) => {
+    log("addNodeDependency will collect dependency", { dependency, options })
+    addOrchestratorPlugin({ dependency, options })
+  },
+  addStoreEffect: (effect: any) => {
+    log("addStoreEffect will add effect", effect)
+    store.effect(effect)
+  },
+  dispatchStore: (type: string, payload: any, options?: any) => {
+    let dispatchObject = { type, payload }
+    if (options) {
+      dispatchObject = { ...dispatchObject, ...options }
+    }
+    log("dispatchStore will dispatch", dispatchObject)
+    store.dispatch(dispatchObject)
+  },
+})
+
+export const handlePluginOperations =
+  (prefixedPluginName: string, log: PluginApi["$log"]) =>
+  (
+    actionIdOverride = "",
+    orchestratorResultWrapper: any,
+    instanceId: string,
+    pluginData: PluginFrontendDefinition["data"] = {},
+  ) => {
+    const plugin = registeredPlugins[prefixedPluginName]
+    const customStoreActions: Record<string, any> = {}
+    for (let [dataTypeName, value] of Object.entries(pluginData)) {
+      if (!dataTypeName) return log("no type for datatype given", value)
+
+      if (!pluginDataTypes[dataTypeName]) {
+        const { operations, ...pluginDataDefinition } = value
+        addPluginDataType(dataTypeName, pluginDataDefinition)
+      }
+
+      const operations = value.operations || {}
+      const { cudOperations, readOperations } = splitOperations(operations)
+
+      const storeActionTypeStoreActions = (customStoreActions[dataTypeName] =
+        {})
+      // Handle write operations
+      Object.entries(cudOperations).forEach(
+        ([customOperationName, customOperation]) => {
+          customOperation.dataTypeName = dataTypeName
+          let actionIdBase = customOperation.actionId || customOperationName
+          if (actionIdOverride.length) actionIdBase = actionIdOverride
+          const actionId = createPluginActionId(dataTypeName, actionIdBase)
+          storeActionTypeStoreActions[customOperationName] = ({
+            params = {},
+            options = {},
+          }: CustomStoreActionsPayload = {}) => {
+            const instanceActionId = getInstanceActionId(
+              prefixedPluginName,
+              instanceId,
+              actionId,
+              actionIdOverride,
+            )
+            if (!params._id && options.immediate === true) {
+              params._id = uuidv4()
+            }
+            return orchestratorResultWrapper.write(
+              instanceActionId,
+              customOperation,
+              {
+                params,
+                options,
+              },
+            )
+          }
+        },
+      )
+      // Handle read operations
+      Object.entries(readOperations).forEach(
+        ([customOperationName, customOperation]) => {
+          customOperation.dataTypeName = dataTypeName
+          let actionIdBase = customOperation.actionId || customOperationName
+          if (actionIdOverride.length) actionIdBase = actionIdOverride
+          const actionId = createPluginActionId(dataTypeName, actionIdBase)
+
+          storeActionTypeStoreActions[customOperationName] = ({
+            params = {},
+            options = {},
+          }: CustomStoreActionsPayload = {}) => {
+            const instanceActionId = getInstanceActionId(
+              prefixedPluginName,
+              instanceId,
+              actionId,
+              actionIdOverride,
+            )
+            const method = customOperation.method || "get"
+            let target = handleOperationTarget(customOperation.target, params)
+
+            const targetPrefix = `remote/${method}`
+
+            target = prefixOperationTarget(target, targetPrefix)
+
+            const operationConfig = {
+              ...customOperation,
+              targetPrefix,
+            }
+            // todo remove this singleton and pass the operationConfig to the query state as we need it in the fetch handler, also if it is called by the query effect
+            addPluginReadOperation(instanceActionId, operationConfig)
+
+            return orchestratorResultWrapper.read(instanceActionId, target, {
+              params,
+              options,
+            })
+          }
+        },
+      )
+    }
+    return customStoreActions
+  }
+
+export interface TranslationUpdate {
+  [locale: string]: {
+    [key: string]: any
+  }
+}
+
+const expandLocaleToAvailableVariants = (
+  locale: string,
+  availableLocales: string[],
+): string[] => {
+  // If exact match exists, return it
+  if (availableLocales.includes(locale)) {
+    return [locale]
+  }
+
+  // If it's a short locale (no dash), find all matching long locales
+  if (!locale.includes("-")) {
+    const matchingLocales = availableLocales.filter((availableLocale) =>
+      availableLocale.startsWith(locale + "-"),
+    )
+    return matchingLocales.length > 0 ? matchingLocales : []
+  }
+
+  // If it's a long locale that doesn't exist, return empty array
+  return []
+}
+
+export const updateTranslations = (
+  pluginKey: string,
+  newTranslations: TranslationUpdate,
+  log: PluginApi["$log"],
+) => {
+  Object.entries(newTranslations).forEach(([locale, messages]) => {
+    const availableLocales = i18nInstance.global.availableLocales
+    const targetLocales = expandLocaleToAvailableVariants(
+      locale,
+      availableLocales,
+    )
+
+    if (targetLocales.length > 0) {
+      targetLocales.forEach((targetLocale) => {
+        const existingMessages =
+          i18nInstance.global.getLocaleMessage(targetLocale)
+        const wrappedI18n: Record<string, any> = {}
+        wrappedI18n[pluginKey] = messages
+
+        const mergedMessages = { ...existingMessages, ...wrappedI18n }
+        log(
+          `updateTranslations added i18n for ${locale} -> ${targetLocale}`,
+          wrappedI18n,
+        )
+        i18nInstance.global.setLocaleMessage(targetLocale, mergedMessages)
+      })
+    } else {
+      log(
+        `updateTranslations: No matching locales found for ${locale}. Available: ${availableLocales.join(", ")}`,
+      )
+    }
+  })
+}

package/services/frontend/src/core/setup/plugin-system/api/wrappers.ts

@@ -0,0 +1,64 @@
+import EventEmitter from "@racletteCore/lib/eventEmitter"
+import type { Socket } from "socket.io-client"
+import type { LoggerInstance } from "@racletteCore/lib/logger"
+import type { PluginApi } from "@racletteOrchestrator"
+import type { PluginSocketApi } from "../types"
+import type { RegisteredPlugin } from "@racletteCore"
+
+export const wrapLogApi = (
+  $log: LoggerInstance,
+  pluginKey: string,
+  pluginApi: Partial<PluginApi>,
+): Partial<PluginApi> => {
+  if ($log && !pluginApi.$log) {
+    pluginApi.$log = $log.plugin(pluginKey)
+  }
+  return pluginApi
+}
+
+export const wrapFileApi = (
+  $file: any,
+  pluginApi: Partial<PluginApi>,
+): Partial<PluginApi> => {
+  if ($file && !pluginApi.$file) {
+    pluginApi.$file = $file
+  }
+  return pluginApi
+}
+
+export const wrapEventbusApi = (
+  $eventbus: any,
+  pluginApi: Partial<PluginApi>,
+): any => {
+  if ($eventbus && !pluginApi.$eventbus) {
+    const $pluginEventbus = new EventEmitter(false, false)
+    $pluginEventbus.global = $eventbus
+    return $pluginEventbus
+  }
+  return pluginApi
+}
+
+export const wrapSocketApi = (
+  plugin: RegisteredPlugin,
+  $socket: Socket,
+): PluginSocketApi => {
+  const socketApi: PluginSocketApi = {
+    registeredListeners: [],
+    on: (eventName: string, handlerFn: Function) => {
+      const channelName = `${plugin.pluginKey}--${eventName}`
+      socketApi.registeredListeners.push({ channelName, handlerFn })
+      return $socket.on(channelName, handlerFn)
+    },
+    off: (eventIdentity: string, handlerFn: Function) => {
+      return $socket.off(eventIdentity, handlerFn)
+    },
+    emit: (eventName: string, eventPayload: any) => {
+      return $socket.emit(eventName, eventPayload)
+    },
+    once: (eventName: string, handlerFn: Function) => {
+      return $socket.once(eventName, handlerFn)
+    },
+  }
+
+  return socketApi
+}

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

@@ -0,0 +1,25 @@
+import {
+  cudOperationTypesList,
+  readOperationTypesList,
+} from "@racletteCore/constants/ApiClient"
+
+// Constants for better maintainability
+export const CUD_HTTP_METHODS = ["post", "delete", "patch", "put"] as const
+
+export const CUD_OPERATION_TYPES = new Set(cudOperationTypesList)
+
+export const READ_OPERATION_TYPES = new Set(readOperationTypesList)
+// Error handling flags
+export const PLUGIN_ERROR_FLAGS = {
+  CORE: 1,
+  NPM: 2,
+  APP: 4,
+} as const
+
+export const DEFAULT_ERROR_FLAGS =
+  PLUGIN_ERROR_FLAGS.CORE | PLUGIN_ERROR_FLAGS.APP
+export const PLUGIN_TYPE_ORDER = {
+  core: 0,
+  npm: 1,
+  app: 2,
+} as const

package/services/frontend/src/core/setup/plugin-system/discovery/app-plugins.ts

@@ -0,0 +1,62 @@
+import { generatePluginKey } from "@shared/helper/pluginHelper"
+import logger from "@racletteCore/lib/logger"
+import { validatePluginMetadata } from "../utils/operations"
+import type { DiscoveredPlugin, PluginType } from "../types"
+
+/**
+ * Discover app/user plugins using static glob pattern with exclusions
+ */
+export const discoverAppPlugins = async (): Promise<DiscoveredPlugin[]> => {
+  const plugins: DiscoveredPlugin[] = []
+
+  try {
+    const configModules = import.meta.glob(
+      [
+        "/src/plugins/**/raclette.plugin.ts",
+        "/src/workbenchPlugins/**/raclette.plugin.ts",
+      ],
+      {
+        eager: false,
+      },
+    )
+
+    for (const configPath of Object.keys(configModules)) {
+      try {
+        const configModule = await configModules[configPath]()
+        const metadata = (configModule as any)?.default || configModule
+
+        if (!validatePluginMetadata(metadata)) {
+          logger.pluginRegistrar(`Invalid plugin metadata in ${configPath}`)
+          continue
+        }
+
+        const pluginPath = configPath.replace(/\/raclette\.plugin\.ts$/, "")
+        const frontendRelativePath =
+          metadata.frontendDir?.replace(/^\.\//, "") || "frontend"
+        const frontendPath = `${pluginPath}/${frontendRelativePath}`
+
+        const pluginKey = generatePluginKey(metadata.name, metadata.author)
+
+        plugins.push({
+          configPath,
+          pluginPath,
+          frontendPath,
+          type: "app" as PluginType,
+          metadata,
+          pluginKey,
+        })
+
+        logger.pluginRegistrar("Discovered app plugin", pluginKey)
+      } catch (error) {
+        logger.pluginRegistrar(
+          `Error processing app plugin ${configPath}:`,
+          error,
+        )
+      }
+    }
+  } catch (error) {
+    logger.pluginRegistrar(`Error discovering app plugins:`, error)
+  }
+
+  return plugins
+}

package/services/frontend/src/core/setup/plugin-system/discovery/core-plugins.ts

@@ -0,0 +1,59 @@
+import { generatePluginKey } from "@shared/helper/pluginHelper"
+import logger from "@racletteCore/lib/logger"
+import { validatePluginMetadata } from "../utils/operations"
+import type { DiscoveredPlugin, PluginType } from "../types"
+
+/**
+ * Discover core plugins using static glob pattern
+ */
+export const discoverCorePlugins = async (): Promise<DiscoveredPlugin[]> => {
+  const plugins: DiscoveredPlugin[] = []
+
+  try {
+    const configModules = import.meta.glob(
+      "/src/corePlugins/**/raclette.plugin.ts",
+      {
+        eager: false,
+      },
+    )
+
+    for (const configPath of Object.keys(configModules)) {
+      try {
+        const configModule = await configModules[configPath]()
+        const metadata = (configModule as any)?.default || configModule
+
+        if (!validatePluginMetadata(metadata)) {
+          logger.pluginRegistrar(`Invalid plugin metadata in ${configPath}`)
+          continue
+        }
+
+        const pluginPath = configPath.replace(/\/raclette\.plugin\.ts$/, "")
+        const frontendRelativePath =
+          metadata.frontendDir?.replace(/^\.\//, "") || "frontend"
+        const frontendPath = `${pluginPath}/${frontendRelativePath}`
+
+        const pluginKey = generatePluginKey(metadata.name, metadata.author)
+
+        plugins.push({
+          configPath,
+          pluginPath,
+          frontendPath,
+          type: "core" as PluginType,
+          metadata,
+          pluginKey,
+        })
+
+        logger.pluginRegistrar("Discovered core plugin", pluginKey)
+      } catch (error) {
+        logger.pluginRegistrar(
+          `Error processing core plugin ${configPath}:`,
+          error,
+        )
+      }
+    }
+  } catch (error) {
+    logger.pluginRegistrar(`Error discovering core plugins:`, error)
+  }
+
+  return plugins
+}

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

@@ -0,0 +1,43 @@
+import logger from "@racletteCore/lib/logger"
+import { PLUGIN_TYPE_ORDER } from "../constants"
+import type { DiscoveredPlugin } from "../types"
+import { discoverCorePlugins } from "./core-plugins"
+import { discoverAppPlugins } from "./app-plugins"
+import { discoverNpmPlugins } from "./npm-plugins"
+
+/**
+ * Discover all plugins using static import.meta.glob patterns
+ */
+export const discoverAllPlugins = async (): Promise<DiscoveredPlugin[]> => {
+  const discoveredPlugins: DiscoveredPlugin[] = []
+
+  try {
+    // Discover core plugins
+    const corePlugins = await discoverCorePlugins()
+    discoveredPlugins.push(...corePlugins)
+
+    // Discover app plugins
+    const appPlugins = await discoverAppPlugins()
+    discoveredPlugins.push(...appPlugins)
+
+    // Discover npm plugins
+    const npmPlugins = await discoverNpmPlugins()
+    discoveredPlugins.push(...npmPlugins)
+
+    // Sort plugins by type to maintain loading order: core -> npm -> app
+    const sortedPlugins = discoveredPlugins.sort((a, b) => {
+      return PLUGIN_TYPE_ORDER[a.type] - PLUGIN_TYPE_ORDER[b.type]
+    })
+
+    logger.pluginRegistrar(`Found ${sortedPlugins.length} plugins total`)
+
+    return sortedPlugins
+  } catch (error) {
+    logger.pluginRegistrar("Error during plugin discovery:", error)
+    throw error
+  }
+}
+
+export * from "./core-plugins"
+export * from "./app-plugins"
+export * from "./npm-plugins"

package/services/frontend/src/core/setup/plugin-system/discovery/npm-plugins.ts

@@ -0,0 +1,117 @@
+import { generatePluginKey } from "@shared/helper/pluginHelper"
+import logger from "@racletteCore/lib/logger"
+import configService from "@racletteCore/lib/configService"
+import { validatePluginMetadata } from "../utils/operations"
+import type { DiscoveredPlugin, PluginType } from "../types"
+
+/**
+ * Discover npm plugins from configuration
+ */
+export const discoverNpmPlugins = async (): Promise<DiscoveredPlugin[]> => {
+  const plugins: DiscoveredPlugin[] = []
+  const installedPlugins = configService.getPlugins()
+
+  if (!installedPlugins.length) {
+    return plugins
+  }
+
+  logger.pluginRegistrar(
+    `Discovering ${installedPlugins.length} npm plugin(s)...`,
+  )
+
+  // Create static glob patterns for all possible npm plugin locations
+  const nodeModulesGlob = import.meta.glob(
+    "/node_modules/*/raclette.plugin.ts",
+    { eager: false },
+  )
+
+  const devMountGlob = import.meta.glob(
+    "/mountedPlugins/*/raclette.plugin.ts",
+    {
+      eager: false,
+    },
+  )
+
+  // Combine all glob results
+  const allNpmConfigs = {
+    ...nodeModulesGlob,
+    ...devMountGlob,
+  }
+
+  for (const pluginPackage of installedPlugins) {
+    try {
+      const pluginNameWithoutScope = pluginPackage.replace(/^@[^/]+\//, "")
+
+      // Find matching config path
+      let foundConfigPath: string | null = null
+      let foundMetadata: any = null
+      let foundPluginPath: string | null = null
+
+      // Check all discovered configs for a match
+      for (const configPath of Object.keys(allNpmConfigs)) {
+        if (
+          configPath.includes(
+            `/node_modules/${pluginPackage}/raclette.plugin.ts`,
+          ) ||
+          (configPath.includes(`/node_modules/@`) &&
+            configPath.includes(
+              `/${pluginPackage.split("/")[1]}/raclette.plugin.ts`,
+            )) ||
+          configPath.includes(`/${pluginNameWithoutScope}/raclette.plugin.ts`)
+        ) {
+          try {
+            const configModule = await allNpmConfigs[configPath]()
+            const metadata = (configModule as any)?.default || configModule
+
+            if (validatePluginMetadata(metadata)) {
+              foundConfigPath = configPath
+              foundMetadata = metadata
+              foundPluginPath = configPath.replace(
+                /\/raclette\.plugin\.ts$/,
+                "",
+              )
+              logger.pluginRegistrar("Found npm plugin config at", configPath)
+              break
+            }
+          } catch (error) {
+            continue
+          }
+        }
+      }
+
+      if (!foundMetadata || !foundConfigPath || !foundPluginPath) {
+        logger.pluginRegistrar(
+          `Could not find valid npm plugin: ${pluginPackage}`,
+        )
+        continue
+      }
+
+      // Determine frontend path
+      const frontendRelativePath = foundMetadata.frontendDir || "src/frontend"
+      const frontendPath = `${foundPluginPath}/${frontendRelativePath}`
+
+      const pluginKey = generatePluginKey(
+        foundMetadata.name,
+        foundMetadata.author,
+      )
+
+      plugins.push({
+        configPath: foundConfigPath,
+        pluginPath: foundPluginPath,
+        frontendPath,
+        type: "npm" as PluginType,
+        metadata: foundMetadata,
+        pluginKey,
+      })
+
+      logger.pluginRegistrar("Discovered npm plugin:", pluginKey)
+    } catch (error) {
+      logger.pluginRegistrar(
+        `Error processing npm plugin ${pluginPackage}:`,
+        error,
+      )
+    }
+  }
+
+  return plugins
+}

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

@@ -0,0 +1,53 @@
+// Main plugin system exports
+export { registerPlugins } from "./registration"
+export { discoverAllPlugins } from "./discovery"
+export { defineRaclettePluginFrontend } from "./registration/loader"
+
+// State exports
+export {
+  registeredPlugins,
+  orchestratorPlugins,
+  pluginReadOperations,
+  pluginDataTypes,
+  pluginPathMapping,
+} from "./state"
+
+// Type exports
+export type {
+  PluginType,
+  DiscoveredPlugin,
+  RouteConfig,
+  Operations,
+  PluginSocketApi,
+  TranslationUpdate,
+  OrchestratorPlugin,
+  PluginApi,
+  PluginMetadata,
+} from "./types"
+
+// Constants exports
+export {
+  PLUGIN_ERROR_FLAGS,
+  DEFAULT_ERROR_FLAGS,
+  CUD_HTTP_METHODS,
+  CUD_OPERATION_TYPES,
+  READ_OPERATION_TYPES,
+  PLUGIN_TYPE_ORDER,
+} from "./constants"
+
+// Utility exports
+export * from "./utils/operations"
+
+// API exports
+export {
+  wrapLogApi,
+  wrapFileApi,
+  wrapEventbusApi,
+  wrapSocketApi,
+} from "./api/wrappers"
+
+export {
+  installPluginData,
+  handlePluginOperations,
+  updateTranslations,
+} from "./api/plugin-data"

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

@@ -0,0 +1,26 @@
+import logger from "@racletteCore/lib/logger"
+import { PLUGIN_ERROR_FLAGS } from "../constants"
+import type { PluginType } from "../types"
+
+/**
+ * Handle plugin errors based on error flags
+ */
+export const handlePluginError = (
+  error: string,
+  pluginType: PluginType,
+  errorFlags: number,
+): void => {
+  const shouldCrash =
+    (errorFlags &
+      PLUGIN_ERROR_FLAGS[
+        pluginType.toUpperCase() as keyof typeof PLUGIN_ERROR_FLAGS
+      ]) !==
+    0
+
+  if (shouldCrash) {
+    logger.pluginRegistrar(error)
+    throw new Error(error)
+  } else {
+    logger.pluginRegistrar(error)
+  }
+}