@ackplus/nest-auth 0.1.51 → 1.1.0

package/ui/src/services/api.ts

@@ -0,0 +1,115 @@
+import { getAdminApiBaseUrl } from "@/components/auth/utils/utils";
+
+export class ApiError extends Error {
+    constructor(
+        message: string,
+        public status: number
+    ) {
+        super(message);
+        this.name = 'ApiError';
+    }
+}
+
+// Global config injected by the server
+declare global {
+    interface Window {
+        __NEST_AUTH_CONFIG__?: {
+            basePath: string;
+            apiUrl?: string;
+        };
+    }
+}
+
+
+interface RequestOptions extends RequestInit {
+    body?: string;
+}
+
+export const api = {
+    get basePath() {
+        return getAdminApiBaseUrl();
+    },
+
+    async request<T = any>(endpoint: string, options: RequestOptions = {}): Promise<T> {
+        const normalizedBase = this.basePath && this.basePath !== '/' ? this.basePath : '';
+        const url = `${normalizedBase}${endpoint}`;
+
+        const fetchOptions: RequestInit = {
+            credentials: 'include',
+            ...options,
+        };
+
+        // Merge headers and ensure Content-Type for JSON bodies without clobbering existing headers
+        if (options.body) {
+            const existing = options.headers;
+            if (existing instanceof Headers) {
+                const hasContentType = Array.from(existing.keys()).some((k) => k.toLowerCase() === 'content-type');
+                if (!hasContentType) existing.set('Content-Type', 'application/json');
+                fetchOptions.headers = existing;
+            } else {
+                const objHeaders: Record<string, string> = {};
+                if (existing) {
+                    for (const [k, v] of Object.entries(existing as Record<string, string>)) {
+                        objHeaders[k] = v as string;
+                    }
+                }
+                const hasContentType = Object.keys(objHeaders).some((k) => k.toLowerCase() === 'content-type');
+                if (!hasContentType) objHeaders['Content-Type'] = 'application/json';
+                fetchOptions.headers = objHeaders;
+            }
+        }
+
+        const response = await fetch(url, fetchOptions);
+        const text = await response.text().catch((err) => {
+            console.warn('Failed to read response text:', err, 'Status:', response.status);
+            return '';
+        });
+
+        let payload: any = {};
+        if (text) {
+            try {
+                payload = JSON.parse(text);
+            } catch (error) {
+                console.warn(
+                    'Failed to parse JSON response:',
+                    error,
+                    'Status:',
+                    response.status,
+                    'Response text:',
+                    text.substring(0, 200)
+                );
+            }
+        }
+
+        if (!response.ok) {
+            const message = payload?.message || payload?.error || `Request failed with status ${response.status}`;
+            throw new ApiError(message, response.status);
+        }
+
+        return payload as T;
+    },
+
+    get<T>(endpoint: string) {
+        return this.request<T>(endpoint);
+    },
+
+    post<T>(endpoint: string, data: any) {
+        return this.request<T>(endpoint, {
+            method: 'POST',
+            body: JSON.stringify(data),
+        });
+    },
+
+    patch<T>(endpoint: string, data: any) {
+        return this.request<T>(endpoint, {
+            method: 'PATCH',
+            body: JSON.stringify(data),
+        });
+    },
+
+    delete<T>(endpoint: string) {
+        return this.request<T>(endpoint, {
+            method: 'DELETE',
+        });
+    },
+};

package/ui/src/types/index.ts

@@ -0,0 +1,136 @@
+export interface Permission {
+    id: string;
+    name: string;
+    guard: string;
+    description?: string;
+    category?: string;
+    metadata?: Record<string, any>;
+    createdAt: string;
+    updatedAt: string;
+}
+
+export interface User {
+    id: string;
+    email: string;
+    phone?: string;
+    tenantId?: string;
+    isActive: boolean;
+    isVerified: boolean;
+    metadata: Record<string, any>;
+    roles: string[];
+    createdAt: string;
+    updatedAt: string;
+    emailVerifiedAt?: string;
+    phoneVerifiedAt?: string;
+    isMfaEnabled?: boolean;
+}
+
+export interface TotpDevice {
+    id: string;
+    deviceName: string;
+    verified: boolean;
+    lastUsedAt?: string;
+    createdAt: string;
+}
+
+export interface UserSessionInfo {
+    id: string;
+    deviceName?: string;
+    userAgent?: string;
+    ipAddress?: string;
+    createdAt?: string;
+    lastActive?: string;
+    expiresAt?: string;
+}
+
+export interface UserMfaDetails {
+    isEnabled: boolean;
+    allowUserToggle: boolean;
+    availableMethods: string[];
+    enabledMethods: string[];
+    hasRecoveryCode: boolean;
+    totpDevices: TotpDevice[];
+}
+
+export interface UserDetails {
+    user: User;
+    loginMethods: {
+        emailEnabled: boolean;
+        phoneEnabled: boolean;
+        hasPassword: boolean;
+    };
+    mfa: UserMfaDetails;
+    sessions: UserSessionInfo[];
+}
+
+export interface Role {
+    id: string;
+    name: string;
+    guard: string;
+    isSystem: boolean;
+    tenantId?: string;
+    permissions: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+
+export interface Tenant {
+    id: string;
+    name: string;
+    slug: string;
+    description?: string;
+    metadata: Record<string, any>;
+    createdAt: string;
+    updatedAt: string;
+}
+
+export interface Admin {
+    id: string;
+    email: string;
+    name?: string;
+    metadata: Record<string, any>;
+    lastLoginAt?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+
+export interface LoginForm {
+    email: string;
+    password: string;
+}
+
+export interface CreateUserForm {
+    email: string;
+    tenantId: string;
+    password?: string;
+    roles: string;
+}
+
+export interface CreateRoleForm {
+    name: string;
+    guard: string;
+    tenantId: string;
+    permissions: string;
+}
+
+export interface CreateTenantForm {
+    name: string;
+    slug: string;
+    description: string;
+}
+
+export interface CreateAdminForm {
+    email: string;
+    name: string;
+    password: string;
+}
+
+export interface ApiResponse<T> {
+    data?: T;
+    message?: string;
+    error?: string;
+}
+
+export interface DashboardConfig {
+    allowAdminManagement: boolean;
+}

package/ui/src/vite-env.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="vite/client" />
+
+interface ImportMetaEnv {
+    readonly VITE_API_BASE_URL?: string;
+}
+
+interface ImportMeta {
+    readonly env: ImportMetaEnv;
+}

package/ui/tailwind.config.js

@@ -0,0 +1,45 @@
+/** @type {import('tailwindcss').Config} */
+export default {
+    content: [
+        "./index.html",
+        "./src/**/*.{js,ts,jsx,tsx}",
+    ],
+    theme: {
+        extend: {
+            colors: {
+                primary: {
+                    50: '#f0f9ff',
+                    100: '#e0f2fe',
+                    200: '#bae6fd',
+                    300: '#7dd3fc',
+                    400: '#38bdf8',
+                    500: '#0ea5e9',
+                    600: '#0284c7',
+                    700: '#0369a1',
+                    800: '#075985',
+                    900: '#0c4a6e',
+                },
+                sidebar: {
+                    DEFAULT: '#1e293b',
+                    light: '#334155',
+                    dark: '#0f172a',
+                }
+            },
+            animation: {
+                'fade-in': 'fadeIn 0.3s ease-in-out',
+                'slide-up': 'slideUp 0.3s ease-out',
+            },
+            keyframes: {
+                fadeIn: {
+                    '0%': { opacity: '0' },
+                    '100%': { opacity: '1' },
+                },
+                slideUp: {
+                    '0%': { transform: 'translateY(10px)', opacity: '0' },
+                    '100%': { transform: 'translateY(0)', opacity: '1' },
+                },
+            },
+        },
+    },
+    plugins: [],
+}

package/ui/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "strict": false,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noFallthroughCasesInSwitch": false,
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src"],
+  "references": [{ "path": "./tsconfig.node.json" }]
+}

package/ui/tsconfig.node.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["vite.config.ts"]
+}

package/ui/vite.config.ts

@@ -0,0 +1,37 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import { resolve } from 'path';
+import { viteSingleFile } from 'vite-plugin-singlefile';
+
+export default defineConfig({
+    plugins: [
+        react({
+            // Disable ESLint plugin during build
+            jsxRuntime: 'automatic',
+        }),
+        // Inline JS and CSS into the generated index.html
+        viteSingleFile(),
+    ],
+    resolve: {
+        alias: {
+            '@': resolve(__dirname, './src'),
+        },
+    },
+    build: {
+        outDir: '../src/lib/admin-console/static',
+        emptyOutDir: true,
+        // Continue build even with TypeScript errors
+        rollupOptions: {
+            input: {
+                main: resolve(__dirname, 'index.html'),
+            },
+            // singlefile handles inlining; filenames no longer matter
+        },
+    },
+    base: './',
+    // Disable linting in dev mode
+    esbuild: {
+        // Ignore linting errors
+        logOverride: { 'this-is-undefined-in-esm': 'silent' },
+    },
+});