@airoom/nextmin-react 1.4.5 → 2.0.1

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',

package/dist/lib/auth.js

@@ -16,6 +16,9 @@ function normalizeRole(value) {
         if (typeof value === 'object' && typeof value.name === 'string') {
             return String(value.name).toLowerCase();
         }
+        if (typeof value === 'number') {
+            return String(value);
+        }
     }
     catch { }
     return null;
@@ -30,8 +33,10 @@ export async function login({ email, password }) {
         throw new Error(res?.message || 'Login failed');
     }
     // Enforce admin-only access here (superadmin/admin)
-    const role = normalizeRole(user?.role);
-    if (role !== 'admin' && role !== 'superadmin') {
+    const roleName = String(user?.roleName || '').toLowerCase();
+    const normalized = normalizeRole(user?.role);
+    const isAdmin = roleName === 'admin' || roleName === 'superadmin' || normalized === 'admin' || normalized === 'superadmin';
+    if (!isAdmin) {
         throw new Error('You are not authorized to access the admin panel');
     }
     return { token, user };

package/dist/lib/types.d.ts

@@ -7,9 +7,23 @@ export type AttributeBase = {
     longtext?: boolean;
     show?: string;
     populateSlugFrom?: string;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    mask?: string;
+    inherited?: boolean;
 };
 export type ArrayAttribute = AttributeBase[];
 export type Attribute = AttributeBase | ArrayAttribute;
+export type CustomAction = {
+    label: string;
+    href: string;
+    icon?: string;
+    variant?: 'light' | 'flat' | 'solid' | 'bordered';
+    color?: 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
+    relatedModel?: string;
+    relatedField?: string;
+};
 export type SchemaDef = {
     modelName: string;
     attributes: Record<string, Attribute>;
@@ -19,6 +33,8 @@ export type SchemaDef = {
         update?: boolean;
         delete?: boolean;
     };
+    extends?: string;
+    actions?: CustomAction[];
 };
 export type SchemasResponse = {
     success: true;