@raclettejs/core 0.0.1

package/services/backend/src/modules/cache/cacheTypes.ts

@@ -0,0 +1,122 @@
+export type CacheOptions = {
+  prefix?: string
+  defaultTtl?: number
+}
+
+export type CacheResult<T> = {
+  changed: boolean
+  data: T
+}
+
+export type CacheKeyMetadata = {
+  key: string
+  ttl: number
+  exists: boolean
+}
+
+export type CacheValueWithMetadata<T> = {
+  value: T | null
+  ttl: number
+  exists: boolean
+}
+
+export type CacheService = {
+  /**
+   * Caches data and returns whether it has changed
+   * @param key The cache key
+   * @param data The data to cache
+   * @param options Additional options
+   * @returns An object containing whether the data has changed and the cached data
+   */
+  cache<T>(
+    key: string,
+    data: T,
+    options?: {
+      ttl?: number
+      serialize?: (data: T) => string
+      deserialize?: (data: string) => T
+    },
+  ): Promise<CacheResult<T>>
+
+  /**
+   * Retrieve data from cache
+   * @param key The cache key
+   * @param deserialize Function to deserialize the data (defaults to JSON.parse)
+   * @returns The cached data or null if not found
+   */
+  get<T>(key: string, deserialize?: (data: string) => T): Promise<T | null>
+
+  /**
+   * Replaces the entry with the given new data
+   * @param key The cache key
+   * @param data New data that will replace the old one
+   * @param options Additional options
+   */
+  forceUpdate<T>(key: string, data: T, options?: { ttl?: number }): Promise<T>
+
+  /**
+   * Remove data from cache
+   * @param key The cache key
+   */
+  invalidate(key: string): Promise<void>
+
+  /**
+   * Remove all cache entries matching a pattern
+   * @param pattern The key pattern to match (e.g., "user:*")
+   * @returns The number of keys that were deleted
+   */
+  invalidatePattern(pattern: string): Promise<number>
+
+  /**
+   * Get all keys matching a pattern (within this service's namespace)
+   * @param pattern The key pattern to match (e.g., "user:*")
+   * @returns Array of matching keys (without the service prefix)
+   */
+  getKeysByPattern(pattern: string): Promise<string[]>
+
+  /**
+   * Get the TTL (time to live) for a specific key
+   * @param key The cache key
+   * @returns TTL in seconds (-1 if no expiry, -2 if key doesn't exist)
+   */
+  getTtl(key: string): Promise<number>
+
+  /**
+   * Get multiple keys with their metadata
+   * @param pattern The key pattern to match
+   * @returns Array of objects containing key, ttl, and exists status
+   */
+  getKeysWithMetadata(pattern: string): Promise<CacheKeyMetadata[]>
+
+  /**
+   * Remove multiple specific keys atomically
+   * @param keys Array of cache keys to remove
+   * @returns The number of keys that were deleted
+   */
+  invalidateMultiple(keys: string[]): Promise<number>
+
+  /**
+   * Check if a key exists in the cache
+   * @param key The cache key
+   * @returns True if the key exists, false otherwise
+   */
+  exists(key: string): Promise<boolean>
+
+  /**
+   * Get cached value along with its metadata
+   * @param key The cache key
+   * @param deserialize Function to deserialize the data (defaults to JSON.parse)
+   * @returns Object containing value, TTL, and existence status
+   */
+  getWithMetadata<T>(
+    key: string,
+    deserialize?: (data: string) => T,
+  ): Promise<CacheValueWithMetadata<T>>
+
+  /**
+   * Create a namespaced cache service
+   * @param namespace The namespace for all cache keys
+   * @param options Additional options
+   */
+  namespace(namespace: string, options?: CacheOptions): CacheService
+}

package/services/backend/src/modules/cache/providers/redis/redisConfig.ts

@@ -0,0 +1,17 @@
+export const REDIS_CONFIG = {
+  LOGIN_ATTEMPTS: {
+    MAX_ATTEMPTS: process.env.LOGIN_MAX_ATTEMPTS
+      ? parseInt(process.env.LOGIN_MAX_ATTEMPTS)
+      : 5,
+    LOCKOUT_DURATION: process.env.LOGIN_LOCKOUT_DURATION
+      ? parseInt(process.env.LOGIN_LOCKOUT_DURATION)
+      : 15 * 60,
+    ATTEMPT_WINDOW: process.env.LOGIN_ATTEMPT_WINDOW
+      ? parseInt(process.env.LOGIN_ATTEMPT_WINDOW)
+      : 30 * 60,
+  },
+  KEY_PREFIXES: {
+    LOGIN_ATTEMPTS: "login_attempts:",
+    LOGIN_LOCK: "login_lock:",
+  },
+} as const

package/services/backend/src/modules/cache/providers/redis/redisConnection.ts

@@ -0,0 +1,59 @@
+import type { FastifyInstance } from "fastify"
+import type { RedisKey } from "ioredis"
+import type { RedisPluginOptions, RedisService } from "./redisTypes"
+import fastifyPlugin from "fastify-plugin"
+import { Redis } from "ioredis"
+
+export default fastifyPlugin(
+  (fastify: FastifyInstance, options: RedisPluginOptions, done: any) => {
+    const url = options.url || "redis://localhost:6379"
+
+    fastify.log.info(`[REDIS] Connecting to ${url}`)
+
+    const client = new Redis(url, {
+      retryStrategy: (times) => {
+        const delay = Math.min(times * 50, 2000)
+
+        return delay
+      },
+      ...options.options,
+    })
+
+    // Handle connection events
+    client.on("error", (error) => {
+      fastify.log.error("[REDIS] Error:", error)
+    })
+    client.on("connect", () => fastify.log.info("[REDIS] Connected"))
+    client.on("reconnecting", () => fastify.log.info("[REDIS] Reconnecting..."))
+
+    const redisService: RedisService = {
+      get: async (key: string) => client.get(key),
+      set: async (key: string, value: string, expireSeconds?: number) => {
+        if (expireSeconds) {
+          return client.setex(key, expireSeconds, value)
+        }
+
+        return client.set(key, value)
+      },
+      del: async (...args: [...keys: RedisKey[]]) => client.del(args),
+      exists: async (key: string) => client.exists(key),
+      incr: async (key: string) => client.incr(key),
+      expire: async (key: string, seconds: number) =>
+        client.expire(key, seconds),
+      multi: () => client.multi() as any,
+      setex: async (key: string, seconds: number, value: string) =>
+        client.setex(key, seconds, value),
+      mget: async (...keys: string[]) => client.mget(keys),
+      keys: async (pattern: string) => client.keys(pattern),
+      ttl: async (key: string) => client.ttl(key),
+    }
+
+    fastify.decorate("redis", redisService)
+
+    fastify.addHook("onClose", async () => {
+      await client.quit()
+    })
+
+    done()
+  },
+)

package/services/backend/src/modules/cache/providers/redis/redisTypes.ts

@@ -0,0 +1,20 @@
+import type { Redis, RedisKey, RedisOptions } from "ioredis"
+
+export type RedisPluginOptions = {
+  url?: string
+  options?: RedisOptions
+}
+
+export type RedisService = {
+  get(key: string): Promise<string | null>
+  set(key: string, value: string, expireSeconds?: number): Promise<"OK">
+  del(...keys: [...keys: RedisKey[]]): Promise<number>
+  exists(key: string): Promise<number>
+  incr(key: string): Promise<number>
+  expire(key: string, seconds: number): Promise<number>
+  multi(): Redis
+  setex(key: string, seconds: number, value: string): Promise<"OK">
+  mget(...keys: string[]): Promise<(string | null)[]>
+  keys(pattern: string): Promise<string[]>
+  ttl(key: string): Promise<number>
+}

package/services/backend/src/modules/cache/providers/valkey/valkeyConfig.ts

@@ -0,0 +1,17 @@
+export const CACHE_CONFIG = {
+  LOGIN_ATTEMPTS: {
+    MAX_ATTEMPTS: process.env.LOGIN_MAX_ATTEMPTS
+      ? parseInt(process.env.LOGIN_MAX_ATTEMPTS)
+      : 5,
+    LOCKOUT_DURATION: process.env.LOGIN_LOCKOUT_DURATION
+      ? parseInt(process.env.LOGIN_LOCKOUT_DURATION)
+      : 15 * 60,
+    ATTEMPT_WINDOW: process.env.LOGIN_ATTEMPT_WINDOW
+      ? parseInt(process.env.LOGIN_ATTEMPT_WINDOW)
+      : 30 * 60,
+  },
+  KEY_PREFIXES: {
+    LOGIN_ATTEMPTS: "login_attempts:",
+    LOGIN_LOCK: "login_lock:",
+  },
+} as const

package/services/backend/src/modules/cache/providers/valkey/valkeyConnection.ts

@@ -0,0 +1,59 @@
+import type { FastifyInstance } from "fastify"
+import type { RedisKey } from "iovalkey"
+import type { ValkeyPluginOptions, ValkeyService } from "./valkeyTypes"
+import fastifyPlugin from "fastify-plugin"
+import { Redis } from "iovalkey"
+
+export default fastifyPlugin(
+  (fastify: FastifyInstance, options: ValkeyPluginOptions, done: any) => {
+    const url = options.url || "redis://cache:6379"
+
+    fastify.log.info(`[CACHE] Connecting to ${url}`)
+
+    const client = new Redis(url, {
+      retryStrategy: (times) => {
+        const delay = Math.min(times * 50, 2000)
+
+        return delay
+      },
+      ...options.options,
+    })
+
+    // Handle connection events
+    client.on("error", (error) => {
+      fastify.log.error("[CACHE] Error:", error)
+    })
+    client.on("connect", () => fastify.log.info("[CACHE] Connected"))
+    client.on("reconnecting", () => fastify.log.info("[CACHE] Reconnecting..."))
+
+    const valkeyService: ValkeyService = {
+      get: async (key: string) => client.get(key),
+      set: async (key: string, value: string, expireSeconds?: number) => {
+        if (expireSeconds) {
+          return client.setex(key, expireSeconds, value)
+        }
+
+        return client.set(key, value)
+      },
+      del: async (...args: [...keys: RedisKey[]]) => client.del(args),
+      exists: async (key: string) => client.exists(key),
+      incr: async (key: string) => client.incr(key),
+      expire: async (key: string, seconds: number) =>
+        client.expire(key, seconds),
+      multi: () => client.multi() as any,
+      setex: async (key: string, seconds: number, value: string) =>
+        client.setex(key, seconds, value),
+      mget: async (...keys: string[]) => client.mget(keys),
+      keys: async (pattern: string) => client.keys(pattern),
+      ttl: async (key: string) => client.ttl(key),
+    }
+
+    fastify.decorate("cache", valkeyService)
+
+    fastify.addHook("onClose", async () => {
+      await client.quit()
+    })
+
+    done()
+  },
+)

package/services/backend/src/modules/cache/providers/valkey/valkeyTypes.ts

@@ -0,0 +1,20 @@
+import type { Redis, RedisKey, RedisOptions } from "iovalkey"
+
+export type ValkeyPluginOptions = {
+  url?: string
+  options?: RedisOptions
+}
+
+export type ValkeyService = {
+  get(key: string): Promise<string | null>
+  set(key: string, value: string, expireSeconds?: number): Promise<"OK">
+  del(...keys: [...keys: RedisKey[]]): Promise<number>
+  exists(key: string): Promise<number>
+  incr(key: string): Promise<number>
+  expire(key: string, seconds: number): Promise<number>
+  multi(): Redis
+  setex(key: string, seconds: number, value: string): Promise<"OK">
+  mget(...keys: string[]): Promise<(string | null)[]>
+  keys(pattern: string): Promise<string[]>
+  ttl(key: string): Promise<number>
+}

package/services/backend/src/modules/database/providers/mongodb/mongoConnection.ts

@@ -0,0 +1,29 @@
+import fastifyPlugin from "fastify-plugin"
+import mongoose from "mongoose"
+
+export default fastifyPlugin(async (fastify, opts: { uri: string }) => {
+  if (!opts.uri) {
+    throw new Error(
+      "MongoDB URI is not provided. Please set the MONGO_HOST environment variable.",
+    )
+  }
+
+  try {
+    // Connect to MongoDB
+    await mongoose.connect(opts.uri)
+    const database = mongoose.connection
+
+    database.on(
+      "error",
+      console.error.bind(console, "MongoDB connection error:"),
+    )
+    database.once("open", () => {
+      fastify.log.info(`MongoDB connected.`)
+    })
+
+    fastify.decorate("database", database)
+  } catch (error: any) {
+    fastify.log.error(`Failed to connect to MongoDB: ${error.message}`)
+    throw error // Ensure that Fastify doesn't start if MongoDB connection fails
+  }
+})

package/services/backend/src/modules/database/providers/mongodb/mongooseMpath.d.ts

@@ -0,0 +1,83 @@
+declare module "mongoose-mpath" {
+  import { Schema, Document, Types } from "mongoose"
+
+  export interface MpathOptions {
+    /**
+     * Name of the model to use for queries
+     */
+    modelName?: string
+
+    /**
+     * Field name to use for path storage. Defaults to 'path'
+     */
+    pathSeparator?: string
+
+    /**
+     * Separator to use for path storage. Defaults to ','
+     */
+    onDelete?: "REPARENT" | "DELETE"
+
+    /**
+     * Action to take when parent is deleted
+     * REPARENT: Parent's children become children of parent's parent
+     * DELETE: Delete all children (default)
+     */
+    pathField?: string
+
+    /**
+     * Field name for parent_id reference. Defaults to 'parent'
+     */
+    parentField?: string
+
+    /**
+     * Type to use for _id fields. Defaults to mongoose.Schema.Types.ObjectId
+     */
+    idType?: typeof Schema.Types.String | typeof Schema.Types.ObjectId
+
+    /**
+     * Whether to index the path. Defaults to true
+     */
+    indexPath?: boolean
+  }
+
+  export interface MpathMethods<T extends Document> {
+    /**
+     * Gets all children of the document, returns a promise
+     */
+    getAllChildren(filters?: Record<string, any>): Promise<T[]>
+
+    /**
+     * Gets immediate children of the document, returns a promise
+     */
+    getImmediateChildren(filters?: Record<string, any>): Promise<T[]>
+
+    /**
+     * Gets children tree of the document
+     */
+    getChildrenTree(options?: {
+      filter?: Record<string, any>
+      fields?: string | string[]
+      options?: Record<string, any>
+      minLevel?: number
+      maxLevel?: number
+      population?: string[]
+    }): Promise<T[]>
+
+    /**
+     * Gets ancestors of the document
+     */
+    getAncestors(filters?: Record<string, any>): Promise<T[]>
+
+    /**
+     * Gets parent of the document
+     */
+    getParent(): Promise<T | null>
+  }
+
+  const MpathPlugin: <T extends Document>(
+    schema: Schema,
+    options?: MpathOptions,
+  ) => void
+
+  export default MpathPlugin
+}

package/services/backend/src/modules/database/providers/mongodb/service.ts

@@ -0,0 +1,12 @@
+import type { PopulateOptions } from "mongoose"
+
+export type PopulateOptionType =
+  | string
+  | PopulateOptions
+  | (string | PopulateOptions)[]
+
+export interface QueryOptions {
+  limit?: number
+  offset?: number
+  populate?: PopulateOptionType[]
+}

package/services/backend/src/server.ts

@@ -0,0 +1,114 @@
+import type { FastifyInstance } from "fastify"
+import app from "./app"
+import process from "node:process"
+
+const PORT = 3000
+const HOST = "0.0.0.0"
+
+const createServer = async () => {
+  const server = await app()
+  return server
+}
+
+const startServer = async (server: FastifyInstance) => {
+  try {
+    await server.listen({ port: PORT, host: HOST })
+    server.log.info(`Server listening on ${HOST}:${PORT}`)
+    return server
+  } catch (error) {
+    server.log.error({ msg: "Failed to start server", error })
+    throw error
+  }
+}
+
+const closeServer = async (server: FastifyInstance) => {
+  try {
+    console.log("Closing server...")
+    await server.close()
+    console.log("Server closed successfully")
+  } catch (error) {
+    console.error("Error closing server:", error)
+    throw error
+  }
+}
+
+const setupGracefulShutdown = (server: FastifyInstance) => {
+  const gracefulShutdown = async (signal: string) => {
+    console.log(`Received ${signal}, shutting down gracefully...`)
+    try {
+      // Stop all background tasks first
+      if (server.taskManager) {
+        server.taskManager.stopAllTasks()
+        console.log("All background tasks stopped")
+      }
+
+      await closeServer(server)
+      process.exit(0)
+    } catch (error) {
+      console.error("Error during graceful shutdown:", error)
+      process.exit(1)
+    }
+  }
+
+  process.on("SIGTERM", () => gracefulShutdown("SIGTERM"))
+  process.on("SIGINT", () => gracefulShutdown("SIGINT"))
+  process.on("SIGQUIT", () => gracefulShutdown("SIGQUIT"))
+}
+
+const handleBuildMode = async (server: FastifyInstance) => {
+  if (process.env.RACLETTE_BUILD_MODE === "generate") {
+    console.log("Build mode: File generation completed, exiting...")
+
+    // App creation already handled all file generation
+    // No need to start the server, just clean up and exit
+
+    // Stop any tasks that might have been created during app initialization
+    if (server.taskManager) {
+      server.taskManager.stopAllTasks()
+      console.log("Stopped any background tasks")
+    }
+
+    // Close server without starting it
+    await closeServer(server)
+
+    // Immediate exit for build mode
+    console.log("Build complete, exiting...")
+    process.exit(0)
+
+    return true
+  }
+  return false
+}
+
+const start = async (): Promise<void> => {
+  try {
+    const server = await createServer()
+
+    // Check build mode first
+    const isBuildMode = await handleBuildMode(server)
+    if (isBuildMode) return
+
+    // Setup graceful shutdown for normal mode
+    setupGracefulShutdown(server)
+
+    // Start server for normal operation
+    await startServer(server)
+
+    // Mark app as ready to start background tasks
+    if (server.taskManager) {
+      server.taskManager.markAppReady()
+      console.log("App ready, background tasks can now start")
+    }
+  } catch (error) {
+    console.error("Failed to start application:", error)
+    process.exit(1)
+  }
+}
+
+// Handle unhandled rejections
+process.on("unhandledRejection", (reason, promise) => {
+  console.error("Unhandled Rejection at:", promise, "reason:", reason)
+  process.exit(1)
+})
+
+start()

package/services/backend/src/shared/helper/mongoHelper.ts

@@ -0,0 +1,61 @@
+import { clone } from "ramda"
+const chainMongoFind = (_params, chain = "$and") => {
+  const params = clone(_params)
+  if (!params.find) {
+    params.find = {}
+  }
+  if (!params.find.$and) {
+    const oldFinds = Object.keys(params.find)
+    params.find[chain] = []
+    oldFinds.forEach((find) => {
+      const newAndFind = {}
+      newAndFind[find] = params.find[find]
+      params.find[chain].push(newAndFind)
+      delete params.find[find]
+    })
+  }
+  return params
+}
+
+const applyDataFieldToQuery = (find, values: any = [], field) => {
+  if (values.length === 0) return find
+
+  const addTypes = (wrapper, values, isArray) => {
+    if (isArray) {
+      const block = {}
+      block[field] = {}
+      if (values.length > 1) {
+        block[field] = { $in: values }
+        wrapper.push(block)
+      }
+      if (values.length === 1) {
+        block[field] = { $eq: values[0] }
+        wrapper.push(block)
+      }
+    } else {
+      if (values.length > 1) {
+        wrapper[field] = { $in: values }
+      }
+      if (values.length === 1) {
+        wrapper[field] = { $eq: values[0] }
+      }
+    }
+
+    return wrapper
+  }
+  if (Object.keys(find).length === 0) {
+    find = addTypes(find, values, false)
+  } else {
+    if (find.$and) {
+      find.$and = addTypes(find.$and, values, true)
+    }
+    if (!find.$and) {
+      find = chainMongoFind({ find }).find
+      find.$and = addTypes(find.$and, values, true)
+    }
+  }
+
+  return find
+}
+
+export { applyDataFieldToQuery, chainMongoFind }

package/services/backend/src/shared/helper/pluginHelper.ts

@@ -0,0 +1,54 @@
+import { pipe, toLower, trim, replace,split, join, map } from "ramda"
+
+export const parsePluginFolderName = (
+  folderName: string,
+): { author: string; pluginName: string } => {
+  const parts = folderName.split("__")
+
+  if (parts.length !== 2) {
+    return { author: "", pluginName: "" }
+  }
+
+  return { author: slugify(parts[0]), pluginName: slugify(parts[1]) }
+}
+
+// Helper function to capitalize first letter of a word
+const capitalize = (word) => word.charAt(0).toUpperCase() + word.slice(1)
+
+export const deslugify = pipe(
+  replace(/^-|-$/g, ""), // Remove any leading/trailing dashes (defensive)
+  split("-"), // Split on dashes to get words
+  map(capitalize), // Capitalize each word
+  join(" ") // Join with spaces
+)
+
+export const slugify = pipe(
+  toLower,
+  trim,
+  replace(/\s+/g, "-"), // Replace spaces with dashes
+  replace(/[^\w-]/g, ""), // Remove non-word chars except dashes
+  replace(/-+/g, "-"), // Replace multiple dashes with single dash
+  replace(/^-|-$/g, ""), // Remove leading/trailing dashes
+)
+
+export const getInstanceActionId = (
+  pluginName: string,
+  identifier: string,
+  actionId: string,
+  actionIdOverride = "",
+) => {
+  if (actionIdOverride.length) {
+    return `plugin-${pluginName}-${actionIdOverride}`
+  }
+  return `plugin-${pluginName}-${identifier}-${actionId}`
+}
+
+export const generatePluginKey = (name:string, author:string):string=>`${slugify(author)}__${slugify(name)}`
+
+export default {
+  parsePluginFolderName,
+  slugify,
+  deslugify,
+  getInstanceActionId,
+  generatePluginKey,
+}