@raclettejs/core 0.0.1

package/services/backend/src/app.ts

@@ -0,0 +1,253 @@
+/**
+ * Primary entry file to the app
+ */
+import type { FastifyBaseLogger, FastifyInstance } from "fastify"
+import fastifyCors from "@fastify/cors"
+import fastifySchedule from "@fastify/schedule"
+import fastifySensible from "@fastify/sensible"
+import Fastify from "fastify"
+import healthcheck from "fastify-custom-healthcheck"
+import { dirname } from "path"
+import pino from "pino"
+import { Transform } from "stream"
+import { fileURLToPath } from "url"
+
+// Application components
+import registerCore from "./domains"
+import { registerPlugins } from "./core/pluginSystem/pluginLoader"
+import initializeSocketSystem from "./core/sockets/socketManager"
+import jwt from "./modules/authentication"
+import eventbus from "./core/eventBus"
+import headersPlugin from "./core/http/headers"
+import httpClient from "./core/http/httpService"
+import requestParamsPlugin from "./core/http/request-params.plugin"
+import mongodb from "./modules/database/providers/mongodb/mongoConnection"
+import valkeyPlugin from "./modules/cache/providers/valkey/valkeyConnection"
+import socket from "./core/sockets"
+import taskManager from "./core/backgroundTasks/taskManager"
+import configService from "./core/config/configService"
+import {
+  generateAllFrontendConfigs,
+  setFastifyInstanceForGeneration,
+} from "./core/pluginSystem/configGenerator"
+import generateRegisteredSchemas from "./core/validation/schemaGenerator"
+import { getAllowedOrigins } from "@/helpers"
+
+// Environment type guard
+const NODE_ENV = process.env.NODE_ENV as
+  | "development"
+  | "production"
+  | "test"
+  | "internal"
+
+/* Set global variables */
+global.__filename = fileURLToPath(import.meta.url)
+global.__dirname = dirname(__filename)
+
+/**
+ * Logger filter stream to exclude plugin logs when configured
+ */
+class PluginFilterStream extends Transform {
+  constructor() {
+    super({ objectMode: true })
+  }
+
+  _transform(chunk: any, _: any, callback: any) {
+    try {
+      const log = JSON.parse(chunk.toString())
+
+      if (!process.env.DISABLE_PLUGIN_LOGS || !log.plugin) {
+        this.push(JSON.stringify(log) + "\n")
+      }
+    } catch {
+      // Pass through if parsing fails
+      this.push(chunk)
+    }
+    callback()
+  }
+}
+
+/**
+ * Configure and create the logger
+ */
+const createLogger = (): FastifyBaseLogger => {
+  const isDevelopment = NODE_ENV === "development"
+  const usePrettyLogs = process.env.PRETTY_LOGS === "true"
+  const logLevel = process.env.LOG_LEVEL ?? "debug"
+  const disablePluginLogs = process.env.DISABLE_PLUGIN_LOGS === "true"
+
+  const loggerOptions = {
+    level: logLevel,
+    ...(isDevelopment || usePrettyLogs
+      ? {
+          transport: {
+            target: "pino-pretty",
+            options: {
+              colorize: true,
+              translateTime: "SYS:standard",
+              ignore: "pid,hostname",
+            },
+          },
+        }
+      : {
+          // Production logging configuration
+          serializers: {
+            req: pino.stdSerializers.req,
+            res: pino.stdSerializers.res,
+            err: pino.stdSerializers.err,
+          },
+        }),
+  }
+
+  const logger = disablePluginLogs
+    ? pino(loggerOptions, new PluginFilterStream())
+    : pino(loggerOptions)
+
+  // Ensure logger is working
+  logger.info("Logger initialized successfully")
+
+  return logger
+}
+
+/**
+ * Main application factory function
+ */
+export default async (): Promise<FastifyInstance> => {
+  const loggerInstance = createLogger()
+
+  const fastify = Fastify({
+    loggerInstance,
+    disableRequestLogging: true,
+    trustProxy: true,
+  })
+
+  // Validate required environment variables
+  if (!process.env.SERVER_TOKEN_SECRET) {
+    fastify.log.fatal("Missing config SERVER_TOKEN_SECRET")
+    throw new Error("Canceling...")
+  }
+
+  await configService.init()
+
+  // setup route tracker for plugin code generation
+  setFastifyInstanceForGeneration(fastify)
+
+  // Register core plugins
+  fastify.register(eventbus)
+  await fastify.register(mongodb, { uri: process.env.MONGO_HOST ?? "" })
+  fastify.register(headersPlugin)
+  fastify.register(jwt, { secret: process.env.SERVER_TOKEN_SECRET })
+  fastify.register(valkeyPlugin, {
+    url: process.env.CACHE_URL,
+    options: {
+      maxRetriesPerRequest: 3,
+      enableReadyCheck: true,
+    },
+  })
+  fastify.register(socket)
+  fastify.register(requestParamsPlugin)
+  fastify.register(taskManager)
+
+  // Register utility plugins
+  fastify.register(fastifySensible)
+  fastify.register(fastifySchedule)
+  await fastify.register(httpClient, {})
+
+  // Configure CORS
+  // Enhanced CORS configuration for streaming support
+  fastify.register(fastifyCors, {
+    methods: "GET,PUT,HEAD,POST,PATCH,DELETE,OPTIONS",
+    strictPreflight: false,
+    origin: (origin, callback) => {
+      const allowedOrigins = getAllowedOrigins()
+
+      // Allow server-to-server calls (no origin)
+      if (!origin) {
+        callback(null, true)
+        return
+      }
+
+      // Check against allowed origins
+      const isAllowed = allowedOrigins.some((allowedOrigin) => {
+        if (typeof allowedOrigin === "string") {
+          return allowedOrigin === origin
+        } else if (allowedOrigin instanceof RegExp) {
+          return allowedOrigin.test(origin)
+        }
+        return false
+      })
+
+      if (isAllowed) {
+        callback(null, true)
+      } else {
+        fastify.log.warn(`CORS blocked origin: ${origin}.`)
+        fastify.log.debug(
+          `Allowed CORS origins are: ${allowedOrigins.join(" | ")}`,
+        )
+        callback(new Error("Not allowed by CORS"), false)
+      }
+    },
+    credentials: true,
+    allowedHeaders: [
+      "Accept",
+      "Accept-Version",
+      "Access-Control-Allow-Headers",
+      "Access-Control-Request-Method",
+      "Authorization",
+      "Content-Range",
+      "Content-Type",
+      "Origin",
+      "current-project",
+      "app-session-id",
+      "app-request-code",
+      "app-broadcast-channels",
+      "http-client-used",
+      "Cache-Control", // For streaming
+      "Connection", // For streaming
+    ],
+    exposedHeaders: [
+      "Content-Type",
+      "Cache-Control",
+      "Connection",
+      "Access-Control-Allow-Origin",
+      "Access-Control-Allow-Headers",
+    ],
+    maxAge: 86400, // 24 hours for preflight cache
+  })
+
+  // Add health check
+  fastify.register(healthcheck, {
+    info: {
+      env: NODE_ENV,
+    },
+    schema: { tags: ["core/system"] },
+  })
+
+  // Register application components
+  await fastify.register(registerCore, { prefix: "/core" })
+
+  // Register plugins
+  try {
+    await registerPlugins(fastify)
+    fastify.log.info("Plugins registered successfully")
+  } catch (error: any) {
+    fastify.log.error("Plugin registration failed:" + error.message)
+  }
+
+  // Log registered routes in debug mode
+  fastify.log.debug(fastify.printRoutes())
+
+  // Generate schemas and types
+  await generateRegisteredSchemas(fastify)
+
+  await generateAllFrontendConfigs()
+
+  // Initialize socket system
+  if (process.env.RACLETTE_BUILD_MODE !== "generate") {
+    initializeSocketSystem(fastify)
+    await fastify.ready()
+    fastify.eventbus.emit("appReady")
+  }
+
+  return fastify
+}

package/services/backend/src/core/backgroundTasks/taskManager.ts

@@ -0,0 +1,174 @@
+import type {
+  IntervalTaskOptions,
+  TaskOptions,
+} from "@c/backgroundTasks/taskManagerTypes"
+import type { FastifyInstance } from "fastify"
+import fastifyPlugin from "fastify-plugin"
+import { SimpleIntervalJob, AsyncTask, ToadScheduler } from "toad-scheduler"
+
+// Store metadata for jobs
+const taskMetadata = new Map<string, { keepRunning: boolean }>()
+
+let activeConnections = 0
+let isAppReady = false
+let tasksToStartOnReady: Array<() => void> = []
+
+const pauseNonEssentialTasks = (fastify: FastifyInstance) => {
+  const jobs = fastify.scheduler.getAllJobs()
+  jobs.forEach((job) => {
+    const metadata = taskMetadata.get(job.id || "")
+    if (metadata && !metadata.keepRunning) {
+      fastify.log.info(`Pausing non-essential task: ${job.id}`)
+      job.stop()
+    }
+  })
+}
+
+const resumeNonEssentialTasks = (fastify: FastifyInstance) => {
+  const jobs = fastify.scheduler.getAllJobs()
+  jobs.forEach((job) => {
+    const metadata = taskMetadata.get(job.id || "")
+    if (metadata && !metadata.keepRunning) {
+      fastify.log.info(`Resuming non-essential task: ${job.id}`)
+      job.start()
+    }
+  })
+}
+
+const stopAllTasks = (fastify: FastifyInstance) => {
+  const jobs = fastify.scheduler.getAllJobs()
+  fastify.log.info(`Stopping ${jobs.length} tasks...`)
+
+  jobs.forEach((job) => {
+    try {
+      job.stop()
+      fastify.log.debug(`Stopped task: ${job.id}`)
+    } catch (error) {
+      fastify.log.error(`Error stopping task ${job.id}:`, error)
+    }
+  })
+
+  // Clear all jobs from scheduler
+  try {
+    fastify.scheduler.stop()
+    fastify.log.info("Task scheduler stopped")
+  } catch (error) {
+    fastify.log.error("Error stopping scheduler:", error)
+  }
+
+  // Clear metadata
+  taskMetadata.clear()
+  tasksToStartOnReady = []
+}
+
+const setupTaskManager = (fastify: FastifyInstance) => {
+  fastify.wss.on("connection", (socket) => {
+    activeConnections++
+    if (activeConnections === 1) {
+      resumeNonEssentialTasks(fastify)
+    }
+
+    socket.on("disconnect", () => {
+      activeConnections--
+      if (activeConnections === 0) {
+        pauseNonEssentialTasks(fastify)
+      }
+    })
+  })
+
+  return {
+    createIntervalTask: (
+      name: string,
+      handler: () => Promise<void>,
+      options: IntervalTaskOptions,
+    ) => {
+      const createTask = () => {
+        const task = new AsyncTask(name, handler, (error: Error) => {
+          if (options.errorHandler) {
+            options.errorHandler(error)
+          }
+          fastify.log.error(`Task ${name} failed:`, error)
+        })
+
+        const job = new SimpleIntervalJob(
+          {
+            seconds: options.seconds,
+            runImmediately: options.runImmediately ?? false,
+          },
+          task,
+          { id: name },
+        )
+
+        taskMetadata.set(name, {
+          keepRunning: options.keepRunning ?? false,
+        })
+
+        fastify.scheduler.addSimpleIntervalJob(job)
+        fastify.log.info(`Registered interval task: ${name}`)
+      }
+
+      // If app is ready, create task immediately
+      // Otherwise, queue it for when the app becomes ready
+      if (isAppReady) {
+        createTask()
+      } else {
+        tasksToStartOnReady.push(createTask)
+        fastify.log.info(`Queued task for app ready: ${name}`)
+      }
+    },
+
+    cancelTask: (name: string) => {
+      const removed = fastify.scheduler.removeById(name)
+
+      if (removed) {
+        taskMetadata.delete(name)
+        fastify.log.info(`Cancelled task: ${name}`)
+      } else {
+        fastify.log.warn(`Task not found: ${name}`)
+      }
+    },
+
+    markAppReady: () => {
+      if (isAppReady) return
+
+      isAppReady = true
+      fastify.log.info(
+        `App ready, starting ${tasksToStartOnReady.length} queued tasks`,
+      )
+
+      // Start all queued tasks
+      tasksToStartOnReady.forEach((createTask) => {
+        try {
+          createTask()
+        } catch (error) {
+          fastify.log.error("Error starting queued task:", error)
+        }
+      })
+
+      tasksToStartOnReady = []
+    },
+
+    stopAllTasks: () => stopAllTasks(fastify),
+
+    getTaskCount: () => fastify.scheduler.getAllJobs().length,
+  }
+}
+
+export default fastifyPlugin(
+  async (fastify: FastifyInstance) => {
+    const taskManager = setupTaskManager(fastify)
+
+    fastify.decorate("taskManager", taskManager)
+
+    // Add cleanup hook for server shutdown
+    fastify.addHook("onClose", async () => {
+      fastify.log.info("App is closing, stopping all tasks...")
+      stopAllTasks(fastify)
+    })
+  },
+  {
+    name: "taskManager",
+  },
+)
+
+export { setupTaskManager, type TaskOptions, type IntervalTaskOptions }

package/services/backend/src/core/backgroundTasks/taskManagerTypes.ts

@@ -0,0 +1,34 @@
+// taskManagerTypes.ts
+
+export interface TaskOptions {
+  // Base options for all tasks
+  errorHandler?: (error: Error) => void
+}
+
+export interface IntervalTaskOptions extends TaskOptions {
+  // Interval in seconds
+  seconds: number
+
+  // Whether to run the task immediately when created
+  runImmediately?: boolean
+
+  // Whether this task should keep running even when no WebSocket connections
+  keepRunning?: boolean
+}
+
+// Extend FastifyInstance to include our task manager
+declare module "fastify" {
+  export interface FastifyInstance {
+    taskManager: {
+      createIntervalTask: (
+        name: string,
+        handler: () => Promise<void>,
+        options: IntervalTaskOptions,
+      ) => void
+      cancelTask: (name: string) => void
+      markAppReady: () => void
+      stopAllTasks: () => void
+      getTaskCount: () => number
+    }
+  }
+}

package/services/backend/src/core/backgroundTasks/toadSchedulerTypes.ts

@@ -0,0 +1,8 @@
+import type { JobOptions } from "toad-scheduler/dist/lib/engines/simple-interval/SimpleIntervalJob"
+
+export interface ExtendedJobOptions extends JobOptions {
+  metadata?: {
+    pluginKey: string
+    keepRunning: boolean
+  }
+}

package/services/backend/src/core/config/configService.ts

@@ -0,0 +1,154 @@
+import type { SocketConfig, CacheConfig } from "@raclettejs/core"
+
+type RacletteBackendConfig = {
+  // not sure what we do here as this gets generated during runtime
+  // mäh
+  sockets?: {
+    autoSend?: any
+  }
+  cache?: {
+    persistence?: string
+  }
+  onlyAllowLoginWithAdminTag?: true
+  plugins?: string[]
+  global?: {
+    requireAuthentication?: boolean
+  }
+  additionalPluginPaths?: string[]
+}
+
+// Cache for configuration
+let cachedConfig: RacletteBackendConfig | null = null
+
+type socketDefaultAutoSend =
+  | "compositions"
+  | "interactionLinks"
+  | "projectConfig"
+
+export class ConfigService {
+  private config: RacletteBackendConfig | null = null
+
+  constructor() {
+    this.config = {}
+  }
+
+  async init() {
+    await this.refreshConfig()
+
+    return this
+  }
+
+  // Refresh the config (useful for hot reloading)
+  public async refreshConfig(): Promise<void> {
+    try {
+      // Dynamic import for ESM - this allows for hot reloading
+      const configModule = await import("../../../raclette.config.js")
+      // const configModule = await import(
+      //   process.env.NODE_ENV === "production"
+      //     ? "../../../raclette.config.js"
+      //     : "../../../raclette.config.ts=" + Date.now()
+      // )
+
+      this.config = configModule.racletteConfig
+
+      cachedConfig = this.config
+    } catch (error) {
+      console.warn(
+        `Error loading config: ${error instanceof Error ? error.message : String(error)}`,
+      )
+      // Keep using cached config if it exists
+      this.config = cachedConfig
+    }
+  }
+
+  // Get the entire config
+  public getConfig(): RacletteBackendConfig | null {
+    if (!this.config) {
+      if (!cachedConfig) {
+        console.error("Failed to load Raclette configuration")
+      }
+      this.config = cachedConfig
+    }
+
+    return this.config
+  }
+  // Get cache configuration with defaults
+  public getCacheConfig(): CacheConfig | {} {
+    const config = this.getConfig()
+
+    return config?.cache ?? {}
+  }
+  // Get cache persistence configuration
+  public getCachePersistenceConfig(): CacheConfig["persistence"] | string {
+    const cacheConfig = this.getCacheConfig()
+
+    return cacheConfig?.persistence ?? "none"
+  }
+  // Get cache rdb configuration
+  public getCacheRDBConfig(): CacheConfig["RDB_OPTIONS"] {
+    const cacheConfig = this.getCacheConfig()
+
+    return cacheConfig?.RDB_OPTIONS ?? "3600 1 300 100 60 10000"
+  }
+  // Get socket configuration with defaults
+  public getSocketConfig(): SocketConfig {
+    const config = this.getConfig()
+
+    return config?.sockets ?? {}
+  }
+
+  // Get socket auto-send configuration
+  public getSocketAutoSendConfig(): SocketConfig["autoSend"] | {} {
+    const socketConfig = this.getSocketConfig()
+
+    return socketConfig?.autoSend ?? {}
+  }
+
+  // Get socket security configuration
+  public getSocketSecurityConfig(): SocketConfig["security"] {
+    const socketConfig = this.getSocketConfig()
+
+    return socketConfig.security || {}
+  }
+
+  // Get socket options configuration
+  public getSocketOptionsConfig(): SocketConfig["options"] {
+    const socketConfig = this.getSocketConfig()
+
+    return socketConfig.options || {}
+  }
+
+  // Helper to check if a specific auto-send feature is enabled
+  // Default to true unless explicitly set to false
+  public isAutoSendEnabled(feature: socketDefaultAutoSend): boolean {
+    const autoSend = this.getSocketAutoSendConfig()
+
+    return autoSend[feature] !== false
+  }
+  // Helper to check if auth is required
+  // Default to true unless explicitly set to false
+  public isAuthRequired(): boolean {
+    return this.config?.global?.requireAuthentication ?? true
+  }
+  public isAdminTagRequired(): boolean {
+    return this.config?.onlyAllowLoginWithAdminTag ?? false
+  }
+  public getCustomSocketData(): Record<string, any> | undefined {
+    const socketConfig = this.getSocketConfig()
+
+    return socketConfig?.autoSend?.customData
+  }
+
+  public getPlugins(): string[] {
+    return this.config?.plugins || []
+  }
+
+  public getAdditonalPluginPaths(): string[] {
+    return this.config?.additionalPluginPaths || []
+  }
+}
+
+// Create singleton instance
+const configService = new ConfigService()
+
+export default configService

package/services/backend/src/core/config/configTypes.ts

@@ -0,0 +1,52 @@
+// Interface for module configuration
+export interface ModuleConfig {
+  name: string
+  enabled: boolean
+  options?: Record<string, any>
+}
+
+// Interface for app hooks
+export interface AppHooks {
+  beforeStart?: () => Promise<void> | void
+  afterStart?: () => Promise<void> | void
+  beforeMount?: () => Promise<void> | void
+  afterMount?: () => Promise<void> | void
+}
+
+// Main app configuration interface
+export interface AppConfig {
+  // Basic app settings
+  title: string
+  baseColor: string
+  languages: string[]
+
+  // Advanced configuration
+  modules?: ModuleConfig[]
+  hooks?: AppHooks
+
+  // Environment-specific settings
+  dev?: {
+    port?: number
+    host?: string
+    debug?: boolean
+  }
+
+  // Build configuration
+  build?: {
+    outDir?: string
+    minify?: boolean
+    sourcemap?: boolean
+  }
+
+  // Custom runtime configuration (accessible in app)
+  runtimeConfig?: {
+    public?: Record<string, any>
+    private?: Record<string, any>
+  }
+}
+
+export const defaultConfig: Partial<AppConfig> = {
+  title: "App",
+  baseColor: "#000000",
+  languages: ["en"],
+}