@insforge/dashboard 0.0.0-dev.1

package/dist/layout/DashboardFrame.d.ts

@@ -0,0 +1,15 @@
+import { type ReactNode } from 'react';
+export interface DashboardFrameRenderProps {
+    isSidebarCollapsed: boolean;
+    toggleSidebar: () => void;
+}
+export interface DashboardFrameProps {
+    showHeader?: boolean;
+    header?: ReactNode;
+    sidebar: (props: DashboardFrameRenderProps) => ReactNode;
+    children: ReactNode;
+    overlays?: ReactNode;
+    className?: string;
+    contentClassName?: string;
+}
+export declare function DashboardFrame({ showHeader, header, sidebar, children, overlays, className, contentClassName, }: DashboardFrameProps): import("react/jsx-runtime").JSX.Element;

package/dist/layout/DashboardOutletLayout.d.ts

@@ -0,0 +1 @@
+export declare function DashboardOutletLayout(): import("react/jsx-runtime").JSX.Element;

package/dist/layout/DashboardSectionLayout.d.ts

@@ -0,0 +1,7 @@
+import type { ReactNode } from 'react';
+export interface DashboardSectionLayoutProps {
+    sidebar?: ReactNode;
+    children: ReactNode;
+    className?: string;
+}
+export declare function DashboardSectionLayout({ sidebar, children, className, }: DashboardSectionLayoutProps): import("react/jsx-runtime").JSX.Element;

package/dist/lib/analytics/posthog.d.ts

@@ -0,0 +1,5 @@
+export declare const PostHogAnalyticsProvider: ({ children }: {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const trackPostHog: (eventName: string, properties?: Record<string, unknown>) => void;
+export declare const getFeatureFlag: (featureFlag: string) => string | boolean | undefined;

package/dist/lib/api/client.d.ts

@@ -0,0 +1,20 @@
+export declare class ApiClient {
+    private accessToken;
+    private onAuthError?;
+    private onRefreshAccessToken?;
+    private refreshPromise;
+    setAccessToken(token: string): void;
+    setCsrfToken(csrfToken: string): void;
+    clearTokens(): void;
+    getAccessToken(): string | null;
+    getCsrfToken(): string | null;
+    setAuthErrorHandler(handler?: () => void): void;
+    setRefreshAccessTokenHandler(handler?: () => Promise<boolean>): void;
+    request(endpoint: string, options?: RequestInit & {
+        returnFullResponse?: boolean;
+        skipAuth?: boolean;
+        skipRefresh?: boolean;
+    }): Promise<any>;
+    withAccessToken(headers?: Record<string, string>): Record<string, string>;
+}
+export declare const apiClient: ApiClient;

package/dist/lib/config/DashboardHostContext.d.ts

@@ -0,0 +1,3 @@
+import type { DashboardProps } from '../../types';
+export declare const DashboardHostProvider: import("react").Provider<DashboardProps | null>;
+export declare function useDashboardHost(): DashboardProps;

package/dist/lib/config/runtime.d.ts

@@ -0,0 +1,3 @@
+export declare function setDashboardBackendUrl(url: string): void;
+export declare function getDashboardBackendUrl(): string;
+export declare function getDashboardApiBaseUrl(): string;

package/dist/lib/contexts/AuthContext.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import type { UserSchema } from '@insforge/shared-schemas';
+interface AuthContextType {
+    user: UserSchema | null;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    loginWithPassword: (email: string, password: string) => Promise<boolean>;
+    loginWithAuthorizationCode: (code: string) => Promise<boolean>;
+    logout: () => Promise<void>;
+    refreshAuth: () => Promise<void>;
+    error: Error | null;
+}
+export declare const useAuth: () => AuthContextType;
+interface AuthProviderProps {
+    children: React.ReactNode;
+}
+export declare const AuthProvider: React.FC<AuthProviderProps>;
+export {};

package/dist/lib/contexts/ModalContext.d.ts

@@ -0,0 +1,2 @@
+export { DashboardModalProvider as ModalProvider, useDashboardModal as useModal, } from '../../modals/DashboardModalContext';
+export type { DashboardSettingsTab as SettingsTab } from '../../modals/DashboardModalContext';

package/dist/lib/contexts/SocketContext.d.ts

@@ -0,0 +1,42 @@
+import { ReactNode } from 'react';
+import { Socket } from 'socket.io-client';
+/**
+ * Server-to-client event types
+ */
+export declare enum ServerEvents {
+    NOTIFICATION = "notification",
+    DATA_UPDATE = "data:update",
+    MCP_CONNECTED = "mcp:connected"
+}
+export declare enum DataUpdateResourceType {
+    DATABASE = "database",
+    USERS = "users",
+    BUCKETS = "buckets",
+    FUNCTIONS = "functions",
+    REALTIME = "realtime"
+}
+export interface DatabaseResourceUpdate {
+    type: 'tables' | 'table' | 'records' | 'index' | 'trigger' | 'policy' | 'function' | 'extension';
+    name?: string;
+}
+interface SocketState {
+    isConnected: boolean;
+    connectionError: string | null;
+    socketId: string | null;
+}
+interface SocketActions {
+    connect: (token: string | null) => void;
+    disconnect: () => void;
+}
+interface SocketContextValue extends SocketState, SocketActions {
+    socket: Socket | null;
+}
+interface SocketProviderProps {
+    children: ReactNode;
+}
+/**
+ * Socket.IO Provider - Manages WebSocket connection for the entire application
+ */
+export declare function SocketProvider({ children }: SocketProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useSocket(): SocketContextValue;
+export {};

package/dist/lib/contexts/ThemeContext.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+type Theme = 'light' | 'dark' | 'system';
+type ResolvedTheme = 'light' | 'dark';
+interface ThemeContextType {
+    theme: Theme;
+    resolvedTheme: ResolvedTheme;
+    setTheme: (theme: Theme) => void;
+    toggleTheme: () => void;
+}
+interface ThemeProviderProps {
+    children: React.ReactNode;
+    forcedTheme?: ResolvedTheme;
+    storageKey?: string;
+}
+export declare function ThemeProvider({ children, forcedTheme, storageKey, }: ThemeProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useTheme(): ThemeContextType;
+export {};

package/dist/lib/hooks/useCloudProjectInfo.d.ts

@@ -0,0 +1,19 @@
+export interface CloudProjectInfo {
+    name?: string;
+    latestVersion?: string;
+    instanceType?: string;
+    region?: string;
+}
+interface UseCloudProjectInfoOptions {
+    enabled?: boolean;
+    staleTime?: number;
+    timeoutMs?: number;
+}
+export declare const CLOUD_PROJECT_INFO_QUERY_KEY: string[];
+export declare function useCloudProjectInfo(options?: UseCloudProjectInfoOptions): {
+    projectInfo: CloudProjectInfo;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<CloudProjectInfo, Error>>;
+};
+export {};

package/dist/lib/hooks/useConfirm.d.ts

@@ -0,0 +1,21 @@
+interface ConfirmOptions {
+    title: string;
+    description: string;
+    confirmText?: string;
+    cancelText?: string;
+    destructive?: boolean;
+}
+export declare function useConfirm(): {
+    confirm: (confirmOptions: ConfirmOptions) => Promise<boolean>;
+    confirmDialogProps: {
+        open: boolean;
+        onOpenChange: (open: boolean) => void;
+        title: string;
+        description: string;
+        confirmText: string | undefined;
+        cancelText: string | undefined;
+        destructive: boolean | undefined;
+        onConfirm: () => void;
+    };
+};
+export {};

package/dist/lib/hooks/useHealth.d.ts

@@ -0,0 +1,13 @@
+interface UseHealthOptions {
+    enabled?: boolean;
+    staleTime?: number;
+}
+export declare function useHealth(options?: UseHealthOptions): {
+    health: import("../services/health.service").HealthResponse | undefined;
+    version: string | undefined;
+    status: string | undefined;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("../services/health.service").HealthResponse, Error>>;
+};
+export {};

package/dist/lib/hooks/useInterval.d.ts

@@ -0,0 +1 @@
+export declare function useInterval(callback: () => void, delay: number | null): void;

package/dist/lib/hooks/useMediaQuery.d.ts

@@ -0,0 +1,6 @@
+type UseMediaQueryOptions = {
+    defaultValue?: boolean;
+    initializeWithValue?: boolean;
+};
+export declare function useMediaQuery(query: string, { defaultValue, initializeWithValue }?: UseMediaQueryOptions): boolean;
+export {};

package/dist/lib/hooks/useMetadata.d.ts

@@ -0,0 +1,239 @@
+interface UseMetadataOptions {
+    enabled?: boolean;
+    staleTime?: number;
+}
+export declare function useMetadata(options?: UseMetadataOptions): {
+    metadata: {
+        functions: {
+            status: string;
+            name: string;
+            description: string | null;
+            slug: string;
+        }[];
+        storage: {
+            totalSizeInGB: number;
+            buckets: {
+                createdAt: string;
+                name: string;
+                public: boolean;
+                objectCount?: number | undefined;
+            }[];
+        };
+        auth: {
+            requireEmailVerification: boolean;
+            passwordMinLength: number;
+            requireNumber: boolean;
+            requireLowercase: boolean;
+            requireUppercase: boolean;
+            requireSpecialChar: boolean;
+            verifyEmailMethod: "code" | "link";
+            resetPasswordMethod: "code" | "link";
+            oAuthProviders: ("google" | "github" | "discord" | "linkedin" | "facebook" | "instagram" | "tiktok" | "apple" | "x" | "spotify" | "microsoft")[];
+            customOAuthProviders: string[];
+        };
+        database: {
+            tables: {
+                tableName: string;
+                recordCount: number;
+            }[];
+            totalSizeInGB: number;
+            hint?: string | undefined;
+        };
+        realtime?: {
+            channels: {
+                id: string;
+                createdAt: string;
+                description: string | null;
+                enabled: boolean;
+                updatedAt: string;
+                pattern: string;
+                webhookUrls: string[] | null;
+            }[];
+            permissions: {
+                subscribe: {
+                    policies: {
+                        tableName: string;
+                        policyName: string;
+                        roles: string[];
+                        withCheck: string | null;
+                        command: string;
+                        using: string | null;
+                    }[];
+                };
+                publish: {
+                    policies: {
+                        tableName: string;
+                        policyName: string;
+                        roles: string[];
+                        withCheck: string | null;
+                        command: string;
+                        using: string | null;
+                    }[];
+                };
+            };
+        } | undefined;
+        aiIntegration?: {
+            models: {
+                inputModality: string[];
+                outputModality: string[];
+                modelId: string;
+            }[];
+        } | undefined;
+        version?: string | undefined;
+    } | undefined;
+    auth: {
+        requireEmailVerification: boolean;
+        passwordMinLength: number;
+        requireNumber: boolean;
+        requireLowercase: boolean;
+        requireUppercase: boolean;
+        requireSpecialChar: boolean;
+        verifyEmailMethod: "code" | "link";
+        resetPasswordMethod: "code" | "link";
+        oAuthProviders: ("google" | "github" | "discord" | "linkedin" | "facebook" | "instagram" | "tiktok" | "apple" | "x" | "spotify" | "microsoft")[];
+        customOAuthProviders: string[];
+    } | undefined;
+    tables: {
+        tableName: string;
+        recordCount: number;
+    }[] | undefined;
+    storage: {
+        totalSizeInGB: number;
+        buckets: {
+            createdAt: string;
+            name: string;
+            public: boolean;
+            objectCount?: number | undefined;
+        }[];
+    } | undefined;
+    version: string;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<{
+        functions: {
+            status: string;
+            name: string;
+            description: string | null;
+            slug: string;
+        }[];
+        storage: {
+            totalSizeInGB: number;
+            buckets: {
+                createdAt: string;
+                name: string;
+                public: boolean;
+                objectCount?: number | undefined;
+            }[];
+        };
+        auth: {
+            requireEmailVerification: boolean;
+            passwordMinLength: number;
+            requireNumber: boolean;
+            requireLowercase: boolean;
+            requireUppercase: boolean;
+            requireSpecialChar: boolean;
+            verifyEmailMethod: "code" | "link";
+            resetPasswordMethod: "code" | "link";
+            oAuthProviders: ("google" | "github" | "discord" | "linkedin" | "facebook" | "instagram" | "tiktok" | "apple" | "x" | "spotify" | "microsoft")[];
+            customOAuthProviders: string[];
+        };
+        database: {
+            tables: {
+                tableName: string;
+                recordCount: number;
+            }[];
+            totalSizeInGB: number;
+            hint?: string | undefined;
+        };
+        realtime?: {
+            channels: {
+                id: string;
+                createdAt: string;
+                description: string | null;
+                enabled: boolean;
+                updatedAt: string;
+                pattern: string;
+                webhookUrls: string[] | null;
+            }[];
+            permissions: {
+                subscribe: {
+                    policies: {
+                        tableName: string;
+                        policyName: string;
+                        roles: string[];
+                        withCheck: string | null;
+                        command: string;
+                        using: string | null;
+                    }[];
+                };
+                publish: {
+                    policies: {
+                        tableName: string;
+                        policyName: string;
+                        roles: string[];
+                        withCheck: string | null;
+                        command: string;
+                        using: string | null;
+                    }[];
+                };
+            };
+        } | undefined;
+        aiIntegration?: {
+            models: {
+                inputModality: string[];
+                outputModality: string[];
+                modelId: string;
+            }[];
+        } | undefined;
+        version?: string | undefined;
+    }, Error>>;
+};
+export declare function useApiKey(options?: UseMetadataOptions): {
+    apiKey: string | undefined;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<string, Error>>;
+};
+export declare function useProjectId(options?: UseMetadataOptions): {
+    projectId: string | null | undefined;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<string | null, Error>>;
+};
+export declare function useDatabaseConnectionString(options?: UseMetadataOptions): {
+    connectionData: {
+        parameters: {
+            user: string;
+            password: string;
+            database: string;
+            host: string;
+            port: number;
+            sslmode: string;
+        };
+        connectionURL: string;
+    } | undefined;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<{
+        parameters: {
+            user: string;
+            password: string;
+            database: string;
+            host: string;
+            port: number;
+            sslmode: string;
+        };
+        connectionURL: string;
+    }, Error>>;
+};
+export declare function useDatabasePassword(options?: UseMetadataOptions): {
+    passwordData: {
+        databasePassword: string;
+    } | undefined;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<{
+        databasePassword: string;
+    }, Error>>;
+};
+export {};

package/dist/lib/hooks/useModal.d.ts

@@ -0,0 +1 @@
+export { useModal } from '../contexts/ModalContext';

package/dist/lib/hooks/usePageSize.d.ts

@@ -0,0 +1,5 @@
+export declare function usePageSize(scope: string): {
+    pageSize: number;
+    pageSizeOptions: number[];
+    onPageSizeChange: (newPageSize: number) => void;
+};

package/dist/lib/hooks/useTimeout.d.ts

@@ -0,0 +1 @@
+export declare function useTimeout(callback: () => void, delay: number | null): void;

package/dist/lib/hooks/useToast.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+interface Toast {
+    id: string;
+    message: string;
+    type?: 'success' | 'error' | 'info' | 'warn' | 'upload';
+    customIcon?: React.ReactNode;
+    duration: number;
+    progress?: number;
+    onCancel?: () => void;
+}
+interface ToastContextType {
+    showToast: (message: string, type?: 'success' | 'error' | 'info' | 'warn' | 'upload', customIcon?: React.ReactNode, duration?: number) => string;
+    updateToast: (id: string, updates: Partial<Toast>) => void;
+    removeToast: (id: string) => void;
+}
+export declare function ToastProvider({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useToast(): ToastContextType;
+export {};

package/dist/lib/routing/AppRoutes.d.ts

@@ -0,0 +1 @@
+export declare function AppRoutes(): import("react/jsx-runtime").JSX.Element;

package/dist/lib/routing/RequireAuth.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+interface RequireAuthProps {
+    children: ReactNode;
+}
+export declare const RequireAuth: ({ children }: RequireAuthProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/lib/services/health.service.d.ts

@@ -0,0 +1,8 @@
+export interface HealthResponse {
+    version: string;
+    status?: string;
+}
+export declare class HealthService {
+    getHealth(): Promise<HealthResponse>;
+}
+export declare const healthService: HealthService;

package/dist/lib/services/metadata.service.d.ts

@@ -0,0 +1,16 @@
+import { AppMetadataSchema, DatabaseConnectionInfo, DatabasePasswordInfo } from '@insforge/shared-schemas';
+export interface RotateApiKeyResponse {
+    success: boolean;
+    message: string;
+    apiKey: string;
+    oldKeyExpiresAt: string;
+}
+export declare class MetadataService {
+    fetchApiKey(): Promise<string>;
+    fetchProjectId(): Promise<string | null>;
+    getFullMetadata(): Promise<AppMetadataSchema>;
+    getDatabaseConnectionString(): Promise<DatabaseConnectionInfo>;
+    getDatabasePassword(): Promise<DatabasePasswordInfo>;
+    rotateApiKey(gracePeriodHours?: number): Promise<RotateApiKeyResponse>;
+}
+export declare const metadataService: MetadataService;

package/dist/lib/utils/__tests__/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/utils/cloudMessaging.d.ts

@@ -0,0 +1,13 @@
+import { CloudEvent } from '@insforge/shared-schemas';
+export declare function postMessageToParent(evt: Record<string, unknown>, targetOrigin?: string): void;
+/**
+ * Parses and validates an unknown value as a CloudEvent.
+ * @param value - The value to validate
+ * @returns A discriminated union: { ok: true; data: CloudEvent } on success, { ok: false } on failure
+ */
+export declare function parseCloudEvent(value: unknown): {
+    ok: true;
+    data: CloudEvent;
+} | {
+    ok: false;
+};

package/dist/lib/utils/constants.d.ts

@@ -0,0 +1,17 @@
+export declare const BREAKPOINTS: {
+    readonly xs: 475;
+    readonly sm: 640;
+    readonly md: 768;
+    readonly lg: 1024;
+    readonly xl: 1280;
+};
+export declare const LOCAL_STORAGE_KEYS: {
+    readonly theme: "insforge-theme";
+    readonly selectedLogSource: "selectedLogSource";
+    readonly sqlEditorTabs: "sql-editor-tabs";
+    readonly sqlEditorActiveTab: "sql-editor-active-tab";
+    readonly databaseTablePreferences: "insforge.database.tables.preferences.v1";
+};
+export declare const LOCAL_STORAGE_KEY_PREFIXES: {
+    readonly pageSize: "insforge-page-size";
+};

package/dist/lib/utils/local-storage.d.ts

@@ -0,0 +1,5 @@
+export declare function getLocalStorageItem(key: string): string | null;
+export declare function setLocalStorageItem(key: string, value: string): boolean;
+export declare function removeLocalStorageItem(key: string): boolean;
+export declare function getLocalStorageJSON<T>(key: string): T | null;
+export declare function setLocalStorageJSON(key: string, value: unknown): boolean;

package/dist/lib/utils/menuItems.d.ts

@@ -0,0 +1,22 @@
+import { type LucideIcon } from 'lucide-react';
+export interface PrimaryMenuItem {
+    id: string;
+    label: string;
+    href: string;
+    icon: LucideIcon;
+    onClick?: () => void;
+    external?: boolean;
+    sectionEnd?: boolean;
+}
+/**
+ * Static menu items configuration
+ * Primary menu items appear in the app sidebar
+ */
+export declare const staticMenuItems: PrimaryMenuItem[];
+/**
+ * Bottom menu items that may be conditionally shown
+ */
+export declare const documentationMenuItem: PrimaryMenuItem;
+export declare const usageMenuItem: PrimaryMenuItem;
+export declare const settingsMenuItem: PrimaryMenuItem;
+export declare const deploymentsMenuItem: PrimaryMenuItem;

package/dist/lib/utils/schemaValidations.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export declare const uuidSchema: z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodLiteral<"">, null, "">]>, z.ZodNull]>;
+export declare const integerSchema: z.ZodCatch<z.ZodUnion<[z.ZodEffects<z.ZodString, number, string>, z.ZodNumber, z.ZodEffects<z.ZodLiteral<"">, null, "">, z.ZodNull]>>;
+export declare const floatSchema: z.ZodCatch<z.ZodUnion<[z.ZodEffects<z.ZodString, number, string>, z.ZodNumber, z.ZodEffects<z.ZodLiteral<"">, null, "">, z.ZodNull]>>;
+export declare const booleanSchema: z.ZodCatch<z.ZodUnion<[z.ZodBoolean, z.ZodEffects<z.ZodString, boolean | null, string>, z.ZodEffects<z.ZodLiteral<"">, null, "">, z.ZodNull]>>;
+export declare const dateSchema: z.ZodCatch<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodLiteral<"">, null, "">, z.ZodNull]>>;
+export declare const dateTimeSchema: z.ZodCatch<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodLiteral<"">, null, "">, z.ZodNull]>>;
+export declare const jsonSchema: z.ZodCatch<z.ZodUnion<[z.ZodEffects<z.ZodString, any, string>, z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>, z.ZodArray<z.ZodUnknown, "many">, z.ZodNull]>>;
+export declare const stringSchema: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+export declare const emailSchema: z.ZodString;
+export declare const loginFormSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    password: string;
+}, {
+    email: string;
+    password: string;
+}>;
+export type LoginForm = z.infer<typeof loginFormSchema>;