@airoom/nextmin-react 1.4.6 → 2.0.2

package/dist/components/viewer/DynamicViewer.js

@@ -1,6 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from 'react';
+import DOMPurify from 'dompurify';
 import { formatCell } from '../../views/list/formatters';
 import { summarizeObject } from '../../views/list/jsonSummary';
 // Hide technical keys in the viewer
@@ -32,6 +33,7 @@ function isPasswordByAttr(attr) {
 }
 // --- small helpers (duplicated minimal logic from table) ---
 const IMG_EXT_RE = /(png|jpe?g|gif|webp|bmp|svg|avif|heic|heif)$/i;
+const HTML_TAG_RE = /<([a-z1-6]+)(?:\s+[^>]*?)?>[\s\S]*?<\/\1>|<[a-z1-6]+(?:\s+[^>]*?)?\s*\/>|&[a-z0-9#]+;/i;
 function isUrlLike(s) {
     return /^https?:\/\//i.test(s) || s.startsWith('/') || s.startsWith('data:');
 }
@@ -118,6 +120,34 @@ function formatDateTimeLocal(d) {
         return d.toString();
     }
 }
+/** Detect HH:mm or HH:mm:ss and format to localized time */
+function formatTimeLocal(val) {
+    if (typeof val !== 'string')
+        return null;
+    const s = val.trim();
+    // Match HH:mm or HH:mm:ss (24h format)
+    const timeMatch = s.match(/^(\d{1,2}):(\d{2})(?::(\d{2}))?$/);
+    if (!timeMatch)
+        return null;
+    try {
+        const hours = parseInt(timeMatch[1], 10);
+        const minutes = parseInt(timeMatch[2], 10);
+        const seconds = timeMatch[3] ? parseInt(timeMatch[3], 10) : 0;
+        if (hours < 0 || hours > 23 || minutes < 0 || minutes > 59 || seconds < 0 || seconds > 59) {
+            return null;
+        }
+        const d = new Date();
+        d.setHours(hours, minutes, seconds);
+        return d.toLocaleTimeString(undefined, {
+            hour: '2-digit',
+            minute: '2-digit',
+            hour12: true,
+        });
+    }
+    catch {
+        return null;
+    }
+}
 function isPrivate(attr) {
     const a = (Array.isArray(attr) ? attr[0] : attr);
     return !!a?.private;
@@ -152,12 +182,23 @@ function toLabel(v) {
     }
     return null;
 }
+function isBadLabel(s) {
+    if (!s)
+        return true;
+    if (s.length > 50)
+        return true;
+    if (s.startsWith('http'))
+        return true;
+    if (/^[a-fA-F0-9]{24}$/.test(s))
+        return true;
+    return false;
+}
 function listLabels(arr) {
     if (!Array.isArray(arr))
         return null;
     const labels = arr
         .map((it) => toLabel(it))
-        .filter((s) => !!s && !!s.trim());
+        .filter((s) => !!s && !!s.trim() && !isBadLabel(s));
     return labels.length ? labels : null;
 }
 function summarizeList(labels, max = 10) {
@@ -210,10 +251,17 @@ function maybeParseJson(val) {
         return val;
     }
 }
-function renderValue(input, key) {
+function renderValue(input, key, attr) {
     const val = maybeParseJson(input);
     if (val == null)
         return _jsx("span", { className: "text-foreground/50", children: "\u2014" });
+    // Detect rich text (explicit or heuristic)
+    const a = Array.isArray(attr) ? attr[0] : attr;
+    const isRich = a?.rich === true;
+    const looksLikeHtml = typeof val === 'string' && HTML_TAG_RE.test(val);
+    if ((isRich || looksLikeHtml) && typeof val === 'string' && val.length > 3) {
+        return (_jsx("div", { className: "prose prose-sm max-w-none dark:prose-invert", dangerouslySetInnerHTML: { __html: DOMPurify.sanitize(val) } }));
+    }
     // Only parse dates for known date fields (createdAt, updatedAt, deletedAt)
     if (isDateField(key)) {
         const d = tryParseDate(val);
@@ -222,38 +270,51 @@ function renderValue(input, key) {
             return (_jsx("time", { dateTime: iso, title: iso, className: "whitespace-pre-wrap", children: formatDateTimeLocal(d) }));
         }
     }
+    // Detect and format plain time strings (e.g. "14:00" -> "2:00 PM")
+    const localizedTime = formatTimeLocal(val);
+    if (localizedTime)
+        return _jsx("span", { children: localizedTime });
     // Detect images
     const urls = extractAllImageUrls(val);
     if (urls.length)
         return _jsx(ImageThumbs, { urls: urls });
     // Primitive or simple object/array formatting via shared formatter
     if (Array.isArray(val)) {
+        const head = Array.isArray(attr) ? attr[0] : attr;
+        const showKey = head?.show;
         // Prefer shared summarizer for arrays
         if (val.length && typeof val[0] === 'object') {
             // Show each summarized object on its own line for readability
             const lines = val
-                .map((v) => (v && typeof v === 'object' ? summarizeObject(v)?.text : null))
+                .map((v) => (v && typeof v === 'object' ? summarizeObject(v, showKey)?.text : null))
                 .filter((s) => !!s && !!s.trim());
             if (lines.length) {
                 return (_jsx("div", { className: "grid gap-1", children: lines.map((s, i) => (_jsx("div", { className: "text-foreground/90", children: s }, i))) }));
             }
         }
         // Fallback detailed rendering
-        return (_jsx("div", { className: "grid gap-2", children: val.map((v, i) => (_jsx("div", { className: "rounded-medium border border-default-100 p-2", children: typeof v === 'object' && v !== null ? (_jsx(ObjectView, { obj: v })) : (_jsx("span", { children: formatCell(v, key) })) }, i))) }));
+        return (_jsx("div", { className: "grid gap-2", children: val.map((v, i) => {
+                const head = Array.isArray(attr) ? attr[0] : attr;
+                const subAttributes = head?.attributes;
+                const subShowKey = head?.show;
+                return (_jsx("div", { className: "rounded-medium border border-default-100 p-2", children: typeof v === 'object' && v !== null ? (_jsx(ObjectView, { obj: v, attributes: subAttributes, showKey: subShowKey })) : (_jsx("span", { children: formatCell(v, key) })) }, i));
+            }) }));
     }
     if (typeof val === 'object') {
-        const condensed = summarizeObject(val)?.text || tryCondenseEntity(val);
+        const showKey = (Array.isArray(attr) ? attr[0] : attr)?.show;
+        const condensed = summarizeObject(val, showKey)?.text || tryCondenseEntity(val);
         if (condensed)
             return _jsx("span", { children: condensed });
-        return _jsx(ObjectView, { obj: val });
+        const head = Array.isArray(attr) ? attr[0] : attr;
+        return _jsx(ObjectView, { obj: val, attributes: head?.attributes, showKey: showKey });
     }
     return _jsx("span", { children: formatCell(val, key) });
 }
-function ObjectView({ obj }) {
+function ObjectView({ obj, attributes, showKey }) {
     const entries = Object.entries(obj).filter(([k]) => !HIDDEN_KEYS.has(k) && !isPasswordKeyRaw(k));
     if (!entries.length)
         return _jsx("span", { className: "text-foreground/50", children: '{ }' });
-    return (_jsx("div", { className: "grid gap-1", children: entries.map(([k, v]) => (_jsxs("div", { className: "flex gap-2 items-start", children: [_jsxs("div", { className: "min-w-24 text-foreground/60 text-sm", children: [humanizeLabel(k), ":"] }), _jsx("div", { className: "flex-1", children: renderValue(v, k) })] }, k))) }));
+    return (_jsx("div", { className: "grid gap-1", children: entries.map(([k, v]) => (_jsxs("div", { className: "flex gap-2 items-start", children: [_jsxs("div", { className: "min-w-24 text-foreground/60 text-sm", children: [humanizeLabel(k), ":"] }), _jsx("div", { className: "flex-1", children: renderValue(v, k, attributes?.[k]) })] }, k))) }));
 }
 export function DynamicViewer({ schema, data }) {
     // Use schema order if available, otherwise object keys order
@@ -270,5 +331,5 @@ export function DynamicViewer({ schema, data }) {
             return base;
         return Object.keys(data || {}).filter((k) => !HIDDEN_KEYS.has(k) && !isPasswordKeyRaw(k));
     }, [attributes, data]);
-    return (_jsx("div", { className: "grid gap-1", children: keys.map((key) => (_jsx(FieldRow, { label: humanizeLabel(key), children: renderValue(data?.[key], key) }, key))) }));
+    return (_jsx("div", { className: "grid gap-1", children: keys.map((key) => (_jsx(FieldRow, { label: humanizeLabel(key), children: renderValue(data?.[key], key, attributes[key]) }, key))) }));
 }

package/dist/hooks/useRealtime.d.ts

@@ -0,0 +1,8 @@
+export interface RealtimeEvent {
+    event: string;
+    payload: any;
+}
+export declare function useRealtime(): {
+    isConnected: boolean;
+    lastEvent: RealtimeEvent | null;
+};

package/dist/hooks/useRealtime.js

@@ -0,0 +1,30 @@
+'use client';
+import { useEffect, useState } from 'react';
+import { RealtimeClient } from '../lib/RealtimeClient';
+export function useRealtime() {
+    const [isConnected, setIsConnected] = useState(false);
+    const [lastEvent, setLastEvent] = useState(null);
+    useEffect(() => {
+        const rt = RealtimeClient.getInstance();
+        // Check initial connection
+        setIsConnected(Boolean(rt.socket?.connected));
+        const onConnect = () => setIsConnected(true);
+        const onDisconnect = () => setIsConnected(false);
+        const handleAnyEvent = (event, payload) => {
+            setLastEvent({ event, payload });
+        };
+        const onAnyEvent = (event, ...args) => {
+            // We only care about events with a payload (usually args[0])
+            setLastEvent({ event, payload: args[0] });
+        };
+        rt.on('connect', onConnect);
+        rt.on('disconnect', onDisconnect);
+        rt.onAny(onAnyEvent);
+        return () => {
+            rt.off('connect', onConnect);
+            rt.off('disconnect', onDisconnect);
+            rt.offAny(onAnyEvent);
+        };
+    }, []);
+    return { isConnected, lastEvent };
+}

package/dist/index.d.ts

@@ -1,2 +1,8 @@
 export * from './providers/NextMinProvider';
 export * from './components/AdminApp';
+export * from './components/ArchitectureDemo';
+export * from './hooks/useRealtime';
+export * from './lib/QueryBuilder';
+export * from './lib/AuthClient';
+export * from './lib/RealtimeClient';
+export * from './lib/api';

package/dist/index.js

@@ -1,2 +1,8 @@
 export * from './providers/NextMinProvider';
 export * from './components/AdminApp';
+export * from './components/ArchitectureDemo';
+export * from './hooks/useRealtime';
+export * from './lib/QueryBuilder';
+export * from './lib/AuthClient';
+export * from './lib/RealtimeClient';
+export * from './lib/api';

package/dist/lib/AuthClient.d.ts

@@ -0,0 +1,15 @@
+export declare class AuthClient {
+    private static STORAGE_KEY_TOKEN;
+    private static STORAGE_KEY_USER;
+    private static baseURL;
+    private static apiKey;
+    static setBaseURL(url: string): void;
+    static getBaseURL(): string;
+    static setApiKey(key: string): void;
+    static getApiKey(): string;
+    static getToken(): string | null;
+    static getUser(): any | null;
+    static setSession(token: string, user: any): void;
+    static clearSession(): void;
+    static isValidToken(token: string | null): boolean;
+}

package/dist/lib/AuthClient.js

@@ -0,0 +1,63 @@
+export class AuthClient {
+    static setBaseURL(url) {
+        this.baseURL = url;
+    }
+    static getBaseURL() {
+        return this.baseURL;
+    }
+    static setApiKey(key) {
+        this.apiKey = key;
+    }
+    static getApiKey() {
+        return this.apiKey;
+    }
+    static getToken() {
+        if (typeof window === 'undefined')
+            return null;
+        return localStorage.getItem(this.STORAGE_KEY_TOKEN);
+    }
+    static getUser() {
+        if (typeof window === 'undefined')
+            return null;
+        const user = localStorage.getItem(this.STORAGE_KEY_USER);
+        try {
+            return user ? JSON.parse(user) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    static setSession(token, user) {
+        if (typeof window === 'undefined')
+            return;
+        localStorage.setItem(this.STORAGE_KEY_TOKEN, token);
+        localStorage.setItem(this.STORAGE_KEY_USER, JSON.stringify(user));
+    }
+    static clearSession() {
+        if (typeof window === 'undefined')
+            return;
+        localStorage.removeItem(this.STORAGE_KEY_TOKEN);
+        localStorage.removeItem(this.STORAGE_KEY_USER);
+    }
+    static isValidToken(token) {
+        if (!token)
+            return false;
+        const parts = token.split('.');
+        if (parts.length !== 3)
+            return true; // non-JWT token
+        try {
+            const payload = JSON.parse(atob(parts[1].replace(/-/g, '+').replace(/_/g, '/')));
+            if (typeof payload?.exp === 'number') {
+                return payload.exp * 1000 > Date.now();
+            }
+            return true;
+        }
+        catch {
+            return true;
+        }
+    }
+}
+AuthClient.STORAGE_KEY_TOKEN = 'nextmin.token';
+AuthClient.STORAGE_KEY_USER = 'nextmin.user';
+AuthClient.baseURL = '/api';
+AuthClient.apiKey = '';

package/dist/lib/QueryBuilder.d.ts

@@ -0,0 +1,29 @@
+export type FilterOperator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'nin' | 'contains' | 'startsWith' | 'endsWith';
+export interface Filter {
+    field: string;
+    operator: FilterOperator;
+    value: any;
+}
+export interface QueryOptions {
+    where?: Record<string, any> | Filter[];
+    sort?: string;
+    sortType?: string;
+    page?: number;
+    limit?: number;
+    fields?: string[];
+    q?: string;
+    searchKeys?: string;
+}
+/**
+ * QueryBuilder helps construct complex filter queries for the NextMin API.
+ */
+export declare class QueryBuilder {
+    private options;
+    where(field: string, operator: FilterOperator, value: any): QueryBuilder;
+    orWhere(field: string, operator: FilterOperator, value: any): QueryBuilder;
+    sort(field: string, direction?: 'asc' | 'desc'): QueryBuilder;
+    page(page: number, limit?: number): QueryBuilder;
+    limit(limit: number): QueryBuilder;
+    search(q: string, keys?: string[]): QueryBuilder;
+    build(): Record<string, string>;
+}

package/dist/lib/QueryBuilder.js

@@ -0,0 +1,74 @@
+/**
+ * QueryBuilder helps construct complex filter queries for the NextMin API.
+ */
+export class QueryBuilder {
+    constructor() {
+        this.options = {};
+    }
+    where(field, operator, value) {
+        if (!this.options.where)
+            this.options.where = {};
+        const map = {
+            eq: '$eq', ne: '$ne', gt: '$gt', gte: '$gte', lt: '$lt', lte: '$lte',
+            in: '$in', nin: '$nin', contains: '$regex', startsWith: '$regex', endsWith: '$regex'
+        };
+        let actualValue = value;
+        if (operator === 'contains')
+            actualValue = { $regex: value, $options: 'i' };
+        else if (operator === 'startsWith')
+            actualValue = { $regex: `^${value}`, $options: 'i' };
+        else if (operator === 'endsWith')
+            actualValue = { $regex: `${value}$`, $options: 'i' };
+        else
+            actualValue = { [map[operator]]: value };
+        this.options.where[field] = actualValue;
+        return this;
+    }
+    orWhere(field, operator, value) {
+        if (!this.options.where)
+            this.options.where = {};
+        // This is a simplified OR for the pilot. Complex nested ORs would need a different IR.
+        const currentWhere = this.options.where;
+        const newCondition = this.where(field, operator, value).options.where;
+        this.options.where = { $or: [currentWhere, newCondition] };
+        return this;
+    }
+    sort(field, direction = 'asc') {
+        this.options.sort = field;
+        this.options.sortType = direction;
+        return this;
+    }
+    page(page, limit = 10) {
+        this.options.page = page;
+        this.options.limit = limit;
+        return this;
+    }
+    limit(limit) {
+        this.options.limit = limit;
+        return this;
+    }
+    search(q, keys) {
+        this.options.q = q;
+        if (keys)
+            this.options.searchKeys = keys.join(',');
+        return this;
+    }
+    build() {
+        const params = {};
+        if (this.options.where)
+            params.where = JSON.stringify(this.options.where);
+        if (this.options.sort)
+            params.sort = this.options.sort;
+        if (this.options.sortType)
+            params.sortType = this.options.sortType;
+        if (this.options.page !== undefined)
+            params.page = String(this.options.page);
+        if (this.options.limit !== undefined)
+            params.limit = String(this.options.limit);
+        if (this.options.q)
+            params.q = this.options.q;
+        if (this.options.searchKeys)
+            params.searchKeys = this.options.searchKeys;
+        return params;
+    }
+}

package/dist/lib/RealtimeClient.d.ts

@@ -0,0 +1,16 @@
+export declare class RealtimeClient {
+    private socket;
+    private static instance;
+    private baseURL;
+    apiKey: string;
+    private constructor();
+    static getInstance(): RealtimeClient;
+    setBaseURL(url: string): void;
+    setApiKey(key: string): void;
+    connect(): void;
+    on(event: string, callback: (data: any) => void): void;
+    onAny(callback: (event: string, ...args: any[]) => void): void;
+    off(event: string, callback: (data: any) => void): void;
+    offAny(callback: (event: string, ...args: any[]) => void): void;
+    disconnect(): void;
+}

package/dist/lib/RealtimeClient.js

@@ -0,0 +1,56 @@
+import { io } from 'socket.io-client';
+import { AuthClient } from './AuthClient';
+const RAW_API = process.env.NEXT_PUBLIC_NEXTMIN_API_URL ?? 'http://localhost:8081';
+const SOCKET_URL = RAW_API.replace('/rest', ''); // Assume socket is at root or similar path
+export class RealtimeClient {
+    constructor() {
+        this.socket = null;
+        this.baseURL = RAW_API.replace('/rest', '');
+        this.apiKey = process.env.NEXT_PUBLIC_NEXTMIN_API_KEY ?? '';
+    }
+    static getInstance() {
+        if (!RealtimeClient.instance) {
+            RealtimeClient.instance = new RealtimeClient();
+        }
+        return RealtimeClient.instance;
+    }
+    setBaseURL(url) {
+        this.baseURL = url;
+    }
+    setApiKey(key) {
+        this.apiKey = key;
+    }
+    connect() {
+        if (this.socket?.connected)
+            return;
+        this.socket = io(`${this.baseURL}/realtime`, {
+            path: '/__nextmin__/realtime',
+            auth: {
+                apiKey: this.apiKey,
+                token: AuthClient.getToken()
+            }
+        });
+        this.socket.on('connect', () => {
+            console.log('[NextMin] Realtime connected');
+        });
+        this.socket.on('connect_error', (err) => {
+            console.warn('[NextMin] Realtime connection error:', err.message);
+        });
+    }
+    on(event, callback) {
+        this.socket?.on(event, callback);
+    }
+    onAny(callback) {
+        this.socket?.onAny(callback);
+    }
+    off(event, callback) {
+        this.socket?.off(event, callback);
+    }
+    offAny(callback) {
+        this.socket?.offAny(callback);
+    }
+    disconnect() {
+        this.socket?.disconnect();
+        this.socket = null;
+    }
+}

package/dist/lib/api.d.ts

@@ -1,18 +1,29 @@
 import { ApiItemResponse, ApiListResponse } from './types';
+import { QueryOptions } from './QueryBuilder';
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
 export declare class ApiError extends Error {
     status: number;
     info?: unknown;
     constructor(message: string, status: number, info?: unknown);
 }
-export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+export declare class NextMinClient {
+    private baseURL;
+    private apiKey;
+    constructor(options?: {
+        baseURL?: string;
+        apiKey?: string;
+    });
+    request<T>(path: string, opts?: FetchOpts): Promise<T>;
+}
+declare function request<T>(path: string, opts?: FetchOpts): Promise<T>;
 type FetchOpts = {
     method?: HttpMethod;
     body?: unknown;
     token?: string | null;
     json?: boolean;
     auth?: boolean;
+    query?: Record<string, string>;
 };
-declare function request<T>(path: string, opts?: FetchOpts): Promise<T>;
 export type ListParams = {
     q?: string;
     searchKey?: string;
@@ -22,7 +33,8 @@ export type ListParams = {
 };
 export declare const api: {
     getSchemas: () => Promise<unknown>;
-    list: <T>(modelName: string, page?: number, limit?: number, params?: ListParams) => Promise<ApiListResponse<T>>;
+    cleanup: () => Promise<unknown>;
+    list: <T>(modelName: string, options?: QueryOptions) => Promise<ApiListResponse<T>>;
     get: <T>(modelName: string, id: string) => Promise<ApiItemResponse<T>>;
     create: <T>(modelName: string, data: unknown) => Promise<ApiItemResponse<T>>;
     update: <T>(modelName: string, id: string, data: unknown) => Promise<ApiItemResponse<T>>;

package/dist/lib/api.js

@@ -1,9 +1,6 @@
-const RAW_API = process.env.NEXT_PUBLIC_NEXTMIN_API_URL ?? 'http://localhost:8081/rest';
-const API_KEY = process.env.NEXT_PUBLIC_NEXTMIN_API_KEY ?? '';
-function normalizeBase(base) {
-    return base.replace(/\/+$/, '');
-}
-const API_BASE = normalizeBase(RAW_API);
+import { AuthClient } from './AuthClient';
+import { QueryBuilder } from './QueryBuilder';
+const normalizeBase = (base) => base.replace(/\/+$/, '');
 export class ApiError extends Error {
     constructor(message, status, info) {
         super(message);
@@ -12,63 +9,56 @@ export class ApiError extends Error {
         this.info = info;
     }
 }
-function tokenFromStorage() {
-    try {
-        if (typeof window === 'undefined')
-            return null;
-        return localStorage.getItem('nextmin.token');
+export class NextMinClient {
+    constructor(options = {}) {
+        this.baseURL = options.baseURL ? normalizeBase(options.baseURL) : normalizeBase(AuthClient.getBaseURL());
+        this.apiKey = options.apiKey ?? AuthClient.getApiKey();
     }
-    catch {
-        return null;
+    async request(path, opts = {}) {
+        const { method = 'GET', body, token, json = true, auth = true, query } = opts;
+        const headers = { 'x-api-key': this.apiKey || AuthClient.getApiKey() };
+        const isForm = typeof FormData !== 'undefined' && body instanceof FormData;
+        if (json && !isForm)
+            headers['Content-Type'] = 'application/json';
+        const bearer = token ?? AuthClient.getToken();
+        if (auth && bearer)
+            headers.Authorization = `Bearer ${bearer}`;
+        const queryString = query ? qs(query) : '';
+        const url = `${this.baseURL || normalizeBase(AuthClient.getBaseURL())}${path}${queryString}`;
+        let res;
+        try {
+            res = await fetch(url, {
+                method,
+                headers,
+                body: body && json && !isForm ? JSON.stringify(body) : body,
+            });
+        }
+        catch (networkErr) {
+            const err = new ApiError(networkErr?.message || 'Network error', 0);
+            err.request = { url, method, headers };
+            throw err;
+        }
+        const raw = await res.text();
+        let payload = {};
+        try {
+            payload = raw ? JSON.parse(raw) : {};
+        }
+        catch {
+            payload = raw || {};
+        }
+        if (!res.ok) {
+            throw payload;
+        }
+        return payload;
     }
 }
+// Keep the global request for backward compatibility, but make it use AuthClient config
+async function request(path, opts = {}) {
+    return new NextMinClient().request(path, opts);
+}
 function modelPath(modelName) {
     return modelName.toLowerCase() === 'user' ? '/auth/user' : `/${modelName}`;
 }
-async function request(path, opts = {}) {
-    const { method = 'GET', body, token, json = true, auth = true } = opts;
-    const headers = { 'x-api-key': API_KEY };
-    // Don't force JSON when sending FormData/Blob
-    const isForm = typeof FormData !== 'undefined' && body instanceof FormData;
-    if (json && !isForm)
-        headers['Content-Type'] = 'application/json';
-    const bearer = token ?? tokenFromStorage();
-    if (auth && bearer)
-        headers.Authorization = `Bearer ${bearer}`;
-    let res;
-    try {
-        res = await fetch(`${API_BASE}${path}`, {
-            method,
-            headers,
-            body: body && json && !isForm
-                ? JSON.stringify(body)
-                : body,
-        });
-    }
-    catch (networkErr) {
-        // Network/DNS/CORS timeouts etc.
-        const err = new ApiError(networkErr?.message || 'Network error', 0);
-        err.request = { url: `${API_BASE}${path}`, method, headers };
-        throw err;
-    }
-    const raw = await res.text();
-    let payload = {};
-    try {
-        payload = raw ? JSON.parse(raw) : {};
-    }
-    catch {
-        payload = raw || {};
-    }
-    if (!res.ok) {
-        const status = res.status;
-        const serverMsg = payload?.message ??
-            payload?.error ??
-            res.statusText ??
-            'API error';
-        throw payload;
-    }
-    return payload;
-}
 function qs(params) {
     const sp = new URLSearchParams();
     for (const [k, v] of Object.entries(params)) {
@@ -84,7 +74,30 @@ function qs(params) {
 }
 export const api = {
     getSchemas: () => request('/_schemas'),
-    list: (modelName, page = 0, limit = 10, params = {}) => request(`${modelPath(modelName)}${qs({ page, limit, ...params })}`),
+    cleanup: () => request('/_cleanup', { method: 'POST' }),
+    list: (modelName, options = {}) => {
+        const builder = new QueryBuilder();
+        if (options.where) {
+            if (Array.isArray(options.where)) {
+                options.where.forEach(f => builder.where(f.field, f.operator, f.value));
+            }
+            else {
+                // Assume it's already a transformed object or handle it
+                Object.keys(options.where).forEach(k => {
+                    // This is a bit simplified, but compatible with the builder's internal state
+                    builder.options.where = options.where;
+                });
+            }
+        }
+        if (options.sort)
+            builder.sort(options.sort, options.sortType);
+        if (options.page !== undefined)
+            builder.page(Math.max(1, options.page), options.limit);
+        if (options.q)
+            builder.search(options.q, options.searchKeys?.split(','));
+        const params = builder.build();
+        return request(`${modelPath(modelName)}${qs(params)}`);
+    },
     get: (modelName, id) => request(`${modelPath(modelName)}/${id}`),
     create: (modelName, data) => request(modelPath(modelName), {
         method: 'POST',