@raclettejs/workbench 0.1.34 → 0.1.36-canary.0

package/plugins/raclette__cache/backend/helpers/valkeyExplorer.ts

@@ -0,0 +1,89 @@
+import { Redis } from "iovalkey"
+
+export type NormalizedPattern = {
+  match: string
+  listAll: boolean
+}
+
+/** Explorer defaults to DB 0; raclette.config often sets cache db 1 for the app client. */
+export const DEFAULT_EXPLORER_DB = 0
+
+export const parseExplorerDb = (queryDb?: number): number => {
+  if (typeof queryDb === "number" && !Number.isNaN(queryDb) && queryDb >= 0) {
+    return Math.floor(queryDb)
+  }
+  return DEFAULT_EXPLORER_DB
+}
+
+export const buildRedisOptions = (db: number) => {
+  const raw = process.env.CACHE_URL || "redis://cache:6379"
+  const normalized = raw
+    .replace(/^valkey:/, "redis:")
+    .replace(/^raclette-cache:/, "redis:")
+
+  try {
+    const url = new URL(normalized)
+    return {
+      host: url.hostname || "cache",
+      port: url.port ? Number(url.port) : 6379,
+      db,
+      maxRetriesPerRequest: 1,
+    }
+  } catch {
+    return { host: "cache", port: 6379, db, maxRetriesPerRequest: 1 }
+  }
+}
+
+export const withExplorerClient = async <T>(
+  db: number,
+  fn: (client: Redis) => Promise<T>,
+): Promise<T> => {
+  const client = new Redis(buildRedisOptions(db))
+  try {
+    return await fn(client)
+  } finally {
+    await client.quit()
+  }
+}
+
+/** SCAN avoids blocking KEYS; dedupes results across cursor pages. */
+export const scanKeys = async (
+  client: Redis,
+  pattern: string,
+): Promise<string[]> => {
+  const keys = new Set<string>()
+  let cursor = "0"
+
+  do {
+    const [next, batch] = await client.scan(
+      cursor,
+      "MATCH",
+      pattern,
+      "COUNT",
+      500,
+    )
+    cursor = next
+    for (const key of batch) {
+      keys.add(key)
+    }
+  } while (cursor !== "0")
+
+  return [...keys]
+}
+
+export const normalizePattern = (pattern?: string): NormalizedPattern => {
+  const trimmed = pattern?.trim() ?? ""
+  if (!trimmed || trimmed === "*") {
+    return { match: "*", listAll: true }
+  }
+  return { match: trimmed, listAll: false }
+}
+
+/** Group label from key prefix (segment before first `:` or `.`). */
+export const keyGroup = (key: string): string => {
+  const colon = key.indexOf(":")
+  if (colon > 0) return key.slice(0, colon)
+  const dot = key.indexOf(".")
+  if (dot > 0) return key.slice(0, dot)
+  return "(ungrouped)"
+}

package/plugins/raclette__cache/backend/index.ts

@@ -0,0 +1,21 @@
+import type {
+  PluginFastifyInstance,
+  PluginOptions,
+} from "@raclettejs/core/backend"
+import { registerRoutes } from "./routes"
+
+const cachePlugin = async (
+  fastify: PluginFastifyInstance,
+  _opts: PluginOptions,
+) => {
+  try {
+    await fastify.register((instance) => registerRoutes(instance))
+  } catch (error) {
+    fastify.log.error("Failed to register cache plugin routes.", error)
+    throw error
+  }
+
+  fastify.registerForFrontendGeneration({})
+}
+
+export default cachePlugin

package/plugins/raclette__cache/backend/routes/route.cache.cacheEntries.get.ts

@@ -0,0 +1,118 @@
+import type { PluginFastifyInstance } from "@raclettejs/types"
+import type { FastifyReply, FastifyRequest } from "fastify"
+import { Type } from "@sinclair/typebox"
+import {
+  buildCacheEntrySource,
+  toPayloadItems,
+} from "../helpers/cacheEntryBuilder"
+import {
+  normalizePattern,
+  parseExplorerDb,
+  scanKeys,
+  withExplorerClient,
+} from "../helpers/valkeyExplorer"
+
+const MAX_LIMIT = 500
+const DEFAULT_LIMIT = 100
+
+const QuerystringSchema = Type.Object({
+  pattern: Type.Optional(Type.String()),
+  offset: Type.Optional(Type.Number({ minimum: 0 })),
+  limit: Type.Optional(Type.Number({ minimum: 1, maximum: MAX_LIMIT })),
+  db: Type.Optional(Type.Number({ minimum: 0, maximum: 15 })),
+})
+
+type Querystring = {
+  pattern?: string
+  offset?: number
+  limit?: number
+  db?: number
+}
+
+export default (fastify: PluginFastifyInstance) => {
+  const handler = async (
+    req: FastifyRequest<{ Querystring: Querystring }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      const { match, listAll } = normalizePattern(req.query.pattern)
+      const db = parseExplorerDb(
+        req.query.db !== undefined ? Number(req.query.db) : undefined,
+      )
+      const offset = Math.max(0, Number(req.query.offset ?? 0))
+      const limit = Math.min(
+        MAX_LIMIT,
+        Math.max(1, Number(req.query.limit ?? DEFAULT_LIMIT)),
+      )
+
+      const entries = []
+      let total = 0
+
+      await withExplorerClient(db, async (client) => {
+        const allKeys = (await scanKeys(client, match)).sort((a, b) =>
+          a.localeCompare(b),
+        )
+        total = allKeys.length
+        const pageKeys = allKeys.slice(offset, offset + limit)
+
+        if (pageKeys.length === 0) return
+
+        const values = await client.mget(...pageKeys)
+
+        const pageEntries = await Promise.all(
+          pageKeys.map(async (key, index) => {
+            const rawValue = values[index] ?? ""
+            const ttl = await client.ttl(key)
+            return buildCacheEntrySource(key, rawValue, ttl)
+          }),
+        )
+
+        entries.push(...pageEntries)
+      })
+
+      const requestData = req.requestParams ?? {}
+
+      return {
+        appSessionId: requestData.appSessionId ?? "",
+        requestId: requestData.requestId ?? "",
+        appRequestCode: requestData.appRequestCode ?? "dataRead",
+        type: "dataRead",
+        body: {
+          items: toPayloadItems(entries),
+          hits: {
+            total,
+            offset,
+            limit,
+            hasMore: offset + limit < total,
+            instanceId: "default",
+            pattern: match,
+            listAll,
+            db,
+          },
+        },
+      }
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : String(err)
+      fastify.log.error(message)
+      return reply.internalServerError(message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [
+      fastify.authenticate,
+      fastify.checkPermissions(["user.isAdmin"]),
+    ],
+    config: {
+      type: "dataRead",
+    },
+    schema: {
+      querystring: QuerystringSchema,
+      summary: "List Valkey cache entries (admin)",
+      description:
+        "Read-only SCAN of keys (optional pattern, db defaults to 0 for explorer)",
+      tags: ["cache"],
+    },
+  }
+}

package/plugins/raclette__cache/backend/routes/route.cache.cacheEntry.get.ts

@@ -0,0 +1,91 @@
+import type { PluginFastifyInstance } from "@raclettejs/types"
+import type { FastifyReply, FastifyRequest } from "fastify"
+import { Type } from "@sinclair/typebox"
+import {
+  buildCacheEntrySource,
+  toPayloadItems,
+  type CacheEntrySource,
+} from "../helpers/cacheEntryBuilder"
+import { parseExplorerDb, withExplorerClient } from "../helpers/valkeyExplorer"
+
+const QuerystringSchema = Type.Object({
+  key: Type.String({ minLength: 1 }),
+  db: Type.Optional(Type.Number({ minimum: 0, maximum: 15 })),
+})
+
+type Querystring = {
+  key: string
+  db?: number
+}
+
+export default (fastify: PluginFastifyInstance) => {
+  const handler = async (
+    req: FastifyRequest<{ Querystring: Querystring }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      const key = req.query.key.trim()
+      if (!key.length) {
+        return reply.badRequest("key is required")
+      }
+
+      const db = parseExplorerDb(
+        req.query.db !== undefined ? Number(req.query.db) : undefined,
+      )
+
+      let entry: CacheEntrySource | null = null
+
+      await withExplorerClient(db, async (client) => {
+        const rawValue = await client.get(key)
+        if (rawValue === null) {
+          return
+        }
+
+        const ttl = await client.ttl(key)
+        entry = buildCacheEntrySource(key, rawValue, ttl, {
+          attachFullParsed: true,
+        })
+      })
+
+      const requestData = req.requestParams ?? {}
+      const items = entry ? toPayloadItems([entry]) : []
+
+      return {
+        appSessionId: requestData.appSessionId ?? "",
+        requestId: requestData.requestId ?? "",
+        appRequestCode: requestData.appRequestCode ?? "dataRead",
+        type: "dataRead",
+        body: {
+          items,
+          hits: {
+            total: items.length,
+            key,
+            db,
+            found: items.length > 0,
+          },
+        },
+      }
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : String(err)
+      fastify.log.error(message)
+      return reply.internalServerError(message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [
+      fastify.authenticate,
+      fastify.checkPermissions(["user.isAdmin"]),
+    ],
+    config: {
+      type: "dataRead",
+    },
+    schema: {
+      querystring: QuerystringSchema,
+      summary: "Read a single Valkey cache entry (admin)",
+      description: "GET + TTL for one key (no SCAN; safe for keys containing wildcards)",
+      tags: ["cache"],
+    },
+  }
+}

package/plugins/raclette__cache/backend/routes.ts

@@ -0,0 +1,8 @@
+import type { PluginFastifyInstance } from "@raclettejs/core/backend"
+import getCacheEntriesRoute from "./routes/route.cache.cacheEntries.get"
+import getCacheEntryRoute from "./routes/route.cache.cacheEntry.get"
+
+export const registerRoutes = async (fastify: PluginFastifyInstance) => {
+  await fastify.get("/cacheEntries", getCacheEntriesRoute(fastify))
+  await fastify.get("/cacheEntry", getCacheEntryRoute(fastify))
+}

package/plugins/raclette__cache/frontend/components/TableColumnConfigDialog.vue

@@ -0,0 +1,95 @@
+<template>
+  <v-dialog
+    v-model="isOpen"
+    :max-width="$vuetify.display.mobile ? undefined : '500px'"
+    scrollable
+  >
+    <v-card :title="$t('workbench.cacheList.configureColumns')">
+      <v-divider />
+
+      <v-card-text class="tw:p-0">
+        <div class="tw:p-4 tw:border-b tw:border-gray-200">
+          <div class="tw:flex tw:gap-2">
+            <v-btn
+              variant="outlined"
+              size="small"
+              prepend-icon="mdi-format-list-bulleted"
+              @click="emit('select-all')"
+            >
+              {{ $t("core.selectAll") }}
+            </v-btn>
+            <v-btn
+              variant="outlined"
+              size="small"
+              prepend-icon="mdi-format-list-checkbox"
+              @click="emit('deselect-all')"
+            >
+              {{ $t("workbench.cacheList.deselectAll") }}
+            </v-btn>
+          </div>
+        </div>
+
+        <v-list class="tw:py-0">
+          <v-list-item
+            v-for="header in headers"
+            :key="header.key"
+            class="tw:px-4"
+            @click="toggleHeader(header.key, !isHeaderEnabled(header.key))"
+          >
+            <template #prepend>
+              <v-switch
+                class="tw:mr-2"
+                :model-value="isHeaderEnabled(header.key)"
+                color="primary"
+                hide-details
+                inset
+              />
+            </template>
+            <v-list-item-title>{{ header.title }}</v-list-item-title>
+          </v-list-item>
+        </v-list>
+      </v-card-text>
+
+      <v-card-actions v-if="$vuetify.display.mobile">
+        <v-spacer />
+        <v-btn variant="outlined" @click="isOpen = false">
+          {{ $t("workbench.cacheList.done") }}
+        </v-btn>
+      </v-card-actions>
+    </v-card>
+  </v-dialog>
+</template>
+
+<script setup lang="ts">
+import { computed } from "vue"
+import type { TableColumnHeader } from "../composables/useTableColumnConfig"
+
+const props = defineProps<{
+  modelValue: boolean
+  headers: TableColumnHeader[]
+  disabledHeaders: string[]
+}>()
+
+const emit = defineEmits<{
+  "update:modelValue": [value: boolean]
+  "toggle-header": [headerKey: string, enabled: boolean]
+  "select-all": []
+  "deselect-all": []
+}>()
+
+const isOpen = computed({
+  get: () => props.modelValue,
+  set: (value: boolean) => emit("update:modelValue", value),
+})
+
+const disabledHeaderKeys = computed(() =>
+  Array.isArray(props.disabledHeaders) ? props.disabledHeaders : [],
+)
+
+const isHeaderEnabled = (headerKey: string) =>
+  !disabledHeaderKeys.value.includes(headerKey)
+
+const toggleHeader = (headerKey: string, enabled: boolean) => {
+  emit("toggle-header", headerKey, enabled)
+}
+</script>

package/plugins/raclette__cache/frontend/composables/useTableColumnConfig.ts

@@ -0,0 +1,66 @@
+import { ref } from "vue"
+import { useLocalStorage } from "@vueuse/core"
+
+export type TableColumnHeader = {
+  title: string
+  key: string
+}
+
+const normalizeDisabledHeaders = (value: unknown): string[] =>
+  Array.isArray(value) ? value.filter((key) => typeof key === "string") : []
+
+export const useTableColumnConfig = (storageKey: string) => {
+  const configureDialogOpen = ref(false)
+  const disabledHeaders = useLocalStorage<string[]>(storageKey, [], {
+    mergeDefaults: (stored, defaults) =>
+      normalizeDisabledHeaders(stored ?? defaults),
+  })
+
+  if (!Array.isArray(disabledHeaders.value)) {
+    disabledHeaders.value = []
+  }
+
+  const filterHeaders = <T extends TableColumnHeader>(headers: T[]): T[] => {
+    const visible = headers.filter(
+      (header) => !disabledHeaders.value.includes(header.key),
+    )
+    return visible.length > 0 ? visible : headers
+  }
+
+  const toggleHeader = (headerKey: string, enabled: boolean) => {
+    if (enabled) {
+      disabledHeaders.value = disabledHeaders.value.filter(
+        (key) => key !== headerKey,
+      )
+      return
+    }
+    if (!disabledHeaders.value.includes(headerKey)) {
+      disabledHeaders.value = [...disabledHeaders.value, headerKey]
+    }
+  }
+
+  const selectAll = (headers: TableColumnHeader[]) => {
+    for (const header of headers) {
+      if (disabledHeaders.value.includes(header.key)) {
+        toggleHeader(header.key, true)
+      }
+    }
+  }
+
+  const deselectAll = (headers: TableColumnHeader[]) => {
+    for (const header of headers) {
+      if (!disabledHeaders.value.includes(header.key)) {
+        toggleHeader(header.key, false)
+      }
+    }
+  }
+
+  return {
+    configureDialogOpen,
+    disabledHeaders,
+    filterHeaders,
+    toggleHeader,
+    selectAll,
+    deselectAll,
+  }
+}

package/plugins/raclette__cache/frontend/generated-config.ts

@@ -0,0 +1,33 @@
+// Auto-generated frontend configuration for plugin: raclette__cache
+// This file is generated from backend routes - do not edit manually
+// Entity mapping: {}
+
+export default {
+  pluginName: "cache",
+  author: "raclette",
+  pluginKey: "raclette__cache",
+  routePrefix: "/raclette__cache",
+  pluginPath: "/app/src/appPlugins/raclette__cache",
+  data: {
+    cacheEntries: {
+      type: "cacheEntries",
+      operations: {
+        get: {
+          target: "/raclette__cache/cacheEntries",
+          method: "get",
+          storeActionType: "dataRead"
+        }
+      }
+    },
+    cacheEntry: {
+      type: "cacheEntry",
+      operations: {
+        get: {
+          target: "/raclette__cache/cacheEntry",
+          method: "get",
+          storeActionType: "dataRead"
+        }
+      }
+    }
+  }
+}