robobyte-front-builder 1.0.19 → 1.0.23

package/src/services/reportData/fetchReportData.js

@@ -8,11 +8,11 @@
 // - isSingle (bool)
 // Optional extras: page (default 1), pageSize (default 50)
 
-import { Services } from 'src/services/Endpoints'
-import { Endpoints } from 'src/services/Endpoints'
-import { ReportBuilderEndpoints } from 'services/Endpoints/ReportBuilderEndpoints'
-import { FilterFormat } from 'services/helper/FilterFormat'
-import { Helper } from 'services/helper/helper'
+import {Services} from 'src/services/Endpoints'
+import {Endpoints} from 'src/services/Endpoints'
+import {ReportBuilderEndpoints} from 'services/Endpoints/ReportBuilderEndpoints'
+import {FilterFormat} from 'services/helper/FilterFormat'
+import {Helper} from 'services/helper/helper'
 
 // In-memory cache for builder models by pageId (resets on refresh/new tab)
 const builderModelCache = new Map()
@@ -48,7 +48,7 @@ function toNestedByUnderscore(input) {
       typeof value === 'object' &&
       !Array.isArray(value)
     ) {
-      ref[last] = { ...existing, ...value }
+      ref[last] = {...existing, ...value}
     } else {
       ref[last] = value
     }
@@ -63,7 +63,7 @@ function toNestedByUnderscore(input) {
       const k = Helper.toCamelCaseDotNet(parts[0])
       const existing = result[k]
       if (existing && typeof existing === 'object' && nestedVal && typeof nestedVal === 'object') {
-        result[k] = { ...existing, ...nestedVal }
+        result[k] = {...existing, ...nestedVal}
       } else {
         result[k] = nestedVal
       }
@@ -96,16 +96,18 @@ function convertToNestedObject(flatObject, builderData) {
 }
 
 export async function fetchReportDataByPageId({
-  pageId,
-  filter = {},
-  isDataOnly = false,
-  dataAsObject = false,
-  isPagination = true,
-  isSingle = false,
-  globalParams = null,
-  page = 1,
-  pageSize = 50
-}) {
+                                                pageId,
+                                                filter = {},
+                                                isDataOnly = false,
+                                                dataAsObject = false,
+                                                isPagination = true,
+                                                isSingle = false,
+                                                globalParams = null,
+                                                page = 1,
+                                                pageSize = 50,
+                                                authContext = null,
+                                                context = null
+                                              }) {
   try {
     const asObject = dataAsObject
 
@@ -117,45 +119,82 @@ export async function fetchReportDataByPageId({
         Endpoints.ReportBuilder.Post.GetReportDetails,
         false,
         {},
-        { id: null, pageId }
+        {id: null, pageId}
       )
 
       const detailsData = detailsResp?.data
       if (!detailsData || !detailsData.value) {
-        return { success: false, error: 'Report details not found' }
+        return {success: false, error: 'Report detailsOld not found'}
       }
 
-      builderModel = { ...JSON.parse(detailsData.value), id: detailsData.id }
+      builderModel = {...JSON.parse(detailsData.value), id: detailsData.id}
       builderModelCache.set(cacheKey, builderModel)
     }
 
     if (globalParams != null && builderModel?.selectionParams != null) {
       builderModel.selectionParams = builderModel.selectionParams.map((param, idx) => {
         if (globalParams.hasOwnProperty(idx)) {
-          return { ...param, value: globalParams[idx] }
+          return {...param, value: globalParams[idx]}
         }
         return param
       })
     }
 
     // 2) Prepare filters (no AG Grid specifics)
-    let localFilter = filter ? { ...filter } : {}
+    let localFilter = filter ? {...filter} : {}
     let localTFilter = localFilter?.Tfilter ? [...localFilter.Tfilter] : []
     localTFilter = localFilter?.TFilter ? [...localTFilter, ...localFilter.TFilter] : [...localTFilter]
     const builderFilter = builderModel?.filter?.Tfilter ?? []
     localTFilter = (localTFilter || []).filter(x => x?.value !== null && x?.value !== undefined && x?.value !== '')
     localTFilter = [...localTFilter, ...builderFilter]
+
+    // Extract customFilterCode from filter or builderModel
+    const customFilterCode = filter?.customFilterCode || builderModel?.filter?.customFilterCode || ''
+
     delete localFilter.Tfilter
     delete localFilter.TFilter
     delete localFilter.LocalTfilter
     delete localFilter.localTfilter
     delete localFilter.fixedTFilter
     delete localFilter.fixedTfilter
+    delete localFilter.customFilterCode
 
     const formattedT = FilterFormat(localTFilter)
+
+    // Execute custom filter code if present
+    let customFilterResult = []
+    if (customFilterCode && customFilterCode.trim()) {
+      try {
+        const executeCode = new Function('authContext', 'context', 'filters', `
+          let customFilter = [];
+          try {
+            ${customFilterCode}
+          } catch (e) {
+            console.error('Inner error in customFilterCode:', e);
+          }
+          return customFilter;
+        `)
+        const result = executeCode(authContext, context, localTFilter)
+
+        if (result && Array.isArray(result)) {
+          customFilterResult = result
+        } else if (result && !Array.isArray(result)) {
+          console.error('Error: Custom filter must return an array')
+        }
+      } catch (error) {
+        console.error('Error executing custom filter code:', error)
+      }
+    }
+
+    // Merge custom filter results with formatted filters
+    const finalTFilter = [
+      ...(Array.isArray(formattedT) ? formattedT.filter(f => (f == null ? false : f.value !== null)) : []),
+      ...customFilterResult
+    ]
+
     let data = {
       ...localFilter,
-      tFilter: Array.isArray(formattedT) ? formattedT.filter(f => (f == null ? false : f.value !== null)) : [],
+      tFilter: finalTFilter,
       selectFields: builderModel?.selectedFields || [],
       selectParams: builderModel?.selectionParams || [],
       rawSql: builderModel?.rawSql
@@ -167,8 +206,8 @@ export async function fetchReportDataByPageId({
         ? 'SqlPagination'
         : 'Pagination'
       : builderModel?.isRaw
-      ? 'SqlNoPagination'
-      : 'NoPagination'
+        ? 'SqlNoPagination'
+        : 'NoPagination'
 
     const response = await Services.PostService(ReportBuilderEndpoints.Post.GenericGet, false, data, {
       page: isSingle ? 1 : page,
@@ -183,7 +222,9 @@ export async function fetchReportDataByPageId({
     if (asObject) {
       rows = rows.map(r => toNestedByUnderscore(r))
     }
-    if (isSingle) rows = rows[0]
+    if (isSingle)
+      rows = rows[0]
+
 
     if (isDataOnly) {
       return rows
@@ -198,12 +239,12 @@ export async function fetchReportDataByPageId({
           getType,
           filter: data,
           sourceModel: builderModel?.reportSource?.fullName,
-          params: { page: isSingle ? 1 : page, pageSize: isSingle ? 1 : pageSize }
+          params: {page: isSingle ? 1 : page, pageSize: isSingle ? 1 : pageSize}
         }
       }
   } catch (error) {
     console.error('fetchReportDataByPageId error', error)
-    return { success: false, error }
+    return {success: false, error}
   }
 }
 

package/src/services/routerRef.js

@@ -0,0 +1,35 @@
+/**
+ * routerRef — module-level Next.js router singleton.
+ *
+ * Why a singleton instead of a hook?
+ * jsExecutor.js runs user Calculation code outside of React's render cycle.
+ * It cannot call useRouter() directly. Instead, RouterSync (mounted inside
+ * RoboByteFrontBuilderProvider) keeps this reference in sync on every
+ * navigation, and jsExecutor imports getRouter() to inject it into every
+ * Calculation as the `router` bare-name variable.
+ *
+ * Usage in action code:
+ *   router.push('/dashboard')
+ *   router.replace({ pathname: '/report/[id]', query: { id: 42 } })
+ *   router.back()
+ *   console.log(router.pathname, router.query)
+ */
+
+let _router = null
+
+/**
+ * Called by RouterSync on every render so the ref is always current.
+ * @param {import('next/router').NextRouter} router
+ */
+export function setRouter(router) {
+  _router = router
+}
+
+/**
+ * Returns the current Next.js router instance, or null if RouterSync has
+ * not mounted yet (e.g. SSR or very early render).
+ * @returns {import('next/router').NextRouter | null}
+ */
+export function getRouter() {
+  return _router
+}

package/src/services/sessionLog.js

@@ -0,0 +1,171 @@
+/**
+ * Session log — captures every successful save of a UI Builder or Print
+ * Builder schema while developers use the tool. The captured entries
+ * become future training data for the AI assistant.
+ *
+ * Storage:
+ *   localStorage key  rbb:sessionLogs:v1
+ *   value              JSON array of entries (newest first)
+ *
+ * Entry shape:
+ *   {
+ *     id:           string,        // unique
+ *     createdAt:    string,        // ISO timestamp
+ *     builder:      'ui' | 'print',
+ *     trigger:      string,        // 'save' | future: 'manual', 'auto'
+ *     title:        string,        // saved view title (for display only)
+ *     viewMetaData: object,        // builder-specific id/group/etc.
+ *     schema:       object,        // the actual saved schema
+ *     prompt:       string,        // empty by default — filled later by the
+ *                                  // developer to label the example for
+ *                                  // training (e.g. the natural-language
+ *                                  // instruction the schema corresponds to).
+ *     notes:        string,        // optional free-form developer notes
+ *   }
+ */
+
+const STORAGE_KEY = 'rbb:sessionLogs:v1'
+
+// ── Internal: pub/sub so the dialog re-renders on changes ────────────────────
+const listeners = new Set()
+function notify() { listeners.forEach(fn => { try { fn() } catch (_) {} }) }
+
+export function subscribe(fn) {
+  listeners.add(fn)
+  return () => listeners.delete(fn)
+}
+
+// ── Internal: read/write ─────────────────────────────────────────────────────
+function safeRead() {
+  try {
+    const raw = typeof window !== 'undefined' ? window.localStorage.getItem(STORAGE_KEY) : null
+    if (!raw) return []
+    const parsed = JSON.parse(raw)
+    return Array.isArray(parsed) ? parsed : []
+  } catch (e) {
+    console.warn('[sessionLog] failed to read storage:', e)
+    return []
+  }
+}
+
+function safeWrite(entries) {
+  try {
+    if (typeof window === 'undefined') return
+    window.localStorage.setItem(STORAGE_KEY, JSON.stringify(entries))
+    notify()
+  } catch (e) {
+    console.warn('[sessionLog] failed to write storage (likely quota):', e)
+  }
+}
+
+function uid() {
+  try { return `log_${crypto.randomUUID()}` }
+  catch { return `log_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}` }
+}
+
+// ── Public API ───────────────────────────────────────────────────────────────
+
+/**
+ * Append a new entry. Returns the created entry.
+ *
+ * @param {Object} params
+ * @param {'ui'|'print'} params.builder
+ * @param {string}      [params.trigger='save']
+ * @param {string}      [params.title='']
+ * @param {Object}      [params.viewMetaData]
+ * @param {Object}      params.schema  - the actual schema being logged
+ * @param {string}      [params.prompt='']
+ * @param {string}      [params.notes='']
+ */
+export function logSchema({
+  builder,
+  trigger = 'save',
+  title = '',
+  viewMetaData = {},
+  schema,
+  prompt = '',
+  notes = ''
+}) {
+  if (!schema) {
+    console.warn('[sessionLog] refusing to log empty schema')
+    return null
+  }
+  const entry = {
+    id:           uid(),
+    createdAt:    new Date().toISOString(),
+    builder,
+    trigger,
+    title,
+    viewMetaData,
+    // deep clone via JSON to detach from any reactive state
+    schema:       JSON.parse(JSON.stringify(schema)),
+    prompt,
+    notes
+  }
+  const next = [entry, ...safeRead()]
+  safeWrite(next)
+  return entry
+}
+
+/** All entries, newest first. */
+export function listEntries() {
+  return safeRead()
+}
+
+export function getEntry(id) {
+  return safeRead().find(e => e.id === id) ?? null
+}
+
+/** Patch an entry — typically used to fill in `prompt` / `notes`. */
+export function updateEntry(id, patch) {
+  const entries = safeRead()
+  const idx = entries.findIndex(e => e.id === id)
+  if (idx === -1) return null
+  const updated = { ...entries[idx], ...patch, id, createdAt: entries[idx].createdAt }
+  entries[idx] = updated
+  safeWrite(entries)
+  return updated
+}
+
+export function deleteEntry(id) {
+  const next = safeRead().filter(e => e.id !== id)
+  safeWrite(next)
+}
+
+export function clearAll() {
+  safeWrite([])
+}
+
+/**
+ * Trigger a JSON file download of all entries.
+ * Filename: rbb-session-logs-YYYY-MM-DD.json
+ */
+export function exportJSON() {
+  if (typeof window === 'undefined') return
+  const entries = safeRead()
+  const blob = new Blob([JSON.stringify(entries, null, 2)], { type: 'application/json' })
+  const url  = URL.createObjectURL(blob)
+  const a    = document.createElement('a')
+  const stamp = new Date().toISOString().slice(0, 10)
+  a.href     = url
+  a.download = `rbb-session-logs-${stamp}.json`
+  document.body.appendChild(a)
+  a.click()
+  document.body.removeChild(a)
+  setTimeout(() => URL.revokeObjectURL(url), 0)
+}
+
+/**
+ * Bulk import (e.g. restoring from a backup). Replaces existing entries.
+ */
+export function importJSON(json) {
+  let parsed
+  try {
+    parsed = typeof json === 'string' ? JSON.parse(json) : json
+  } catch (e) {
+    throw new Error('Invalid JSON')
+  }
+  if (!Array.isArray(parsed)) throw new Error('Expected an array of entries')
+  safeWrite(parsed)
+  return parsed.length
+}

package/src/views/ConfirmDialog.js

@@ -18,7 +18,7 @@ import {
 } from '@mui/material'
 import Box from '@mui/material/Box'
 import { Close } from 'mdi-material-ui'
-import { Warning, DeleteOutline } from '@mui/icons-material'
+import { Warning, DeleteOutlined } from '@mui/icons-material'
 import { useState } from 'react'
 
 const ConfirmDelete = props => {
@@ -111,7 +111,7 @@ const ConfirmDelete = props => {
                   mt: 2,
                   mb: 3
                 }}>
-                  <DeleteOutline
+                  <DeleteOutlined
                     sx={{
                       fontSize: 40,
                       color: '#d32f2f',