@goplusvn/core 0.1.0 → 0.1.2

package/src/rbac/resource-service.ts

@@ -0,0 +1,115 @@
+export interface ResourcePrismaClient {
+  resource: any;
+  action: any;
+}
+
+/**
+ * Get resources data with pagination and filtering
+ * Shared function for both API route and Server Component
+ *
+ * @param db - The tenant-specific Prisma Client instance
+ * @param params - Filter and pagination parameters
+ */
+export async function getResourcesData(
+  db: ResourcePrismaClient,
+  params: any = {},
+) {
+  const { page = 1, pageSize = 10, search, status, group, type } = params;
+
+  const where: any = {
+    AND: [
+      search
+        ? {
+            OR: [
+              { code: { contains: search, mode: "insensitive" } },
+              { name: { contains: search, mode: "insensitive" } },
+              { description: { contains: search, mode: "insensitive" } },
+              { path: { contains: search, mode: "insensitive" } },
+            ],
+          }
+        : {},
+      status && status !== "all"
+        ? { status: { equals: status, mode: "insensitive" } }
+        : {},
+      group && group !== "all" ? { group } : {},
+      type && type !== "all" ? { type } : {},
+    ],
+  };
+
+  const [total, items] = await Promise.all([
+    db.resource.count({ where }),
+    db.resource.findMany({
+      where,
+      orderBy: [{ order: "asc" }, { updatedAt: "desc" }],
+      skip: (page - 1) * pageSize,
+      take: pageSize,
+    }),
+  ]);
+
+  // Transform Prisma items to Resource type format
+  const transformedItems = items.map((item: any) => ({
+    id: item.id,
+    code: item.code,
+    name: item.name,
+    group: item.group || undefined,
+    description: item.description || undefined,
+    status: item.status,
+    parentCode: item.parentCode || undefined,
+    order: item.order || undefined,
+    type: item.type || undefined,
+    icon: item.icon || undefined,
+    path: item.path || undefined,
+    config: item.config || undefined,
+    createdAt: item.createdAt.toISOString(),
+    updatedAt: item.updatedAt.toISOString(),
+  }));
+
+  return { total, page, pageSize, items: transformedItems };
+}
+
+/**
+ * Get all active resources for permission matrix
+ * Used in role management to build dynamic permission matrix
+ */
+export async function getResourcesForPermissionMatrix(
+  db: ResourcePrismaClient,
+) {
+  return await db.resource.findMany({
+    where: {
+      status: "active",
+    },
+    orderBy: [{ group: "asc" }, { order: "asc" }, { name: "asc" }],
+    select: {
+      id: true,
+      code: true,
+      name: true,
+      group: true,
+      description: true,
+      icon: true,
+      order: true,
+      config: true,
+    },
+  });
+}
+
+/**
+ * Get all active actions for permission matrix
+ * Used in role management to build dynamic permission matrix
+ */
+export async function getActionsForPermissionMatrix(db: ResourcePrismaClient) {
+  return await db.action.findMany({
+    where: {
+      status: "active",
+    },
+    orderBy: {
+      code: "asc",
+    },
+    select: {
+      id: true,
+      code: true,
+      name: true,
+      description: true,
+      isDefault: true,
+    },
+  });
+}

package/src/rbac/resource-validator.ts

@@ -0,0 +1,119 @@
+/**
+ * Resource Validator
+ * Validates resource codes against DB with caching
+ */
+
+import { cacheManager } from "../infrastructure/cache/cache-manager";
+
+// Cache for valid resource codes (loaded from DB)
+const resourceCache = cacheManager.create({
+  name: "resource-codes",
+  ttl: 3600, // 1 hour - resource codes rarely change
+  max: 1000,
+});
+
+// Type for Prisma client with Resource model
+interface ResourcePrismaClient {
+  resource: {
+    findUnique: (args: { where: { code: string } }) => Promise<{ code: string } | null>;
+    findMany: (args?: { select?: { code: boolean } }) => Promise<{ code: string }[]>;
+  };
+}
+
+/**
+ * Check if a resource code exists.
+ * Checks cache first, then DB if not found.
+ * 
+ * @param db - Prisma client
+ * @param resourceCode - Resource code to validate
+ * @returns true if valid, false otherwise
+ */
+export async function isValidResourceCode(
+  db: ResourcePrismaClient,
+  resourceCode: string
+): Promise<boolean> {
+  // Check cache first
+  const cacheKey = `valid:${resourceCode}`;
+  const cached = await resourceCache.get<boolean>(cacheKey);
+  
+  if (cached !== undefined) {
+    return cached;
+  }
+
+  // Not in cache, check DB
+  const resource = await db.resource.findUnique({
+    where: { code: resourceCode },
+  });
+
+  const isValid = resource !== null;
+  
+  // Cache result
+  await resourceCache.set(cacheKey, isValid);
+  
+  return isValid;
+}
+
+/**
+ * Get the correct resource code for permission checking.
+ * Priority: config.permissionResource > config.name > entity param
+ * 
+ * @param config - Entity config (may be partial)
+ * @param entityParam - Entity param from URL
+ * @returns Resource code to use for permission check
+ */
+export function getPermissionResourceCode(
+  config: { permissionResource?: string; name?: string } | null | undefined,
+  entityParam: string
+): string {
+  if (config?.permissionResource) {
+    return config.permissionResource;
+  }
+  if (config?.name) {
+    return config.name;
+  }
+  return entityParam;
+}
+
+/**
+ * Validate and get resource code for permission checking.
+ * Combines getPermissionResourceCode with DB validation.
+ * 
+ * @param db - Prisma client
+ * @param config - Entity config
+ * @param entityParam - Entity param from URL
+ * @returns Object with resourceCode and isValid flag
+ */
+export async function validatePermissionResource(
+  db: ResourcePrismaClient,
+  config: { permissionResource?: string; name?: string } | null | undefined,
+  entityParam: string
+): Promise<{ resourceCode: string; isValid: boolean }> {
+  const resourceCode = getPermissionResourceCode(config, entityParam);
+  const isValid = await isValidResourceCode(db, resourceCode);
+  
+  return { resourceCode, isValid };
+}
+
+/**
+ * Preload all resource codes into cache.
+ * Call this on app startup for better performance.
+ * 
+ * @param db - Prisma client
+ */
+export async function preloadResourceCodes(db: ResourcePrismaClient): Promise<void> {
+  const resources = await db.resource.findMany({
+    select: { code: true },
+  });
+
+  for (const resource of resources) {
+    await resourceCache.set(`valid:${resource.code}`, true);
+  }
+}
+
+/**
+ * Clear resource cache.
+ * Call when resources are added/removed.
+ */
+export async function clearResourceCache(): Promise<void> {
+  await resourceCache.reset();
+}

package/src/rbac/role-service.ts

@@ -0,0 +1,165 @@
+// Note: We use Prisma types for input construction, but we don't import the client instance.
+// If Prisma types are not available in core (since core doesn't have prisma schema),
+// we might need to define loose types or rely on the injected client's type inference if strict mode allows.
+// However, since we want to be Type-safe, we assume the host app uses standard Prisma conventions.
+// For core, we can define the expected structure of the Include/Where types if needed,
+// or simply use 'any' for the complex Prisma types if we want to avoid strict coupling to a specific schema version.
+// To be safe and generic in 'core', we will define the input params using standard TypeScript types
+// and the db client interface locally.
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export type RoleFilters = {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  status?: string;
+};
+
+export type RoleData = {
+  id: string;
+  name: string;
+  code: string;
+  description?: string;
+  status: string;
+  permissions: string[];
+  usersCount: number;
+  users: {
+    id: string;
+    name: string | null;
+    email: string | null;
+    image: string | null;
+    isActive: boolean;
+  }[];
+  createdAt: string;
+  updatedAt: string;
+  createdBy?: string;
+  updatedBy?: string;
+};
+
+// Interface for the DB client injected into the service
+// We define the shape of the Prisma Client we expect
+export interface RolePrismaClient {
+  role: {
+    count: (args: { where: any }) => Promise<number>;
+    findMany: (args: {
+      where: any;
+      orderBy: any;
+      skip: number;
+      take: number;
+      include: any;
+    }) => Promise<any[]>;
+  };
+}
+
+// ============================================================================
+// Service Logic
+// ============================================================================
+
+/**
+ * Get roles data with pagination and filtering
+ * Generic core implementation using injected DB client
+ *
+ * @param db - The tenant-specific Prisma Client instance
+ * @param params - Filter and pagination parameters
+ */
+export async function getRolesData(
+  db: RolePrismaClient,
+  params: RoleFilters = {},
+): Promise<{
+  total: number;
+  page: number;
+  pageSize: number;
+  items: RoleData[];
+}> {
+  const { page = 1, pageSize = 10, search, status } = params;
+
+  const whereConditions: any[] = [];
+
+  if (search) {
+    whereConditions.push({
+      OR: [
+        { name: { contains: search, mode: "insensitive" } },
+        { code: { contains: search, mode: "insensitive" } },
+        { description: { contains: search, mode: "insensitive" } },
+      ],
+    });
+  }
+
+  if (status && status !== "all") {
+    whereConditions.push({ status });
+  }
+
+  const where: any = whereConditions.length > 0 ? { AND: whereConditions } : {};
+
+  const [total, items] = await Promise.all([
+    db.role.count({ where }),
+    db.role.findMany({
+      where,
+      orderBy: { createdAt: "desc" },
+      skip: (page - 1) * pageSize,
+      take: pageSize,
+      include: {
+        userRoles: {
+          include: {
+            user: {
+              select: {
+                id: true,
+                name: true,
+                email: true,
+                image: true,
+                isActive: true,
+              },
+            },
+          },
+        },
+        rolePermissions: {
+          include: {
+            resource: {
+              select: {
+                code: true,
+                name: true,
+                icon: true,
+              },
+            },
+            action: {
+              select: {
+                code: true,
+                name: true,
+              },
+            },
+          },
+        },
+      },
+    }),
+  ]);
+
+  // Transform raw DB items to RoleData type
+  const transformedItems = items.map((role: any) => ({
+    id: role.id,
+    name: role.name,
+    code: role.code,
+    description: role.description || undefined,
+    status: role.status,
+    // Transform rolePermissions to array of "action:resource" strings
+    permissions: role.rolePermissions.map(
+      (rp: any) => `${rp.actionCode}:${rp.resourceCode}`,
+    ),
+    usersCount: role.userRoles.length,
+    users: role.userRoles.map((ur: any) => ({
+      id: ur.user.id,
+      name: ur.user.name,
+      email: ur.user.email,
+      image: ur.user.image,
+      isActive: ur.user.isActive,
+    })),
+    createdAt: role.createdAt.toISOString(),
+    updatedAt: role.updatedAt.toISOString(),
+    createdBy: role.createdBy || undefined,
+    updatedBy: role.updatedBy || undefined,
+  }));
+
+  return { total, page, pageSize, items: transformedItems };
+}

package/src/rbac/server.ts

@@ -0,0 +1,16 @@
+// @goerp/core/rbac/server
+// Server-only RBAC data functions - no client/UI imports
+// Use this in Server Components and API routes to avoid bundling client code
+
+export {
+  getRolesData,
+  type RoleFilters,
+  type RoleData,
+  type RolePrismaClient,
+} from "./role-service";
+
+export {
+  getResourcesForPermissionMatrix,
+  getActionsForPermissionMatrix,
+  type ResourcePrismaClient,
+} from "./resource-service";

package/src/rbac/types.ts

@@ -0,0 +1,38 @@
+export type User = {
+  id: string;
+  name: string | null;
+  email: string | null;
+  image: string | null;
+  isActive: boolean;
+  jobTitle?: string;
+};
+
+export type Role = {
+  id: string;
+  name: string;
+  code: string;
+  description?: string | null | undefined;
+  status: string;
+  permissions: string[];
+  usersCount: number;
+  users: User[];
+  createdAt: string;
+  updatedAt: string;
+  createdBy?: string | null | undefined;
+  updatedBy?: string | null | undefined;
+};
+
+export type Permission = {
+  id: string;
+  action: string;
+  resource: string;
+  description: string;
+  status: string;
+};
+
+export type RolesResponse = {
+  total: number;
+  page: number;
+  pageSize: number;
+  items: Role[];
+};

package/src/schemas/action.schema.ts

@@ -0,0 +1,66 @@
+import { z } from "zod";
+
+import { STATUS_ACTIVE, STATUS_INACTIVE, STATUS_VALUES } from "../configs";
+
+/**
+ * Action Validation Schema
+ *
+ * Rules:
+ * - code: Required, max 50 chars
+ * - name: Required, max 200 chars
+ * - description: Optional, max 1000 chars
+ * - status: Enum (active/inactive)
+ */
+
+export const actionSchema = z.object({
+  code: z
+    .string()
+    .min(1, "Mã hành động là bắt buộc")
+    .max(50, "Mã hành động tối đa 50 ký tự")
+    .trim(),
+
+  name: z
+    .string()
+    .min(1, "Tên hành động là bắt buộc")
+    .max(200, "Tên hành động tối đa 200 ký tự")
+    .trim(),
+
+  description: z
+    .string()
+    .max(1000, "Mô tả tối đa 1000 ký tự")
+    .optional()
+    .or(z.literal(""))
+    .transform((val) => val || ""),
+
+  isDefault: z.boolean().default(false),
+
+  status: z.preprocess((val) => {
+    // Hỗ trợ boolean từ switch field (true -> active, false -> inactive)
+    if (typeof val === "boolean") {
+      return val ? STATUS_ACTIVE : STATUS_INACTIVE;
+    }
+    // Hỗ trợ cả Active/Inactive cũ và chuyển về lowercase
+    if (val === "Active" || val === "Inactive") {
+      return val === "Active" ? STATUS_ACTIVE : STATUS_INACTIVE;
+    }
+    return val;
+  }, z.enum(STATUS_VALUES).default(STATUS_ACTIVE)),
+});
+
+/**
+ * Type inference from schema
+ */
+export type ActionInput = z.infer<typeof actionSchema>;
+
+/**
+ * Partial schema for updates (all fields optional)
+ */
+export const actionUpdateSchema = actionSchema.partial();
+
+/**
+ * Schema for bulk operations
+ */
+export const actionBulkSchema = z.object({
+  ids: z.array(z.string()).min(1, "Phải chọn ít nhất 1 hành động"),
+  action: z.enum(["delete", "activate", "deactivate"]),
+});

package/src/schemas/branch.schema.ts

@@ -0,0 +1,52 @@
+import { z } from "zod";
+
+/**
+ * Branch Validation Schema
+ *
+ * Validates branch form submissions on both client & server.
+ */
+
+export const branchSchema = z.object({
+  companyId: z.string().min(1, "Công ty là bắt buộc"),
+
+  code: z
+    .string()
+    .min(1, "Mã chi nhánh là bắt buộc")
+    .max(50, "Mã chi nhánh tối đa 50 ký tự")
+    .trim(),
+
+  name: z
+    .string()
+    .min(1, "Tên chi nhánh là bắt buộc")
+    .max(255, "Tên chi nhánh tối đa 255 ký tự")
+    .trim(),
+
+  address: z
+    .string()
+    .max(500, "Địa chỉ tối đa 500 ký tự")
+    .trim()
+    .optional()
+    .nullable(),
+
+  phone: z
+    .string()
+    .max(20, "Số điện thoại tối đa 20 ký tự")
+    .trim()
+    .optional()
+    .nullable(),
+
+  email: z
+    .string()
+    .max(255, "Email tối đa 255 ký tự")
+    .email("Email không hợp lệ")
+    .trim()
+    .optional()
+    .nullable()
+    .or(z.literal("")),
+
+  status: z.enum(["active", "inactive"]).default("active"),
+});
+
+export type BranchInput = z.infer<typeof branchSchema>;
+
+export const branchUpdateSchema = branchSchema.partial();

package/src/schemas/coming-soon-schema.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+
+export const ComingSoonSchema = z.object({
+  email: z
+    .string()
+    .email({ message: "Invalid email address" })
+    .toLowerCase()
+    .trim(),
+});

package/src/schemas/company.schema.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+
+/**
+ * Company Validation Schema
+ *
+ * Validates company form submissions on both client & server.
+ */
+
+export const companySchema = z.object({
+  name: z
+    .string()
+    .min(1, "Tên công ty là bắt buộc")
+    .max(255, "Tên công ty tối đa 255 ký tự")
+    .trim(),
+
+  taxCode: z
+    .string()
+    .min(1, "Mã số thuế là bắt buộc")
+    .max(50, "Mã số thuế tối đa 50 ký tự")
+    .trim(),
+
+  address: z
+    .string()
+    .min(1, "Địa chỉ là bắt buộc")
+    .max(500, "Địa chỉ tối đa 500 ký tự")
+    .trim(),
+
+  phone: z
+    .string()
+    .min(1, "Số điện thoại là bắt buộc")
+    .max(20, "Số điện thoại tối đa 20 ký tự")
+    .trim(),
+
+  email: z
+    .string()
+    .min(1, "Email là bắt buộc")
+    .max(255, "Email tối đa 255 ký tự")
+    .email("Email không hợp lệ")
+    .trim(),
+});
+
+export type CompanyInput = z.infer<typeof companySchema>;
+
+export const companyUpdateSchema = companySchema.partial();

package/src/schemas/forgot-passward-schema.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+
+export const ForgotPasswordSchema = z.object({
+  email: z
+    .string()
+    .email({ message: "Invalid email address" })
+    .toLowerCase()
+    .trim(),
+});

package/src/schemas/index.ts

@@ -0,0 +1,30 @@
+/**
+ * Central export for all validation schemas
+ *
+ * Usage:
+ *   import { supplierSchema, materialSchema } from '@/lib/schemas'
+ */
+
+export * from "./supplier.schema";
+export * from "./material.schema";
+export * from "./material-category.schema";
+export * from "./uom.schema";
+export * from "./warehouse.schema";
+export * from "./partner-company.schema";
+export * from "./system-category-group.schema";
+export * from "./system-category.schema";
+export * from "./action.schema";
+export * from "./resource.schema";
+export * from "./material-pricing.schema";
+export * from "./user.schema";
+export * from "./role.schema";
+export * from "./user-supplier.schema";
+export * from "./system-config.schema";
+export * from "./company.schema";
+export * from "./branch.schema";
+export * from "./register-schema";
+export * from "./sign-in-schema";
+export * from "./forgot-passward-schema";
+export * from "./new-passward-schema";
+export * from "./verify-email-schema";
+export * from "./coming-soon-schema";