@rebasepro/plugin-insights 0.2.3 → 0.3.0

package/dist/types/src/types/user_management_delegate.d.ts

@@ -104,15 +104,17 @@ export interface UserManagementDelegate<USER extends User = User> {
      * If true, the UI will allow the user to create the default roles (admin, editor, viewer).
      */
     allowDefaultRolesCreation?: boolean;
-    /**
-     * Should collection config permissions be included?
-     */
-    includeCollectionConfigPermissions?: boolean;
     /**
      * Optionally define roles for a given user. This is useful when the roles
      * are coming from a separate provider than the one issuing the tokens.
      */
     defineRolesFor?: (user: USER) => Promise<Role[] | undefined> | Role[] | undefined;
+    /**
+     * Whether any admin users exist. Used by the bootstrap banner to decide
+     * whether to prompt.  Populated via a lightweight check (e.g. `limit=1`
+     * query) instead of loading all users.
+     */
+    hasAdminUsers?: boolean;
     /**
      * Optional function to bootstrap an admin user.
      * Often used when the database is empty.

package/dist/types/src/users/roles.d.ts

@@ -11,12 +11,4 @@ export type Role = {
      * If this flag is true, the user can perform any action
      */
     isAdmin?: boolean;
-    /**
-     * Permissions related to editing the collections
-     */
-    config?: {
-        createCollections?: boolean;
-        editCollections?: boolean | "own";
-        deleteCollections?: boolean | "own";
-    };
 };

package/dist/ui/src/components/Button.d.ts

@@ -9,6 +9,6 @@ export type ButtonProps<C extends React.ElementType = "button"> = {
     fullWidth?: boolean;
     className?: string;
     component?: C;
-    onClick?: React.MouseEventHandler<any>;
+    onClick?: React.MouseEventHandler<HTMLElement>;
 } & React.ComponentPropsWithoutRef<C>;
-export declare const Button: React.FC<ButtonProps<any>>;
+export declare const Button: React.FC<ButtonProps<React.ElementType>>;

package/dist/ui/src/components/ErrorBoundary.d.ts

@@ -1,11 +1,33 @@
 import React, { ErrorInfo, PropsWithChildren } from "react";
-export declare class ErrorBoundary extends React.Component<PropsWithChildren<Record<string, unknown>>, {
+export interface ErrorBoundaryProps {
+    /**
+     * When true, renders a full-page centered error screen instead of the
+     * compact inline error. Intended for wrapping top-level app roots or
+     * major route sections.
+     */
+    fullPage?: boolean;
+    /**
+     * Optional callback invoked when the user clicks "Try again". If provided,
+     * the boundary resets its error state and calls this handler. If omitted,
+     * the "Try again" button resets the boundary state, re-mounting children.
+     */
+    onReset?: () => void;
+}
+interface ErrorBoundaryState {
     error: Error | null;
-}> {
-    constructor(props: any);
+    showDetails: boolean;
+}
+export declare class ErrorBoundary extends React.Component<PropsWithChildren<ErrorBoundaryProps>, ErrorBoundaryState> {
+    constructor(props: PropsWithChildren<ErrorBoundaryProps>);
     static getDerivedStateFromError(error: Error): {
         error: Error;
     };
     componentDidCatch(error: Error, _errorInfo: ErrorInfo): void;
+    private handleReset;
+    private handleReload;
+    private toggleDetails;
     render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;
+    private renderInline;
+    private renderFullPage;
 }
+export {};

package/dist/ui/src/components/VirtualTable/VirtualTable.d.ts

@@ -8,4 +8,4 @@ import { VirtualTableProps } from "./VirtualTableProps";
  *
  * @group Components
  */
-export declare const VirtualTable: React.NamedExoticComponent<VirtualTableProps<any>>;
+export declare const VirtualTable: React.NamedExoticComponent<VirtualTableProps<Record<string, unknown>>>;

package/dist/ui/src/components/VirtualTable/VirtualTableCell.d.ts

@@ -4,18 +4,18 @@ type VirtualTableCellProps<T> = {
     dataKey: string;
     column: VirtualTableColumn;
     columns: VirtualTableColumn[];
-    rowData: any;
-    cellData: any;
-    rowIndex: any;
+    rowData: T;
+    cellData: unknown;
+    rowIndex: number;
     columnIndex: number;
     cellRenderer: (props: CellRendererParams<T>) => React.ReactNode;
     sortableNodeRef?: (node: HTMLElement | null) => void;
     sortableStyle?: React.CSSProperties;
-    sortableAttributes?: Record<string, any>;
+    sortableAttributes?: Record<string, unknown>;
     isDragging?: boolean;
     isDraggable?: boolean;
     frozen?: boolean;
-    extraData?: any;
+    extraData?: unknown;
 };
-export declare const VirtualTableCell: React.NamedExoticComponent<VirtualTableCellProps<any>>;
+export declare const VirtualTableCell: React.NamedExoticComponent<VirtualTableCellProps<unknown>>;
 export {};

package/dist/ui/src/components/VirtualTable/VirtualTableHeader.d.ts

@@ -2,28 +2,28 @@ import React from "react";
 import { VirtualTableColumn, VirtualTableSort, VirtualTableWhereFilterOp } from "./VirtualTableProps";
 export type FilterFormFieldProps<CustomProps> = {
     id: React.Key;
-    filterValue: [VirtualTableWhereFilterOp, any] | undefined;
-    setFilterValue: (filterValue?: [VirtualTableWhereFilterOp, any]) => void;
+    filterValue: [VirtualTableWhereFilterOp, unknown] | undefined;
+    setFilterValue: (filterValue?: [VirtualTableWhereFilterOp, unknown]) => void;
     column: VirtualTableColumn<CustomProps>;
     hidden: boolean;
     setHidden: (hidden: boolean) => void;
 };
-type VirtualTableHeaderProps<M extends Record<string, any>> = {
+type VirtualTableHeaderProps<M extends Record<string, unknown>> = {
     resizeHandleRef: React.Ref<HTMLDivElement>;
     columnIndex: number;
     isResizingIndex: number;
-    column: VirtualTableColumn<any>;
+    column: VirtualTableColumn<unknown>;
     onColumnSort: (key: Extract<keyof M, string>) => void;
-    filter?: [VirtualTableWhereFilterOp, any];
+    filter?: [VirtualTableWhereFilterOp, unknown];
     sort: VirtualTableSort;
-    onFilterUpdate: (column: VirtualTableColumn, filterForProperty?: [VirtualTableWhereFilterOp, any]) => void;
+    onFilterUpdate: (column: VirtualTableColumn, filterForProperty?: [VirtualTableWhereFilterOp, unknown]) => void;
     onClickResizeColumn?: (columnIndex: number, column: VirtualTableColumn) => void;
-    createFilterField?: (props: FilterFormFieldProps<any>) => React.ReactNode;
+    createFilterField?: (props: FilterFormFieldProps<unknown>) => React.ReactNode;
     AdditionalHeaderWidget?: (props: {
         onHover: boolean;
     }) => React.ReactNode;
     isDragging?: boolean;
     isDraggable?: boolean;
 };
-export declare const VirtualTableHeader: React.FunctionComponent<VirtualTableHeaderProps<any>>;
+export declare const VirtualTableHeader: React.FunctionComponent<VirtualTableHeaderProps<Record<string, unknown>>>;
 export {};

package/dist/ui/src/components/VirtualTable/VirtualTableHeaderRow.d.ts

@@ -1,2 +1,2 @@
 import { VirtualTableContextProps } from "./types";
-export declare const VirtualTableHeaderRow: ({ columns, currentSort, onColumnSort, onFilterUpdate, sortByProperty, filter, onColumnResize, onColumnResizeEnd, createFilterField, AddColumnComponent, onColumnsOrderChange, data, cellRenderer: CellRenderer, rowHeight, draggingColumnId, headerHeight }: VirtualTableContextProps<any>) => import("react/jsx-runtime").JSX.Element;
+export declare const VirtualTableHeaderRow: ({ columns, currentSort, onColumnSort, onFilterUpdate, sortByProperty, filter, onColumnResize, onColumnResizeEnd, createFilterField, AddColumnComponent, onColumnsOrderChange, data, cellRenderer: CellRenderer, rowHeight, draggingColumnId, headerHeight }: VirtualTableContextProps<Record<string, unknown>>) => import("react/jsx-runtime").JSX.Element;

package/dist/ui/src/components/VirtualTable/VirtualTableProps.d.ts

@@ -1,6 +1,6 @@
 import React from "react";
 import { FilterFormFieldProps } from "./VirtualTableHeader";
-export type OnRowClickParams<T extends Record<string, any>> = {
+export type OnRowClickParams<T extends Record<string, unknown>> = {
     rowData: T;
     rowIndex: number;
     event: React.SyntheticEvent;
@@ -9,7 +9,7 @@ export type OnRowClickParams<T extends Record<string, any>> = {
  * @see Table
  * @group Components
  */
-export interface VirtualTableProps<T extends Record<string, any>> {
+export interface VirtualTableProps<T extends Record<string, unknown>> {
     /**
      * Array of arbitrary data
      */
@@ -61,12 +61,12 @@ export interface VirtualTableProps<T extends Record<string, any>> {
     /**
      * In case this table should have some filters set by default
      */
-    filter?: VirtualTableFilterValues<any>;
+    filter?: VirtualTableFilterValues<string>;
     /**
      * Callback used when filters are updated
      * @param filter
      */
-    onFilterUpdate?: (filter?: VirtualTableFilterValues<any> | undefined) => void;
+    onFilterUpdate?: (filter?: VirtualTableFilterValues<string> | undefined) => void;
     /**
      * Callback when the table is scrolled
      * @param props
@@ -111,7 +111,7 @@ export interface VirtualTableProps<T extends Record<string, any>> {
      * Callback to create a filter field, displayed in the header as a dropdown
      * @param props
      */
-    createFilterField?: (props: FilterFormFieldProps<any>) => React.ReactNode;
+    createFilterField?: (props: FilterFormFieldProps<unknown>) => React.ReactNode;
     /**
      * Class name applied to the table
      */
@@ -141,9 +141,9 @@ export interface VirtualTableProps<T extends Record<string, any>> {
     /**
      * Extra data passed to the cell renderer
      */
-    extraData?: any;
+    extraData?: unknown;
 }
-export type CellRendererParams<T = any> = {
+export type CellRendererParams<T = unknown> = {
     column: VirtualTableColumn;
     columns: VirtualTableColumn[];
     columnIndex: number;
@@ -153,17 +153,17 @@ export type CellRendererParams<T = any> = {
     isScrolling?: boolean;
     sortableNodeRef?: (node: HTMLElement | null) => void;
     sortableStyle?: React.CSSProperties;
-    sortableAttributes?: Record<string, any>;
+    sortableAttributes?: Record<string, unknown>;
     isDragging?: boolean;
     isDraggable?: boolean;
     frozen?: boolean;
-    extraData?: any;
+    extraData?: unknown;
 };
 /**
  * @see Table
  * @group Components
  */
-export interface VirtualTableColumn<CustomProps = any> {
+export interface VirtualTableColumn<CustomProps = unknown> {
     /**
      * Data key for the cell value, could be "a.b.c"
      */
@@ -233,7 +233,7 @@ export type VirtualTableSort = "asc" | "desc" | undefined;
  * @see Table
  * @group Components
  */
-export type VirtualTableFilterValues<Key extends string> = Partial<Record<Key, [VirtualTableWhereFilterOp, any]>>;
+export type VirtualTableFilterValues<Key extends string> = Partial<Record<Key, [VirtualTableWhereFilterOp, unknown]>>;
 /**
  * Filter conditions in a `Query.where()` clause are specified using the
  * strings `<`, `<=`, `==`, `>=`, `>`, `array-contains`, `in`, and `array-contains-any`.

package/dist/ui/src/components/VirtualTable/VirtualTableRow.d.ts

@@ -1,3 +1,3 @@
 import React from "react";
 import { VirtualTableRowProps } from "./types";
-export declare const VirtualTableRow: React.NamedExoticComponent<VirtualTableRowProps<any>>;
+export declare const VirtualTableRow: React.NamedExoticComponent<VirtualTableRowProps<Record<string, unknown>>>;

package/dist/ui/src/components/VirtualTable/types.d.ts

@@ -1,12 +1,12 @@
 import React from "react";
 import { CellRendererParams, OnRowClickParams, OnVirtualTableColumnResizeParams, VirtualTableColumn, VirtualTableFilterValues, VirtualTableWhereFilterOp } from "./VirtualTableProps";
 import { FilterFormFieldProps } from "./VirtualTableHeader";
-export type VirtualTableRowProps<T> = {
-    style: any;
+export type VirtualTableRowProps<T extends Record<string, unknown>> = {
+    style: React.CSSProperties;
     rowHeight: number;
     rowData: T;
     rowIndex: number;
-    onRowClick?: (props: OnRowClickParams<any>) => void;
+    onRowClick?: (props: OnRowClickParams<Record<string, unknown>>) => void;
     children: React.ReactNode[];
     columns: VirtualTableColumn[];
     hoverRow?: boolean;
@@ -19,20 +19,20 @@ export type VirtualTableContextProps<T> = {
     columns: VirtualTableColumn[];
     cellRenderer: React.ComponentType<CellRendererParams<T>>;
     currentSort: "asc" | "desc" | undefined;
-    filter?: VirtualTableFilterValues<any>;
-    onRowClick?: (props: OnRowClickParams<any>) => void;
-    onColumnSort: (key: string) => any;
+    filter?: VirtualTableFilterValues<string>;
+    onRowClick?: (props: OnRowClickParams<Record<string, unknown>>) => void;
+    onColumnSort: (key: string) => void;
     onColumnResize: (params: OnVirtualTableColumnResizeParams) => void;
     onColumnResizeEnd: (params: OnVirtualTableColumnResizeParams) => void;
-    onFilterUpdate: (column: VirtualTableColumn, filterForProperty?: [VirtualTableWhereFilterOp, any]) => void;
+    onFilterUpdate: (column: VirtualTableColumn, filterForProperty?: [VirtualTableWhereFilterOp, unknown]) => void;
     sortByProperty?: string;
     customView?: React.ReactNode;
     hoverRow: boolean;
-    createFilterField?: (props: FilterFormFieldProps<any>) => React.ReactNode;
+    createFilterField?: (props: FilterFormFieldProps<unknown>) => React.ReactNode;
     rowClassName?: (rowData: T) => string | undefined;
     endAdornment?: React.ReactNode;
     AddColumnComponent?: React.ComponentType;
     onColumnsOrderChange?: (columns: VirtualTableColumn[]) => void;
     draggingColumnId?: string | null;
-    extraData?: Record<string, any>;
+    extraData?: unknown;
 };

package/dist/ui/src/hooks/useDebounceCallback.d.ts

@@ -1 +1 @@
-export declare function useDebounceCallback<T extends (...args: any[]) => any>(callback?: T, delay?: number): T;
+export declare function useDebounceCallback<T extends (...args: any[]) => unknown>(callback?: T, delay?: number): T;

package/dist/ui/src/util/debounce.d.ts

@@ -1,7 +1,7 @@
 /**
  * @ignore
  */
-export declare function debounce<T extends (...args: any[]) => any>(func: T, wait?: number): T & Cancelable;
+export declare function debounce<T extends (...args: any[]) => unknown>(func: T, wait?: number): T & Cancelable;
 /**
  * @ignore
  */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/plugin-insights",
   "type": "module",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "main": "./dist/index.umd.js",
   "module": "./dist/index.es.js",
   "types": "./dist/index.d.ts",
@@ -16,8 +16,9 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@rebasepro/core": "0.2.3",
-    "@rebasepro/types": "0.2.3"
+    "@rebasepro/core": "0.3.0",
+    "@rebasepro/ui": "0.3.0",
+    "@rebasepro/types": "0.3.0"
   },
   "peerDependencies": {
     "react": ">=19.0.0",

package/src/engine/InsightsCache.test.ts

@@ -0,0 +1,56 @@
+import { InsightsCache } from "./InsightsCache";
+import type { InsightDataResult } from "../types";
+
+describe("InsightsCache", () => {
+    it("should set and get values from cache", () => {
+        const cache = new InsightsCache();
+        const data: InsightDataResult = {
+            data: [{ count: 10 }],
+            columns: ["count"]
+        };
+        cache.set("query_key", data);
+        expect(cache.get("query_key")).toEqual(data);
+    });
+
+    it("should return null for expired keys", () => {
+        const cache = new InsightsCache(-1); // -1ms TTL to force immediate expiry
+        const data: InsightDataResult = {
+            data: [{ count: 10 }],
+            columns: ["count"]
+        };
+        cache.set("query_key", data);
+        // Expired immediately
+        expect(cache.get("query_key")).toBeNull();
+    });
+
+    it("should manage inflight requests", () => {
+        const cache = new InsightsCache();
+        const promise = Promise.resolve({
+            data: [],
+            columns: []
+        });
+        expect(cache.getInflight("query_key")).toBeNull();
+        
+        cache.setInflight("query_key", promise);
+        expect(cache.getInflight("query_key")).toBe(promise);
+
+        // Setting a result should remove the inflight reference
+        const data: InsightDataResult = { data: [], columns: [] };
+        cache.set("query_key", data);
+        expect(cache.getInflight("query_key")).toBeNull();
+    });
+
+    it("should invalidate entries", () => {
+        const cache = new InsightsCache();
+        const data: InsightDataResult = { data: [], columns: [] };
+        cache.set("key_1", data);
+        cache.set("key_2", data);
+
+        cache.invalidate("key_1");
+        expect(cache.get("key_1")).toBeNull();
+        expect(cache.get("key_2")).toEqual(data);
+
+        cache.invalidate();
+        expect(cache.get("key_2")).toBeNull();
+    });
+});

package/src/engine/useInsightsData.ts

@@ -83,6 +83,7 @@ export function useInsightsData(
                 }
             })
             .catch((err) => {
+                cache.invalidate(cacheKey);
                 if (!cancelled) {
                     setError(err instanceof Error ? err : new Error(String(err)));
                 }

package/dist/core/src/hooks/useValidateAuthenticator.d.ts

@@ -1,21 +0,0 @@
-import { AuthController, Authenticator, RebaseData, StorageSource, User } from "@rebasepro/types";
-/**
- * This hook is used internally for validating an authenticator.
- *
- * @param authController
- * @param authentication
- * @param storageSource
- * @param data
- */
-export declare function useValidateAuthenticator<USER extends User = any>({ disabled, authController, authenticator, storageSource, data }: {
-    disabled?: boolean;
-    authController: AuthController<USER>;
-    authenticator?: boolean | Authenticator<USER>;
-    data: RebaseData;
-    storageSource: StorageSource;
-}): {
-    canAccessMainView: boolean;
-    authLoading: boolean;
-    notAllowedError: any;
-    authVerified: boolean;
-};

package/dist/core/src/util/icon_synonyms.d.ts

@@ -1 +0,0 @@
-export declare const iconSynonyms: Record<string, string>;

package/dist/core/src/util/useTraceUpdate.d.ts

@@ -1,2 +0,0 @@
-export declare function printChanged(props: any, prev: any, path?: string | undefined, depth?: number | undefined, maxDepth?: number | undefined): void;
-export declare function useTraceUpdate(props: any, maxDepth?: number): void;