@goplusvn/core 0.1.0 → 0.1.2

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@goplusvn/core",
   "description": "GoPlusVN Platform Kit - ERP kernel: layout, RBAC, CRUD, multi-tenant, system pages",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "private": false,
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public"
   },
-  "main": "./dist/index.js",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
+  "main": "./src/index.ts",
+  "module": "./src/index.ts",
+  "types": "./src/index.ts",
   "sideEffects": false,
   "files": [
-    "dist",
+    "src",
     "README.md",
     "CHANGELOG.md"
   ],
@@ -23,176 +23,32 @@
   },
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
-    },
-    "./system": {
-      "types": "./dist/system/index.d.ts",
-      "import": "./dist/system/index.mjs",
-      "require": "./dist/system/index.js"
-    },
-    "./auth": {
-      "types": "./dist/auth/index.d.ts",
-      "import": "./dist/auth/index.mjs",
-      "require": "./dist/auth/index.js"
-    },
-    "./types": {
-      "types": "./dist/types/index.d.ts",
-      "import": "./dist/types/index.mjs",
-      "require": "./dist/types/index.js"
-    },
-    "./utils": {
-      "types": "./dist/utils/index.d.ts",
-      "import": "./dist/utils/index.mjs",
-      "require": "./dist/utils/index.js"
-    },
-    "./layout": {
-      "types": "./dist/layout/index.d.ts",
-      "import": "./dist/layout/index.mjs",
-      "require": "./dist/layout/index.js"
-    },
-    "./crud": {
-      "types": "./dist/crud/index.d.ts",
-      "import": "./dist/crud/index.mjs",
-      "require": "./dist/crud/index.js"
-    },
-    "./crud/server": {
-      "types": "./dist/crud/server.d.ts",
-      "import": "./dist/crud/server.mjs",
-      "require": "./dist/crud/server.js"
-    },
-    "./ui": {
-      "types": "./dist/ui/index.d.ts",
-      "import": "./dist/ui/index.mjs",
-      "require": "./dist/ui/index.js"
-    },
-    "./ui/auth": {
-      "types": "./dist/ui/auth.d.ts",
-      "import": "./dist/ui/auth.mjs",
-      "require": "./dist/ui/auth.js"
-    },
-    "./ui/primitives": {
-      "types": "./dist/ui/primitives.d.ts",
-      "import": "./dist/ui/primitives.mjs",
-      "require": "./dist/ui/primitives.js"
-    },
-    "./ui/primitives/client": {
-      "types": "./dist/ui/primitives/client.d.ts",
-      "import": "./dist/ui/primitives/client.mjs",
-      "require": "./dist/ui/primitives/client.js"
-    },
-    "./ui/forms": {
-      "types": "./dist/ui/forms/index.d.ts",
-      "import": "./dist/ui/forms/index.mjs",
-      "require": "./dist/ui/forms/index.js"
-    },
-    "./ui/data-display": {
-      "types": "./dist/ui/data-display/index.d.ts",
-      "import": "./dist/ui/data-display/index.mjs",
-      "require": "./dist/ui/data-display/index.js"
-    },
-    "./ui/feedback": {
-      "types": "./dist/ui/feedback.d.ts",
-      "import": "./dist/ui/feedback.mjs",
-      "require": "./dist/ui/feedback.js"
-    },
-    "./ui/crud": {
-      "types": "./dist/ui/crud/index.d.ts",
-      "import": "./dist/ui/crud/index.mjs",
-      "require": "./dist/ui/crud/index.js"
-    },
-    "./hooks": {
-      "types": "./dist/hooks/index.d.ts",
-      "import": "./dist/hooks/index.mjs",
-      "require": "./dist/hooks/index.js"
-    },
-    "./configs": {
-      "types": "./dist/configs/index.d.ts",
-      "import": "./dist/configs/index.mjs",
-      "require": "./dist/configs/index.js"
-    },
-    "./providers": {
-      "types": "./dist/providers/index.d.ts",
-      "import": "./dist/providers/index.mjs",
-      "require": "./dist/providers/index.js"
-    },
-    "./workflow": {
-      "types": "./dist/workflow/index.d.ts",
-      "import": "./dist/workflow/index.mjs",
-      "require": "./dist/workflow/index.js"
-    },
-    "./navigation": {
-      "types": "./dist/navigation/index.d.ts",
-      "import": "./dist/navigation/index.mjs",
-      "require": "./dist/navigation/index.js"
-    },
-    "./rbac": {
-      "types": "./dist/rbac/index.d.ts",
-      "import": "./dist/rbac/index.mjs",
-      "require": "./dist/rbac/index.js"
-    },
-    "./rbac/permissions": {
-      "types": "./dist/rbac/permissions.d.ts",
-      "import": "./dist/rbac/permissions.mjs",
-      "require": "./dist/rbac/permissions.js"
-    },
-    "./rbac/server": {
-      "types": "./dist/rbac/server.d.ts",
-      "import": "./dist/rbac/server.mjs",
-      "require": "./dist/rbac/server.js"
-    },
-    "./organization": {
-      "types": "./dist/organization/index.d.ts",
-      "import": "./dist/organization/index.mjs",
-      "require": "./dist/organization/index.js"
-    },
-    "./assets/erp_wallpaper.png": "./src/assets/erp_wallpaper.png",
-    "./plugin": {
-      "types": "./dist/plugin/index.d.ts",
-      "import": "./dist/plugin/index.mjs",
-      "require": "./dist/plugin/index.js"
-    },
-    "./code-generation": {
-      "types": "./dist/code-generation/index.d.ts",
-      "import": "./dist/code-generation/index.mjs",
-      "require": "./dist/code-generation/index.js"
-    },
-    "./schemas": {
-      "types": "./dist/schemas/index.d.ts",
-      "import": "./dist/schemas/index.mjs",
-      "require": "./dist/schemas/index.js"
-    },
-    "./infrastructure": {
-      "types": "./dist/infrastructure/index.d.ts",
-      "import": "./dist/infrastructure/index.mjs",
-      "require": "./dist/infrastructure/index.js"
-    },
-    "./audit": {
-      "types": "./dist/audit/index.d.ts",
-      "import": "./dist/audit/index.mjs",
-      "require": "./dist/audit/index.js"
-    },
-    "./notification": {
-      "types": "./dist/notification/index.d.ts",
-      "import": "./dist/notification/index.mjs",
-      "require": "./dist/notification/index.js"
-    },
-    "./home": {
-      "types": "./dist/home/index.d.ts",
-      "import": "./dist/home/index.mjs",
-      "require": "./dist/home/index.js"
-    },
-    "./user": {
-      "types": "./dist/user/index.d.ts",
-      "import": "./dist/user/index.mjs",
-      "require": "./dist/user/index.js"
-    },
-    "./user/client-page": {
-      "types": "./src/user/pages/users-client-page.tsx",
-      "import": "./src/user/pages/users-client-page.tsx",
-      "require": "./src/user/pages/users-client-page.tsx"
-    }
+      "types": "./src/index.ts",
+      "import": "./src/index.ts",
+      "default": "./src/index.ts"
+    },
+    "./*": {
+      "types": [
+        "./src/*.ts",
+        "./src/*.tsx",
+        "./src/*/index.ts",
+        "./src/*/index.tsx"
+      ],
+      "import": [
+        "./src/*.ts",
+        "./src/*.tsx",
+        "./src/*/index.ts",
+        "./src/*/index.tsx"
+      ],
+      "default": [
+        "./src/*.ts",
+        "./src/*.tsx",
+        "./src/*/index.ts",
+        "./src/*/index.tsx"
+      ]
+    },
+    "./assets/*": "./src/assets/*",
+    "./package.json": "./package.json"
   },
   "peerDependencies": {
     "next": ">=14.0.0",

package/src/audit/audit-manager.ts

@@ -0,0 +1,139 @@
+import type {
+  AuditLog,
+  AuditLogger,
+  AuditManagerOptions,
+  CreateAuditInput,
+} from "./types";
+import { createLogger } from "../infrastructure/logger";
+import { MemoryAuditLogger } from "./memory-audit-logger";
+
+const logger = createLogger("AuditManager");
+
+/**
+ * Console-based audit logger (default)
+ * In production, replace with database or external service
+ */
+class ConsoleAuditLogger implements AuditLogger {
+  async log(entry: AuditLog): Promise<void> {
+    logger.info(`AUDIT: ${entry.action} ${entry.resource}`, {
+      id: entry.id,
+      resourceId: entry.resourceId,
+      userId: entry.userId,
+      changes: entry.changes,
+    });
+  }
+}
+
+/**
+ * AuditManager - tracks actions for compliance and debugging
+ *
+ * @example
+ * ```typescript
+ * import { auditManager } from '@goerp/core/audit';
+ *
+ * // Log an action
+ * await auditManager.log({
+ *   action: 'update',
+ *   resource: 'purchase-order',
+ *   resourceId: '123',
+ *   userId: session.user.id,
+ *   changes: { status: { old: 'pending', new: 'approved' } }
+ * });
+ * ```
+ */
+class AuditManagerImpl {
+  private auditLogger: AuditLogger;
+  private registeredActions: Set<string>;
+
+  constructor(options: AuditManagerOptions = {}) {
+    this.auditLogger = options.logger || new MemoryAuditLogger();
+    this.registeredActions = new Set(
+      options.actions || ["create", "update", "delete", "login", "logout"],
+    );
+  }
+
+  /** Set custom audit logger */
+  setLogger(auditLogger: AuditLogger): void {
+    this.auditLogger = auditLogger;
+  }
+
+  /** Register action for automatic auditing */
+  registerAction(action: string): void {
+    this.registeredActions.add(action);
+  }
+
+  /** Check if action is registered for auditing */
+  isRegistered(action: string): boolean {
+    return this.registeredActions.has(action);
+  }
+
+  /** Log an audit entry */
+  async log(input: CreateAuditInput): Promise<void> {
+    const entry: AuditLog = {
+      id: crypto.randomUUID(),
+      ...input,
+      createdAt: new Date(),
+    };
+
+    try {
+      await this.auditLogger.log(entry);
+    } catch (error) {
+      logger.error("Failed to log audit entry", { error: String(error) });
+    }
+  }
+
+  /**
+   * Get logs if the logger supports it (specifically MemoryAuditLogger)
+   */
+  getLogs(filter: any = {}): AuditLog[] {
+    if ("getLogs" in this.auditLogger) {
+      return (this.auditLogger as any).getLogs(filter);
+    }
+    return [];
+  }
+
+  /** Create middleware for automatic API route auditing */
+  middleware() {
+    return async (
+      ctx: {
+        action?: { actionName: string; resourceName: string };
+        state?: { currentUser?: { id: string }; currentRole?: string };
+        request?: { ip?: string; header?: Record<string, string> };
+        status?: number;
+      },
+      next: () => Promise<void>,
+    ): Promise<void> => {
+      const startTime = Date.now();
+      let error: Error | null = null;
+
+      try {
+        await next();
+      } catch (e) {
+        error = e as Error;
+        throw e;
+      } finally {
+        if (ctx.action && this.isRegistered(ctx.action.actionName)) {
+          await this.log({
+            action: ctx.action.actionName,
+            resource: ctx.action.resourceName,
+            userId: ctx.state?.currentUser?.id,
+            roleName: ctx.state?.currentRole,
+            ip: ctx.request?.ip,
+            userAgent: ctx.request?.header?.["user-agent"],
+            status: ctx.status || (error ? 500 : 200),
+            metadata: {
+              duration: Date.now() - startTime,
+              ...(error && { error: error.message }),
+            },
+          });
+        }
+      }
+    };
+  }
+}
+
+// Singleton instance
+export const auditManager = new AuditManagerImpl();
+
+// Export class for testing
+export { AuditManagerImpl, ConsoleAuditLogger, MemoryAuditLogger };

package/src/audit/index.ts

@@ -0,0 +1,11 @@
+export {
+  auditManager,
+  AuditManagerImpl,
+  ConsoleAuditLogger,
+} from "./audit-manager";
+export type {
+  AuditLog,
+  AuditLogger,
+  AuditManagerOptions,
+  CreateAuditInput,
+} from "./types";

package/src/audit/memory-audit-logger.ts

@@ -0,0 +1,86 @@
+import type { AuditLog, AuditLogger } from "./types";
+
+/**
+ * Filter options for retrieving audit logs
+ */
+export interface AuditLogFilter {
+  fromDate?: Date;
+  toDate?: Date;
+  userId?: string;
+  action?: string;
+  resource?: string;
+  type?: "info" | "warning" | "error";
+  limit?: number;
+  offset?: number;
+}
+
+/**
+ * In-memory audit logger that supports retrieval
+ */
+export class MemoryAuditLogger implements AuditLogger {
+  private logs: AuditLog[] = [];
+  private readonly maxLogs: number;
+
+  constructor(maxLogs = 1000) {
+    this.maxLogs = maxLogs;
+  }
+
+  async log(entry: AuditLog): Promise<void> {
+    // Add to beginning of array
+    this.logs.unshift(entry);
+
+    // Trim if exceeds max size
+    if (this.logs.length > this.maxLogs) {
+      this.logs = this.logs.slice(0, this.maxLogs);
+    }
+  }
+
+  /**
+   * Get logs with filtering
+   */
+  getLogs(filter: AuditLogFilter = {}): AuditLog[] {
+    let filtered = this.logs;
+
+    if (filter.fromDate) {
+      filtered = filtered.filter((log) => log.createdAt >= filter.fromDate!);
+    }
+
+    if (filter.toDate) {
+      filtered = filtered.filter((log) => log.createdAt <= filter.toDate!);
+    }
+
+    if (filter.userId) {
+      filtered = filtered.filter((log) => log.userId === filter.userId);
+    }
+
+    if (filter.action) {
+      filtered = filtered.filter((log) => log.action === filter.action);
+    }
+
+    if (filter.resource) {
+      filtered = filtered.filter((log) => log.resource === filter.resource);
+    }
+
+    // "type" filter is a fuzzy mapping based on status code or action name for demo purposes
+    if (filter.type) {
+      filtered = filtered.filter((log) => {
+        if (filter.type === "error") return (log.status || 200) >= 400;
+        if (filter.type === "warning")
+          return (log.status || 200) >= 300 && (log.status || 200) < 400;
+        return (log.status || 200) < 300;
+      });
+    }
+
+    const offset = filter.offset || 0;
+    const limit = filter.limit || 50;
+
+    return filtered.slice(offset, offset + limit);
+  }
+
+  /**
+   * Clear all logs
+   */
+  clear(): void {
+    this.logs = [];
+  }
+}

package/src/audit/types.ts

@@ -0,0 +1,50 @@
+// Audit Types
+export interface AuditLog {
+  id: string;
+  /** Action type: create, update, delete, login, logout, custom */
+  action: string;
+  /** Resource/entity name (e.g., 'purchase-order', 'user') */
+  resource: string;
+  /** Resource ID */
+  resourceId?: string;
+  /** User who performed the action */
+  userId?: string;
+  /** User's role at time of action */
+  roleName?: string;
+  /** Changes made (for update actions) */
+  changes?: Record<string, { old: unknown; new: unknown }>;
+  /** Additional metadata */
+  metadata?: Record<string, unknown>;
+  /** Request IP address */
+  ip?: string;
+  /** User agent */
+  userAgent?: string;
+  /** HTTP status code */
+  status?: number;
+  /** Timestamp */
+  createdAt: Date;
+}
+
+export interface CreateAuditInput {
+  action: string;
+  resource: string;
+  resourceId?: string;
+  userId?: string;
+  roleName?: string;
+  changes?: Record<string, { old: unknown; new: unknown }>;
+  metadata?: Record<string, unknown>;
+  ip?: string;
+  userAgent?: string;
+  status?: number;
+}
+
+export interface AuditLogger {
+  log(entry: AuditLog): Promise<void>;
+}
+
+export interface AuditManagerOptions {
+  /** Custom logger implementation */
+  logger?: AuditLogger;
+  /** Actions to automatically audit */
+  actions?: string[];
+}

package/src/auth/auth-service.ts

@@ -0,0 +1,97 @@
+// Define the shape of the Prisma Client required by this service
+export interface AuthPrismaClient {
+  user: any;
+}
+
+// Dynamic import bcryptjs to avoid Edge Runtime issues
+export async function verifyPassword(
+  password: string,
+  hash: string,
+): Promise<boolean> {
+  try {
+    const bcrypt = await import("bcryptjs");
+    return bcrypt.compareSync(password, hash);
+  } catch (error) {
+    console.error("Error verifying password", error);
+    return false;
+  }
+}
+
+export interface AuthenticatedUser {
+  id: string;
+  email: string | null;
+  name: string;
+  avatar: string | null;
+  status: string;
+}
+
+export interface AuthError {
+  message: string;
+  email?: string;
+}
+
+/**
+ * Authenticate user with email and password
+ * Returns user data if successful, throws error if failed
+ */
+export async function authenticateUser(
+  db: AuthPrismaClient,
+  email: string,
+  password: string,
+): Promise<AuthenticatedUser> {
+  try {
+    // Query user from database by email
+    const user = await db.user.findUnique({
+      where: { email: email.toLowerCase().trim() },
+      select: {
+        id: true,
+        email: true,
+        name: true,
+        avatar: true,
+        password: true,
+        isActive: true,
+      },
+    });
+
+    // Check if user exists
+    if (!user) {
+      throw new Error("Invalid email or password");
+    }
+
+    // Check if user account is suspended/inactive
+    if (!user.isActive) {
+      throw new Error("ACCOUNT_SUSPENDED");
+    }
+
+    // Verify password
+    if (!user.password) {
+      throw new Error("Invalid email or password");
+    }
+
+    const isPasswordValid = await verifyPassword(password, user.password);
+    if (!isPasswordValid) {
+      throw new Error("Invalid email or password");
+    }
+
+    // Update last login time
+    await db.user.update({
+      where: { id: user.id },
+      data: { lastLoginAt: new Date() },
+    });
+
+    // Return user data (without password)
+    return {
+      id: user.id,
+      name: user.name || "",
+      email: user.email,
+      avatar: user.avatar || null,
+      status: "ONLINE",
+    };
+  } catch (error) {
+    // Re-throw error with proper message
+    if (error instanceof Error) {
+      throw error;
+    }
+    throw new Error("Error signing in");
+  }
+}