@raclettejs/core 0.1.0 → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.1] - 03.09.2025
+
+### Added
+
+- i18n will now fallback to other region locale if requested region locale is not provided. Will finally fall back to fallbackLocale
+
+### Removed
+
+- removed self dependency from backend on core and workbench
+
+### Fixed
+
+- added core. prefix to notifications.
+- Prevent template exception during notification from system user

package/README.md

@@ -1,7 +1,9 @@
-<!--![Latest release](https://gitlab.com/raclettejs/core/-/badges/release.svg)-->
+[![NPM Version](https://img.shields.io/npm/v/%40raclettejs%2Fcore)](https://www.npmjs.com/package/@raclettejs/core)
+[![NPM License](https://img.shields.io/npm/l/%40raclettejs%2Fcore)](LICENSE)
+
 
 > [!important] Beta Phase!
-> Raclett is still in the Beta phase. There might be breaking changes over the next couple of month so be aware of migration needs. Visit our [Milestone Overview](https://gitlab.com/groups/raclettejs/-/milestones) for more insights and estimates
+> raclette is still in the Beta phase. There might be breaking changes over the next couple of month so be aware of migration needs. Visit our [Milestone Overview](https://gitlab.com/groups/raclettejs/-/milestones) for more insights and estimates
 
 ## What is **raclette**?
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raclettejs/core",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "racletteJS core package",
   "repository": "https://gitlab.com/raclettejs/core",
   "author": "Pacifico Digital Explorations GmbH <info@raclettejs.com>",

package/services/backend/package.json

@@ -32,8 +32,6 @@
     "@fastify/swagger": "^9.5.1",
     "@fastify/swagger-ui": "^5.2.3",
     "@fastify/type-provider-typebox": "^5.1.0",
-    "@raclettejs/core": "^0.0.1",
-    "@raclettejs/workbench": "^0.0.1",
     "@sinclair/typebox": "^0.34.37",
     "@types/vary": "^1.1.3",
     "axios": "^1.10.0",
@@ -74,4 +72,4 @@
     "typescript": "^5.8.3",
     "typescript-eslint": "^8.36.0"
   }
-}
+}

package/services/frontend/src/orchestrator/components/chip/UserChip.vue

@@ -1,6 +1,6 @@
 <template>
   <v-chip
-    v-if="user._source"
+    v-if="user?._source"
     size="small"
     :color="user ? user._source.color || 'grey' : 'grey'"
   >

package/services/frontend/src/orchestrator/components/menu/UserNotifications.vue

@@ -23,7 +23,7 @@
         <v-tooltip activator="parent" location="bottom">
           {{
             $t(
-              "receivedNotifications$count",
+              "core.receivedNotifications$count",
               state.unreadCount,
               state.unreadCount,
             )
@@ -86,7 +86,9 @@
                         :user-id="entry.updatedBy"
                         compact
                       />
-                      <TimeAgo :timestamp="entry.time" />
+                      <TimeAgo
+                        :timestamp="new Date(entry.time).toISOString()"
+                      />
                     </v-col>
                   </v-row>
                 </v-list-item-subtitle>

package/services/frontend/src/orchestrator/setup/i18n.ts

@@ -7,9 +7,12 @@ import configService from "@racletteCore/lib/configService"
 import logger from "@racletteCore/lib/logger"
 import { mergeDeepRight } from "ramda"
 
+// Types
 type LocaleFileImports = Record<string, () => Promise<any>>
 type Messages = Record<string, any>
 type DateLocales = Record<string, any>
+type LocaleEnrichmentMap = Record<string, string[]>
+type SectionPriorities = Record<string, number>
 
 interface I18nInstance {
   i18nInstance: I18n
@@ -17,6 +20,13 @@ interface I18nInstance {
   dateLocale: DateLocales
 }
 
+interface LocaleSection {
+  section: string
+  content: any
+  priority: number
+}
+
+// File imports using Vite's glob
 const i18nFiles: LocaleFileImports = import.meta.glob(
   ["/src/orchestrator/i18n/**/*.json"],
   { eager: false },
@@ -32,144 +42,182 @@ const dateFnsLocaleFiles: LocaleFileImports = import.meta.glob(
   { eager: false },
 )
 
+// Global state
 let i18nInstance: I18n | null = null
 let instanceAdapter: { adapter: any } | null = null
 let dateLocale: DateLocales = {}
 let messages: Messages = {}
 
+// Utility functions
+const extractLocaleFromFilePath = (filePath: string): string => {
+  const fileName = filePath.split("/").pop()!
+  return fileName.replace(/\.(json|js)$/, "")
+}
+
+const getShortLocale = (longLocale: string): string => {
+  return longLocale.split("-")[0]
+}
+
 const getAvailableLocales = (files: LocaleFileImports): string[] => {
-  return Object.keys(files).map((filePath) => {
-    const fileName = filePath.split("/").pop()!
-    return fileName.replace(".json", "").replace(".js", "")
-  })
+  return Object.keys(files).map(extractLocaleFromFilePath)
 }
 
 const getAvailableDateFnsLocales = (files: LocaleFileImports): string[] => {
   return Object.keys(files)
-    .map((filePath) => {
-      const fileName = filePath.split("/").pop()!
-      return fileName.replace(".js", "")
-    })
-    .filter((locale) => !locale.includes("cdn") && locale !== "types") // Filter out non-locale files
+    .map(extractLocaleFromFilePath)
+    .filter((locale) => !locale.includes("cdn") && locale !== "types")
 }
 
-const createFormats = (locales: string[], defaultFormats: any) => {
-  return locales.reduce(
-    (formats, locale) => {
-      formats[locale] = defaultFormats.EU
-      return formats
-    },
-    {} as Record<string, any>,
-  )
+const createFormatsForLocales = (
+  locales: string[],
+  defaultFormats: any
+): Record<string, any> => {
+  return locales.reduce((formats, locale) => {
+    formats[locale] = defaultFormats.EU
+    return formats
+  }, {} as Record<string, any>)
 }
 
-const getShortLocale = (longLocale: string): string => {
-  return longLocale.split("-")[0]
+// Locale filtering functions
+const createLocaleFilter = (targetLocales: string[]) => {
+  return (files: LocaleFileImports): LocaleFileImports => {
+    const filtered: LocaleFileImports = {}
+    
+    Object.entries(files).forEach(([filePath, importFn]) => {
+      const fileLocale = extractLocaleFromFilePath(filePath)
+      if (targetLocales.includes(fileLocale)) {
+        filtered[filePath] = importFn
+      }
+    })
+    
+    return filtered
+  }
 }
 
-const filterFilesByLocales = (
-  files: LocaleFileImports,
-  locales: string[],
-): LocaleFileImports => {
-  const filtered: LocaleFileImports = {}
+const createDateFnsLocaleFilter = (requestedLocales: string[]) => {
+  return (files: LocaleFileImports): LocaleFileImports => {
+    const filtered: LocaleFileImports = {}
+    const availableDateFnsLocales = getAvailableDateFnsLocales(files)
+
+    requestedLocales.forEach((locale) => {
+      const targetLocale = findBestDateFnsLocale(locale, availableDateFnsLocales)
+      
+      if (targetLocale) {
+        const matchingFilePath = Object.keys(files).find((filePath) => {
+          return extractLocaleFromFilePath(filePath) === targetLocale
+        })
+
+        if (matchingFilePath) {
+          filtered[matchingFilePath] = files[matchingFilePath]
+        }
+      }
+    })
+    
+    return filtered
+  }
+}
 
-  Object.keys(files).forEach((filePath) => {
-    const fileName = filePath.split("/").pop()!
-    const fileLocale = fileName.replace(".json", "").replace(".js", "")
+const findBestDateFnsLocale = (
+  requestedLocale: string,
+  availableLocales: string[]
+): string | null => {
+  // Try exact match first
+  if (availableLocales.includes(requestedLocale)) {
+    return requestedLocale
+  }
+  
+  // Try short locale
+  const shortLocale = getShortLocale(requestedLocale)
+  if (availableLocales.includes(shortLocale)) {
+    return shortLocale
+  }
+  
+  // Fallback to "eu"
+  if (availableLocales.includes("eu")) {
+    return "eu"
+  }
+  
+  return null
+}
 
-    if (locales.includes(fileLocale)) {
-      filtered[filePath] = files[filePath]
-    }
-  })
+// Locale enrichment logic
+const buildFallbackChain = (
+  requestedLocale: string,
+  availableLocales: string[]
+): string[] => {
+  const fallbackChain: string[] = []
+  const requestedLang = getShortLocale(requestedLocale)
+
+  // 1. Exact match
+  if (availableLocales.includes(requestedLocale)) {
+    fallbackChain.push(requestedLocale)
+  }
 
-  return filtered
-}
+  // 2. Same language, different region
+  const sameLanguageDifferentRegion = availableLocales.filter(
+    (locale) =>
+      locale !== requestedLocale &&
+      getShortLocale(locale) === requestedLang &&
+      locale.includes("-")
+  )
+  fallbackChain.push(...sameLanguageDifferentRegion)
 
-const filterDateFnsFilesByLocales = (
-  files: LocaleFileImports,
-  locales: string[],
-): LocaleFileImports => {
-  const filtered: LocaleFileImports = {}
-  const availableDateFnsLocales = getAvailableDateFnsLocales(files)
+  // 3. Short locale
+  if (availableLocales.includes(requestedLang) && !fallbackChain.includes(requestedLang)) {
+    fallbackChain.push(requestedLang)
+  }
 
-  locales.forEach((locale) => {
-    let targetLocale = ""
+  return fallbackChain
+}
 
-    // Try exact match first (e.g., "de-DE" -> "de-DE")
-    if (availableDateFnsLocales.includes(locale)) {
-      targetLocale = locale
-    }
-    // Try short locale (e.g., "de-DE" -> "de")
-    else if (availableDateFnsLocales.includes(getShortLocale(locale))) {
-      targetLocale = getShortLocale(locale)
-    }
-    // Fallback to "eu"
-    else if (availableDateFnsLocales.includes("eu")) {
-      targetLocale = "eu"
+const createLocaleEnrichmentMap = (
+  requestedLocales: string[],
+  availableLocales: string[],
+  fallbackLocale: string
+): LocaleEnrichmentMap => {
+  const enrichmentMap: LocaleEnrichmentMap = {}
+
+  requestedLocales.forEach((requestedLocale) => {
+    let fallbackChain = buildFallbackChain(requestedLocale, availableLocales)
+    
+    // Add fallback locale if nothing else was found
+    if (fallbackChain.length === 0 && availableLocales.includes(fallbackLocale)) {
+      fallbackChain = [fallbackLocale]
     }
 
-    if (targetLocale.length) {
-      // Find the actual file path that matches this locale
-      const matchingFilePath = Object.keys(files).find((filePath) => {
-        const fileName = filePath.split("/").pop()!
-        return fileName.replace(".js", "") === targetLocale
-      })
-
-      if (matchingFilePath) {
-        filtered[matchingFilePath] = files[matchingFilePath]
-        console.log(
-          `Matched ${locale} -> ${targetLocale} (${matchingFilePath})`,
-        )
-      }
+    if (fallbackChain.length > 0) {
+      enrichmentMap[requestedLocale] = fallbackChain
+      logger.orchestrator(`Enrichment chain for ${requestedLocale}:`, fallbackChain)
     }
   })
 
-  console.log("Filtered date-fns files:", Object.keys(filtered))
-  return filtered
+  return enrichmentMap
 }
 
-const loadMessages = async (
-  locales: string[],
-  priorities: Record<string, number>,
-): Promise<Messages> => {
-  const filteredI18nFiles = filterFilesByLocales(i18nFiles, locales)
-  const shortLocales = locales.map(getShortLocale)
-  const filteredVuetifyFiles = filterFilesByLocales(
-    vuetifyLocaleFiles,
-    shortLocales,
-  )
-
-  const messages: Messages = {}
-
-  // Initialize message structure for each locale
-  locales.forEach((locale) => {
-    messages[locale] = {}
-  })
+// Message loading functions
+const extractSectionFromFilePath = (filePath: string): string => {
+  const pathParts = filePath.split("/")
+  const i18nIndex = pathParts.findIndex((part) => part === "i18n")
+  const folderPath = pathParts.slice(i18nIndex + 1, -1).join("/")
+  return folderPath || "."
+}
 
-  // First, collect all sections by locale
-  const sectionsByLocale: Record<
-    string,
-    Array<{ section: string; content: any; priority: number }>
-  > = {}
+const loadAndCategorizeI18nFiles = async (
+  files: LocaleFileImports,
+  priorities: SectionPriorities
+): Promise<Record<string, LocaleSection[]>> => {
+  const sectionsByLocale: Record<string, LocaleSection[]> = {}
 
-  for (const [filePath, importFn] of Object.entries(filteredI18nFiles)) {
+  for (const [filePath, importFn] of Object.entries(files)) {
     const module = await importFn()
     const content = module.default || module
-
-    const fileName = filePath.split("/").pop()!
-    const fileLocale = fileName.replace(".json", "")
-
-    // Determine the folder/section
-    const pathParts = filePath.split("/")
-    const i18nIndex = pathParts.findIndex((part) => part === "i18n")
-    const folderPath = pathParts.slice(i18nIndex + 1, -1).join("/")
-    const section = folderPath || "."
-
-    // Check if section has priority defined
+    const fileLocale = extractLocaleFromFilePath(filePath)
+    const section = extractSectionFromFilePath(filePath)
     const priority = priorities[section]
+
     if (priority === undefined) {
       logger.warning(
-        `Section "${section}" for locale "${fileLocale}" has no priority defined and will be skipped`,
+        `Section "${section}" for locale "${fileLocale}" has no priority defined and will be skipped`
       )
       continue
     }
@@ -178,35 +226,67 @@ const loadMessages = async (
       sectionsByLocale[fileLocale] = []
     }
 
-    sectionsByLocale[fileLocale].push({
-      section,
-      content,
-      priority,
-    })
+    sectionsByLocale[fileLocale].push({ section, content, priority })
   }
 
-  // Merge sections by priority for each locale
-  for (const [locale, sections] of Object.entries(sectionsByLocale)) {
-    // Sort by priority descending (highest number first = lowest priority)
+  return sectionsByLocale
+}
+
+const mergeSectionsByPriority = (
+  sectionsByLocale: Record<string, LocaleSection[]>
+): Record<string, any> => {
+  const mergedByLocale: Record<string, any> = {}
+
+  Object.entries(sectionsByLocale).forEach(([locale, sections]) => {
+    // Sort by priority descending (highest number = lowest priority)
     const sortedSections = sections.sort((a, b) => b.priority - a.priority)
 
     // Deep merge from lowest to highest priority
-    messages[locale] = sortedSections.reduce((merged, { content }) => {
+    mergedByLocale[locale] = sortedSections.reduce((merged, { content }) => {
       return mergeDeepRight(merged, content || {})
     }, {})
-  }
+  })
 
-  // Load Vuetify locales
-  for (const [filePath, importFn] of Object.entries(filteredVuetifyFiles)) {
+  return mergedByLocale
+}
+
+const enrichMessagesWithFallbacks = (
+  enrichmentMap: LocaleEnrichmentMap,
+  mergedByLocale: Record<string, any>
+): Messages => {
+  const enrichedMessages: Messages = {}
+
+  Object.entries(enrichmentMap).forEach(([requestedLocale, fallbackChain]) => {
+    let localeMessages = {}
+
+    // Merge in reverse order (lowest priority first)
+    const reversedChain = [...fallbackChain].reverse()
+    reversedChain.forEach((sourceLocale) => {
+      if (mergedByLocale[sourceLocale]) {
+        localeMessages = mergeDeepRight(localeMessages, mergedByLocale[sourceLocale])
+        logger.orchestrator(`Merged ${sourceLocale} into ${requestedLocale}`)
+      }
+    })
+
+    enrichedMessages[requestedLocale] = localeMessages
+  })
+
+  return enrichedMessages
+}
+
+const loadVuetifyLocales = async (
+  files: LocaleFileImports,
+  locales: string[],
+  messages: Messages
+): Promise<void> => {
+  for (const [filePath, importFn] of Object.entries(files)) {
     const module = await importFn()
     const vuetifyLocale = module.default || module
-
-    const fileName = filePath.split("/").pop()!
-    const shortLocale = fileName.replace(".js", "")
+    const shortLocale = extractLocaleFromFilePath(filePath)
 
     // Find corresponding long locale(s)
     const matchingLocales = locales.filter(
-      (locale) => getShortLocale(locale) === shortLocale,
+      (locale) => getShortLocale(locale) === shortLocale
     )
 
     matchingLocales.forEach((locale) => {
@@ -215,52 +295,55 @@ const loadMessages = async (
       }
     })
   }
+}
+
+const loadMessages = async (
+  locales: string[],
+  priorities: SectionPriorities
+): Promise<Messages> => {
+  const availableLocales = getAvailableLocales(i18nFiles)
+  const enrichmentMap = createLocaleEnrichmentMap(locales, availableLocales, "en-EU")
+
+  // Get all unique locales to load
+  const allLocalesToLoad = new Set<string>()
+  Object.values(enrichmentMap).forEach((fallbackChain) => {
+    fallbackChain.forEach((locale) => allLocalesToLoad.add(locale))
+  })
+
+  // Filter and load i18n files
+  const filteredI18nFiles = createLocaleFilter(Array.from(allLocalesToLoad))(i18nFiles)
+  const sectionsByLocale = await loadAndCategorizeI18nFiles(filteredI18nFiles, priorities)
+  const mergedByLocale = mergeSectionsByPriority(sectionsByLocale)
+  const messages = enrichMessagesWithFallbacks(enrichmentMap, mergedByLocale)
+
+  // Load Vuetify locales
+  const shortLocales = locales.map(getShortLocale)
+  const filteredVuetifyFiles = createLocaleFilter(shortLocales)(vuetifyLocaleFiles)
+  await loadVuetifyLocales(filteredVuetifyFiles, locales, messages)
 
   return messages
 }
 
+// Date-fns locale loading
 const loadDateFnsLocales = async (locales: string[]): Promise<DateLocales> => {
-  const filteredDateFnsFiles = filterDateFnsFilesByLocales(
-    dateFnsLocaleFiles,
-    locales,
-  )
+  const filteredDateFnsFiles = createDateFnsLocaleFilter(locales)(dateFnsLocaleFiles)
   const dateLocales: DateLocales = {}
+  const availableDateFnsLocales = getAvailableDateFnsLocales(dateFnsLocaleFiles)
 
-  // Load date-fns locales
   for (const [filePath, importFn] of Object.entries(filteredDateFnsFiles)) {
     const module = await importFn()
     const dateFnsLocale = module.default || module
-
-    // Extract the actual locale from the file path
-    const fileName = filePath.split("/").pop()!
-    const actualLocale = fileName.replace(".js", "")
+    const actualLocale = extractLocaleFromFilePath(filePath)
 
     // Map to all requesting locales that should use this date-fns locale
     locales.forEach((requestedLocale) => {
-      const availableDateFnsLocales =
-        getAvailableDateFnsLocales(dateFnsLocaleFiles)
-
-      let shouldUseThisLocale = false
-
-      // Check if this is the exact match
-      if (requestedLocale === actualLocale) {
-        shouldUseThisLocale = true
-      }
-      // Check if this is the short locale fallback
-      else if (
-        getShortLocale(requestedLocale) === actualLocale &&
-        !availableDateFnsLocales.includes(requestedLocale)
-      ) {
-        shouldUseThisLocale = true
-      }
-      // Check if this is the "eu" fallback
-      else if (
-        actualLocale === "eu" &&
-        !availableDateFnsLocales.includes(requestedLocale) &&
-        !availableDateFnsLocales.includes(getShortLocale(requestedLocale))
-      ) {
-        shouldUseThisLocale = true
-      }
+      const shouldUseThisLocale = 
+        requestedLocale === actualLocale ||
+        (getShortLocale(requestedLocale) === actualLocale && 
+         !availableDateFnsLocales.includes(requestedLocale)) ||
+        (actualLocale === "eu" && 
+         !availableDateFnsLocales.includes(requestedLocale) &&
+         !availableDateFnsLocales.includes(getShortLocale(requestedLocale)))
 
       if (shouldUseThisLocale) {
         dateLocales[requestedLocale] = dateFnsLocale
@@ -271,22 +354,33 @@ const loadDateFnsLocales = async (locales: string[]): Promise<DateLocales> => {
   return dateLocales
 }
 
+// Main initialization function
 const initI18n = async (): Promise<I18nInstance> => {
   if (!i18nInstance) {
     const fallbackLocale = "en-EU"
     const { locales, priorities } = configService.getI18nConfig()
     const availableLocales = getAvailableLocales(i18nFiles)
+    
     logger.orchestrator("Configured locales:", locales)
     logger.orchestrator("Available locale files:", availableLocales)
 
-    // Load messages and date locales
-    messages = await loadMessages(locales, priorities)
-    dateLocale = await loadDateFnsLocales(locales)
+    // Load messages and date locales concurrently
+    const [loadedMessages, loadedDateLocales] = await Promise.all([
+      loadMessages(locales, priorities),
+      loadDateFnsLocales(locales)
+    ])
+
+    messages = loadedMessages
+    dateLocale = loadedDateLocales
+    
     logger.orchestrator("Loaded messages:", Object.keys(messages))
     logger.orchestrator("Loaded date locales:", Object.keys(dateLocale))
-    const dateTimeFormats = createFormats(locales, defaultDateTimeFormats)
-    const numberFormatsForLocales = createFormats(locales, defaultNumberFormats)
 
+    // Create formats
+    const dateTimeFormats = createFormatsForLocales(locales, defaultDateTimeFormats)
+    const numberFormatsForLocales = createFormatsForLocales(locales, defaultNumberFormats)
+
+    // Initialize i18n instance
     i18nInstance = createI18n({
       legacy: false,
       globalInjection: true,
@@ -309,4 +403,4 @@ const initI18n = async (): Promise<I18nInstance> => {
 }
 
 export default initI18n
-export { i18nInstance, instanceAdapter, dateLocale, initI18n }
+export { i18nInstance, instanceAdapter, dateLocale, initI18n }