@raclettejs/workbench 0.1.35 → 0.1.36-canary.0

package/plugins/pacifico__compositions/frontend/widgets/CompositionCreateWidget.vue

@@ -1,29 +1,57 @@
 <template>
   <CompositionConfiguration
+    ref="configurationRef"
     v-model="newComposition"
+    v-model:interaction-link="draftInteractionLink"
     :disabled="isLoading"
-    @save-and-finish="onSubmit(true)"
-    @save="onSubmit"
+    @custom-action="onCustomAction"
   />
 </template>
 
 <script setup lang="ts">
-import { CompositionCreate } from "@raclettejs/core"
-import { ref } from "vue"
+import { CompositionCreate, InteractionLinkCreate } from "@raclettejs/core"
+import { computed, ref } from "vue"
 import CompositionConfiguration from "../components/compositionConfiguration/CompositionConfiguration.vue"
 import {
   usePluginApi,
   useRouteState,
 } from "@raclettejs/core/orchestrator/composables"
+import { DEFAULT_SLOT_NAME } from "@raclettejs/core/orchestrator/router/routeParserHelper"
+import { prefillInteractionLinkFromComposition } from "../composables/prefillInteractionLinkFromComposition"
 
-const props = defineProps<{
+defineProps<{
   uuid: string
 }>()
 
 const { $data } = usePluginApi("raclette__core")
 const { triggerInteractionLinkById } = useRouteState()
 
-const { execute, isLoading, error } = $data.composition.create()
+const configurationRef = ref<InstanceType<typeof CompositionConfiguration>>()
+
+const {
+  execute: executeCreate,
+  isLoading: isCreating,
+  error: createError,
+  data: createResultData,
+} = $data.composition.create({
+  options: { notify: false },
+})
+const {
+  execute: executeUpdate,
+  isLoading: isUpdating,
+  error: updateError,
+} = $data.composition.update({
+  options: { notify: false },
+})
+const {
+  execute: executeInteractionLinkCreate,
+  isLoading: isCreatingInteractionLink,
+  error: interactionLinkCreateError,
+} = $data.interactionLink.create()
+
+const isLoading = computed(
+  () => isCreating.value || isUpdating.value || isCreatingInteractionLink.value,
+)
 
 const newComposition = ref<CompositionCreate>({
   title: "",
@@ -39,14 +67,122 @@ const newComposition = ref<CompositionCreate>({
   widgetsLayout: [[]],
 })
 
+const createdCompositionId = ref<string | null>(null)
+
+const draftInteractionLink = ref<InteractionLinkCreate>({
+  composition: "",
+  description: "",
+  slotType: DEFAULT_SLOT_NAME,
+  triggers: [],
+  tags: [],
+  queryParameters: [],
+  isLandingPage: false,
+})
+
 const navigateBack = () =>
   triggerInteractionLinkById("compositionListInteractionLink")
 
-const onSubmit = async (finish = false) => {
-  await execute(newComposition.value)
+type CompositionWriteResult = {
+  result?: Array<{ _id?: string }>
+  response?: {
+    data?: {
+      body?: {
+        items?: Array<{ _id?: string }>
+      }
+    }
+  }
+}
+
+const getCreatedId = (executeResult: unknown): string | undefined => {
+  if (!executeResult || typeof executeResult !== "object") {
+    return undefined
+  }
+
+  const payload = executeResult as CompositionWriteResult
+  const fromHandler = payload.result?.[0]?._id
+  if (fromHandler) {
+    return fromHandler
+  }
+
+  return payload.response?.data?.body?.items?.[0]?._id
+}
+
+const getCreatedIdFromStore = (): string | undefined => {
+  if (!createResultData.value) {
+    return undefined
+  }
+
+  const items = Object.values(createResultData.value) as Array<{ _id?: string }>
+  return items[0]?._id
+}
 
-  if (!error.value && finish) {
+const persistComposition = async (): Promise<boolean> => {
+  if (createdCompositionId.value) {
+    await executeUpdate({
+      ...newComposition.value,
+      _id: createdCompositionId.value,
+    })
+
+    if (updateError.value) {
+      return false
+    }
+  } else {
+    const result = await executeCreate(newComposition.value)
+
+    if (createError.value) {
+      return false
+    }
+
+    const createdId = getCreatedId(result) ?? getCreatedIdFromStore()
+
+    if (!createdId) {
+      return false
+    }
+
+    createdCompositionId.value = createdId
+  }
+
+  draftInteractionLink.value.composition = createdCompositionId.value
+  prefillInteractionLinkFromComposition(
+    draftInteractionLink.value,
+    newComposition.value,
+  )
+
+  return true
+}
+
+const onCustomAction = async (actionId: string) => {
+  if (actionId === "save-and-continue") {
+    const saved = await persistComposition()
+
+    if (saved) {
+      configurationRef.value?.goToStep(3, { skipValidation: true })
+    }
+
+    return
+  }
+
+  if (actionId === "finish-without-il") {
     navigateBack()
+    return
+  }
+
+  if (actionId === "save-il") {
+    if (!createdCompositionId.value) {
+      const saved = await persistComposition()
+
+      if (!saved) {
+        return
+      }
+    }
+
+    draftInteractionLink.value.composition = createdCompositionId.value!
+
+    await executeInteractionLinkCreate(draftInteractionLink.value)
+
+    if (!interactionLinkCreateError.value) {
+      navigateBack()
+    }
   }
 }
 </script>

package/plugins/pacifico__compositions/frontend/widgets/CompositionEditWidget.vue

@@ -47,7 +47,11 @@ const { data } = $data.composition.get({
   },
 })
 
-const { execute: executeUpdate, isLoading } = $data.composition.update()
+const {
+  execute: executeUpdate,
+  isLoading,
+  error: updateError,
+} = $data.composition.update()
 const editableComposition = ref<Composition>()
 
 const composition = computed<Composition | undefined>(() => {
@@ -61,6 +65,11 @@ const composition = computed<Composition | undefined>(() => {
 const navigateBack = () =>
   triggerInteractionLinkById("compositionListInteractionLink")
 
-const onSubmit = async (finish = false) =>
+const onSubmit = async (finish = false) => {
   await executeUpdate(toRaw(editableComposition.value))
+
+  if (finish && !updateError.value) {
+    navigateBack()
+  }
+}
 </script>

package/plugins/pacifico__compositions/frontend/widgets/CompositionListWidget.vue

@@ -16,7 +16,11 @@
           prepend-icon="mdi-plus"
           variant="flat"
           color="success"
-          :text="$t('core.baseDataTable.createDataButton', { dataName: $t('workbench.compositionList.dataName') })"
+          :text="
+            $t('core.baseDataTable.createDataButton', {
+              dataName: $t('workbench.compositionList.dataName'),
+            })
+          "
           @click="goToCreate('compositionCreateInteractionLink')"
         />
       </template>
@@ -94,7 +98,11 @@
 </template>
 
 <script setup lang="ts">
-import { usePluginApi } from "@raclettejs/core/orchestrator/composables"
+import {
+  usePluginApi,
+  useRouteState,
+} from "@raclettejs/core/orchestrator/composables"
+import { DEFAULT_SLOT_NAME } from "@raclettejs/core/orchestrator/router/routeParserHelper"
 import { computed, watch, ref } from "vue"
 import type { Composition } from "@raclettejs/core"
 import { formatDistance } from "date-fns"
@@ -153,6 +161,16 @@ const props = defineProps<{
 }>()
 
 const { $data, $socket, $user } = usePluginApi("raclette__core")
+const { compositionSlots } = useRouteState()
+
+const COMPOSITION_LIST_PATH = "composition-list"
+
+const isCompositionListActive = () =>
+  compositionSlots.value.some(
+    (slot) =>
+      slot.slotName === DEFAULT_SLOT_NAME &&
+      slot.slotValue === COMPOSITION_LIST_PATH,
+  )
 const {
   data: compositions,
   execute,
@@ -291,9 +309,11 @@ const restore = (_id: string) => {
 const handleRowClick = (item: Composition) =>
   goToEditById("compositionEditInteractionLink", item._id)
 
-$socket.on("compositionCreated", () =>
-  execute({ isDeleted: showDeleted.value }),
-)
+$socket.on("compositionCreated", () => {
+  if (isCompositionListActive()) {
+    execute({ isDeleted: showDeleted.value })
+  }
+})
 watch(
   showDeleted,
   () => {

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

@@ -0,0 +1,22 @@
+// Auto-generated frontend configuration for plugin: pacifico__core
+// This file is generated from backend routes - do not edit manually
+// Entity mapping: {}
+
+export default {
+  pluginName: "core",
+  author: "pacifico",
+  pluginKey: "pacifico__core",
+  routePrefix: "/pacifico__core",
+  pluginPath: "/app/src/appPlugins/pacifico__core",
+  data: {
+    "init-project": {
+      type: "init-project",
+      operations: {
+        create: {
+          target: "/pacifico__core/init-project",
+          method: "post"
+        }
+      }
+    }
+  }
+}

package/plugins/pacifico__interactionLinks/frontend/components/InteractionLinkConfiguration.vue

@@ -33,11 +33,7 @@ import { useI18n } from "vue-i18n"
 import { computed, useTemplateRef } from "vue"
 import { Step } from "@app/components/stepNavigator/StepNavigatorTypes"
 import StepNavigator from "@app/components/stepNavigator/StepNavigator.vue"
-import {
-  DEFAULT_SLOT_NAME,
-  DEFAULT_INLINE_SLOT_NAME,
-  DEFAULT_MODAL_SLOT_NAME,
-} from "@raclettejs/core/orchestrator/router/routeParserHelper"
+import { useInteractionLinkBehaviorFields } from "@app/composables/useInteractionLinkBehaviorFields"
 
 defineProps<{ disabled?: boolean; isEditing?: boolean }>()
 
@@ -53,6 +49,7 @@ const interactionLink = defineModel<
 const dynamicFormRef = useTemplateRef("dynamicFormRef")
 
 const { t } = useI18n()
+const { behaviorFields } = useInteractionLinkBehaviorFields()
 
 const inputFields = computed<
   DynamicFormItem<InteractionLinkCreate | InteractionLinkUpdate>[]
@@ -68,66 +65,7 @@ const inputFields = computed<
     prependIcon: "file-document",
     validation: { required: true },
   },
-  {
-    title: t("workbench.interactionLinkConfiguration.description.title"),
-    description: t(
-      "workbench.interactionLinkConfiguration.description.description",
-    ),
-    inputType: "textarea",
-    field: "description",
-    prependIcon: "text",
-  },
-  {
-    title: t("workbench.interactionLinkConfiguration.tags.title"),
-    description: t("workbench.interactionLinkConfiguration.tags.description"),
-    inputType: "tags",
-    field: "tags",
-    prependIcon: "tag-multiple",
-  },
-  {
-    divider: t("workbench.interactionLinkConfiguration.dividers.behavior"),
-  },
-  {
-    title: t("workbench.interactionLinkConfiguration.slotType.title"),
-    description: t(
-      "workbench.interactionLinkConfiguration.slotType.description",
-    ),
-    inputType: "select",
-    field: "slotType",
-    selectItems: [
-      DEFAULT_SLOT_NAME,
-      DEFAULT_MODAL_SLOT_NAME,
-      DEFAULT_INLINE_SLOT_NAME,
-    ],
-    prependIcon: "dock-window",
-    validation: {
-      required: true,
-    },
-  },
-  {
-    title: t("workbench.interactionLinkConfiguration.triggers.title"),
-    description: t(
-      "workbench.interactionLinkConfiguration.triggers.description",
-    ),
-    inputType: "triggers",
-    field: "triggers",
-  },
-  {
-    title: t("workbench.interactionLinkConfiguration.queryParameters.title"),
-    description: t(
-      "workbench.interactionLinkConfiguration.queryParameters.description",
-    ),
-    inputType: "list",
-    field: "queryParameters",
-  },
-  {
-    title: t("workbench.interactionLinkConfiguration.isLandingPage.title"),
-    description: t(
-      "workbench.interactionLinkConfiguration.isLandingPage.description",
-    ),
-    inputType: "switch",
-    field: "isLandingPage",
-  },
+  ...behaviorFields.value,
 ])
 
 const validateForm = (): boolean => {

package/plugins/pacifico__plugins/frontend/widgets/PluginListWidget.vue

@@ -7,8 +7,21 @@
       :show-filters="true"
       :show-actions-column="false"
       :row-click-handler="onRowClick"
+      :is-row-clickable="isPluginRowClickable"
       :show-export="false"
-    />
+    >
+      <template #item.name="{ item }">
+        <span class="tw:flex tw:items-center tw:gap-2">
+          <v-icon
+            v-if="isPluginRowClickable(item)"
+            icon="mdi-pencil"
+            size="small"
+            class="tw:opacity-70"
+          />
+          {{ item.name }}
+        </span>
+      </template>
+    </BaseDataTable>
   </div>
 </template>
 
@@ -48,10 +61,14 @@ const headers = computed<
   },
 ])
 
+const isPluginRowClickable = (item: PluginMetadata) =>
+  Boolean(item.pluginKey && hasPluginSettingsWidget(item.pluginKey))
+
 const onRowClick = (item: PluginMetadata) => {
-  if (item.pluginKey && hasPluginSettingsWidget(item.pluginKey)) {
+  const { pluginKey } = item
+  if (pluginKey && isPluginRowClickable(item)) {
     triggerInteractionLinkById("pluginDetailInteractionLink", {
-      pluginKey: item.pluginKey,
+      pluginKey,
     })
   }
 }

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

@@ -0,0 +1,94 @@
+import { keyGroup } from "./valkeyExplorer"
+import { sanitizeCacheEntryFields } from "./cacheEntrySanitizer"
+
+/** Max string length stored per row (larger values are truncated for transport). */
+export const MAX_VALUE_LENGTH = 16_384
+
+export type CacheEntrySource = {
+  key: string
+  keyGroup: string
+  value: string
+  valuePreview?: string
+  truncated: boolean
+  valueParsed?: unknown
+  ttl: number
+  ttlLabel: string
+}
+
+const truncateValue = (
+  raw: string,
+): { value: string; valuePreview?: string; truncated: boolean } => {
+  if (raw.length <= MAX_VALUE_LENGTH) {
+    return { value: raw, truncated: false }
+  }
+
+  return {
+    value: raw.slice(0, MAX_VALUE_LENGTH),
+    valuePreview: `${raw.slice(0, 512)}…`,
+    truncated: true,
+  }
+}
+
+const formatTtlLabel = (ttl: number): string => {
+  if (ttl === -1) return "no expiry"
+  if (ttl === -2) return "missing"
+  return `${ttl}s`
+}
+
+export type BuildCacheEntrySourceOptions = {
+  /** Parse the full raw value for `valueParsed` even when the transport string is truncated. */
+  attachFullParsed?: boolean
+}
+
+export const buildCacheEntrySource = (
+  key: string,
+  rawValue: string,
+  ttl: number,
+  options: BuildCacheEntrySourceOptions = {},
+): CacheEntrySource => {
+  const { attachFullParsed = false } = options
+  const truncatedFields = truncateValue(rawValue ?? "")
+  const sanitized = sanitizeCacheEntryFields(truncatedFields)
+
+  let valueParsed = sanitized.valueParsed
+
+  if (attachFullParsed && truncatedFields.truncated) {
+    const fullSanitized = sanitizeCacheEntryFields({
+      value: rawValue ?? "",
+      truncated: false,
+    })
+    if (fullSanitized.valueParsed !== undefined) {
+      valueParsed = fullSanitized.valueParsed
+    }
+  }
+
+  return {
+    key,
+    keyGroup: keyGroup(key),
+    value: sanitized.value,
+    valuePreview: sanitized.valuePreview,
+    truncated: sanitized.truncated,
+    valueParsed,
+    ttl,
+    ttlLabel: formatTtlLabel(ttl),
+  }
+}
+
+export const toPayloadItems = (entries: CacheEntrySource[]) => {
+  const now = new Date().toISOString()
+
+  return entries.map((entry) => ({
+    _id: entry.key,
+    _type: "cacheEntry",
+    _offline: 0,
+    _owner: "",
+    _tags: [] as string[],
+    _displayName: entry.key,
+    _completion: "",
+    _project: "",
+    _updatedAt: now,
+    _createdAt: now,
+    _deleted: false,
+    _source: entry,
+  }))
+}

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

@@ -0,0 +1,86 @@
+export const HIDE_SECRETS = true
+
+export const SECRET_KEY_PATTERNS: RegExp[] = [
+  /password/i,
+  /secret/i,
+  /token/i,
+  /api[_-]?key/i,
+  /credential/i,
+  /private[_-]?key/i,
+  /access[_-]?token/i,
+  /refresh[_-]?token/i,
+  /authorization/i,
+  /bearer/i,
+]
+
+const REDACTED_VALUE = "******"
+const PREVIEW_LENGTH = 512
+
+export const isSecretKey = (key: string): boolean =>
+  SECRET_KEY_PATTERNS.some((pattern) => pattern.test(key))
+
+export const redactJsonValue = (value: unknown): unknown => {
+  if (Array.isArray(value)) {
+    return value.map((item) => redactJsonValue(item))
+  }
+
+  if (value !== null && typeof value === "object") {
+    const redacted: Record<string, unknown> = {}
+
+    for (const [key, nestedValue] of Object.entries(
+      value as Record<string, unknown>,
+    )) {
+      redacted[key] = isSecretKey(key)
+        ? REDACTED_VALUE
+        : redactJsonValue(nestedValue)
+    }
+
+    return redacted
+  }
+
+  return value
+}
+
+type SanitizeInput = {
+  value: string
+  valuePreview?: string
+  truncated: boolean
+}
+
+type SanitizeResult = {
+  value: string
+  valuePreview?: string
+  truncated: boolean
+  valueParsed?: unknown
+}
+
+const buildPreview = (value: string): string =>
+  `${value.slice(0, PREVIEW_LENGTH)}…`
+
+export const sanitizeCacheEntryFields = ({
+  value,
+  valuePreview,
+  truncated,
+}: SanitizeInput): SanitizeResult => {
+  let parsed: unknown
+
+  try {
+    parsed = JSON.parse(value)
+  } catch {
+    return { value, valuePreview, truncated }
+  }
+
+  if (!HIDE_SECRETS) {
+    return { value, valuePreview, truncated, valueParsed: parsed }
+  }
+
+  const valueParsed = redactJsonValue(parsed)
+  const redactedValue = JSON.stringify(valueParsed)
+
+  return {
+    value: redactedValue,
+    valuePreview: truncated ? buildPreview(redactedValue) : valuePreview,
+    truncated,
+    valueParsed,
+  }
+}

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)"
+}