@goplusvn/core 0.1.0 → 0.1.1

package/src/organization/branch-service.ts

@@ -0,0 +1,299 @@
+import { branchSchema, branchUpdateSchema } from "../schemas";
+
+export interface BranchRecord {
+  id: string;
+  companyId?: string;
+  code: string;
+  name: string;
+  address?: string | null;
+  phone?: string | null;
+  email?: string | null;
+  status?: string;
+  company?: { id: string; name: string };
+}
+
+export interface BranchDbClient {
+  branch: {
+    count: (args: { where?: Record<string, unknown> }) => Promise<number>;
+    findMany: (args: {
+      where?: Record<string, unknown>;
+      orderBy?: Record<string, unknown>;
+      skip?: number;
+      take?: number;
+      include?: Record<string, unknown>;
+    }) => Promise<BranchRecord[]>;
+    findUnique: (args: {
+      where: { id?: string; code?: string };
+      include?: Record<string, unknown>;
+    }) => Promise<BranchRecord | null>;
+    create: (args: {
+      data: Record<string, unknown>;
+      include?: Record<string, unknown>;
+    }) => Promise<BranchRecord>;
+    update: (args: {
+      where: { id: string };
+      data: Record<string, unknown>;
+      include?: Record<string, unknown>;
+    }) => Promise<BranchRecord>;
+    delete: (args: { where: { id: string } }) => Promise<BranchRecord>;
+  };
+  company: {
+    findUnique: (args: {
+      where: { id: string };
+    }) => Promise<{ id: string } | null>;
+  };
+}
+
+export interface BranchListParams {
+  page?: number;
+  pageSize?: number;
+  search?: string | null;
+  companyId?: string | null;
+  status?: string | null;
+}
+
+export interface BranchListResponse {
+  data: BranchRecord[];
+  pagination: {
+    page: number;
+    pageSize: number;
+    total: number;
+    totalPages: number;
+  };
+}
+
+export class BranchServiceError extends Error {
+  status: number;
+  field?: string;
+  details?: unknown;
+
+  constructor(
+    message: string,
+    status: number,
+    options?: { field?: string; details?: unknown },
+  ) {
+    super(message);
+    this.name = "BranchServiceError";
+    this.status = status;
+    this.field = options?.field;
+    this.details = options?.details;
+  }
+}
+
+const BRANCH_INCLUDE = {
+  company: {
+    select: { id: true, name: true },
+  },
+};
+
+const ensureUserId = (userId?: string) => {
+  if (!userId) {
+    throw new BranchServiceError("Unauthorized", 401);
+  }
+};
+
+export async function listBranches(
+  db: BranchDbClient,
+  params: BranchListParams,
+): Promise<BranchListResponse> {
+  const page = Number(params.page || 1);
+  const pageSize = Math.min(Number(params.pageSize || 10), 100);
+  const skip = (page - 1) * pageSize;
+
+  const search = params.search?.trim() || undefined;
+  const companyId = params.companyId?.trim() || undefined;
+  const status = params.status?.trim() || undefined;
+
+  const where: Record<string, unknown> = {};
+
+  if (search) {
+    where.OR = [
+      { name: { contains: search, mode: "insensitive" } },
+      { code: { contains: search, mode: "insensitive" } },
+      { email: { contains: search, mode: "insensitive" } },
+    ];
+  }
+
+  if (companyId) {
+    where.companyId = companyId;
+  }
+
+  if (status) {
+    where.status = status;
+  }
+
+  // ⚡ Bolt: Run count and findMany concurrently to reduce latency
+  const [total, data] = await Promise.all([
+    db.branch.count({ where }),
+    db.branch.findMany({
+      where,
+      orderBy: { name: "asc" },
+      skip,
+      take: pageSize,
+      include: BRANCH_INCLUDE,
+    }),
+  ]);
+
+  return {
+    data,
+    pagination: {
+      page,
+      pageSize,
+      total,
+      totalPages: Math.ceil(total / pageSize),
+    },
+  };
+}
+
+export async function getBranchById(
+  db: BranchDbClient,
+  id: string,
+): Promise<BranchRecord> {
+  const branch = await db.branch.findUnique({
+    where: { id },
+    include: BRANCH_INCLUDE,
+  });
+
+  if (!branch) {
+    throw new BranchServiceError("Chi nhánh không tồn tại", 404);
+  }
+
+  return branch;
+}
+
+export async function createBranch(
+  db: BranchDbClient,
+  input: unknown,
+  userId?: string,
+): Promise<BranchRecord> {
+  ensureUserId(userId);
+
+  const result = branchSchema.safeParse(input);
+  if (!result.success) {
+    const errors = result.error.issues || [];
+    const firstError = errors[0];
+    throw new BranchServiceError(
+      firstError?.message || "Validation error",
+      400,
+      {
+        field: firstError?.path?.join("."),
+        details: errors,
+      },
+    );
+  }
+
+  const validData = result.data;
+
+  const existing = await db.branch.findUnique({
+    where: { code: validData.code },
+  });
+
+  if (existing) {
+    throw new BranchServiceError("Mã chi nhánh đã tồn tại", 400, {
+      field: "code",
+    });
+  }
+
+  const company = await db.company.findUnique({
+    where: { id: validData.companyId },
+  });
+
+  if (!company) {
+    throw new BranchServiceError("Công ty không tồn tại", 400, {
+      field: "companyId",
+    });
+  }
+
+  return db.branch.create({
+    data: {
+      id: crypto.randomUUID(),
+      companyId: validData.companyId,
+      code: validData.code,
+      name: validData.name,
+      address: validData.address,
+      phone: validData.phone,
+      email: validData.email,
+      status: validData.status,
+      createdBy: userId,
+      updatedAt: new Date(),
+      updatedBy: userId,
+    },
+    include: BRANCH_INCLUDE,
+  });
+}
+
+export async function updateBranch(
+  db: BranchDbClient,
+  id: string,
+  input: unknown,
+  userId?: string,
+): Promise<BranchRecord> {
+  ensureUserId(userId);
+
+  const result = branchUpdateSchema.safeParse(input);
+  if (!result.success) {
+    const errors = result.error.issues || [];
+    const firstError = errors[0];
+    throw new BranchServiceError(
+      firstError?.message || "Validation error",
+      400,
+      {
+        field: firstError?.path?.join("."),
+        details: errors,
+      },
+    );
+  }
+
+  const validData = result.data;
+  const existingBranch = await db.branch.findUnique({
+    where: { id },
+  });
+
+  if (!existingBranch) {
+    throw new BranchServiceError("Chi nhánh không tồn tại", 404);
+  }
+
+  if (validData.code && validData.code !== existingBranch.code) {
+    const duplicate = await db.branch.findUnique({
+      where: { code: validData.code },
+    });
+    if (duplicate) {
+      throw new BranchServiceError("Mã chi nhánh đã tồn tại", 400, {
+        field: "code",
+      });
+    }
+  }
+
+  if (validData.companyId) {
+    const company = await db.company.findUnique({
+      where: { id: validData.companyId },
+    });
+    if (!company) {
+      throw new BranchServiceError("Công ty không tồn tại", 400, {
+        field: "companyId",
+      });
+    }
+  }
+
+  return db.branch.update({
+    where: { id },
+    data: {
+      ...validData,
+      updatedAt: new Date(),
+      updatedBy: userId,
+    },
+    include: BRANCH_INCLUDE,
+  });
+}
+
+export async function deleteBranch(
+  db: BranchDbClient,
+  id: string,
+): Promise<BranchRecord> {
+  const branch = await db.branch.findUnique({ where: { id } });
+  if (!branch) {
+    throw new BranchServiceError("Chi nhánh không tồn tại", 404);
+  }
+
+  return db.branch.delete({ where: { id } });
+}

package/src/organization/branches.config.ts

@@ -0,0 +1,154 @@
+import { GitBranch } from "lucide-react";
+
+import type { EntityConfig } from "../types";
+
+import { STATUS_OPTIONS } from "../configs/status";
+
+export const branchesConfig: EntityConfig = {
+  name: "branch",
+  permissionResource: "branch",
+  label: "Chi nhánh",
+  pluralLabel: "Danh sách chi nhánh",
+  icon: GitBranch,
+  description: "Quản lý danh sách chi nhánh",
+  apiEndpoint: "/api/branches",
+  idField: "id",
+  displayField: "name",
+
+  fields: [
+    {
+      name: "id",
+      label: "ID",
+      type: "text",
+      hideInForm: true,
+      hideInTable: true,
+    },
+    {
+      name: "companyId",
+      label: "Công ty",
+      type: "select",
+      required: true,
+      placeholder: "Chọn công ty",
+      filterable: true,
+      dataSource: {
+        type: "api",
+        endpoint: "/api/companies",
+        labelField: "name",
+        valueField: "id",
+      },
+    },
+    {
+      name: "code",
+      label: "Mã chi nhánh",
+      type: "text",
+      required: true,
+      placeholder: "Nhập mã chi nhánh",
+      filterable: true,
+    },
+    {
+      name: "name",
+      label: "Tên chi nhánh",
+      type: "text",
+      required: true,
+      placeholder: "Nhập tên chi nhánh",
+      filterable: true,
+    },
+    {
+      name: "address",
+      label: "Địa chỉ",
+      type: "textarea",
+      required: false,
+      placeholder: "Nhập địa chỉ",
+      rows: 2,
+    },
+    {
+      name: "phone",
+      label: "Số điện thoại",
+      type: "text",
+      required: false,
+      placeholder: "Nhập số điện thoại",
+    },
+    {
+      name: "email",
+      label: "Email",
+      type: "email",
+      required: false,
+      placeholder: "Nhập email",
+    },
+    {
+      name: "status",
+      label: "Trạng thái",
+      type: "switch",
+      required: true,
+      defaultValue: "active",
+      filterable: true,
+      options: STATUS_OPTIONS,
+    },
+    {
+      name: "createdAt",
+      label: "Ngày tạo",
+      type: "datetime",
+      hideInForm: true,
+      renderCell: (value) => {
+        return new Date(value as string).toLocaleDateString("vi-VN");
+      },
+    },
+    {
+      name: "updatedAt",
+      label: "Ngày cập nhật",
+      type: "datetime",
+      hideInForm: true,
+      hideInTable: true,
+    },
+  ],
+
+  filters: [
+    {
+      name: "search",
+      label: "Tìm kiếm",
+      type: "text",
+      field: "name",
+      operator: "contains",
+    },
+    {
+      name: "companyId",
+      label: "Công ty",
+      type: "select",
+      field: "companyId",
+      operator: "eq",
+      dataSource: {
+        type: "api",
+        endpoint: "/api/companies",
+        labelField: "name",
+        valueField: "id",
+      },
+    },
+    {
+      name: "status",
+      label: "Trạng thái",
+      type: "checkbox",
+      field: "status",
+      operator: "in",
+      options: [
+        { label: "Hoạt động", value: "active" },
+        { label: "Ngừng hoạt động", value: "inactive" },
+      ],
+    },
+  ],
+
+  permissions: {
+    create: true,
+    read: true,
+    update: true,
+    delete: true,
+    export: true,
+    import: false,
+  },
+
+  features: {
+    search: true,
+    bulkActions: true,
+    export: true,
+    import: false,
+  },
+};

package/src/organization/index.ts

@@ -0,0 +1,5 @@
+// @goerp/core/organization
+// Organization shared module
+
+export * from "./branches.config";
+export * from "./branch-service";

package/src/plugin/apps-registry.ts

@@ -0,0 +1,97 @@
+// @goerp/core/plugin
+// AppsRegistry - Central registry for GoerpApp instances
+
+import type { EntityConfig, NavigationType } from "../types"
+
+import type { GoerpApp } from "./types"
+
+/**
+ * AppsRegistry - Manages registration and lookup of GoerpApp
+ * Host app registers installed apps; registry merges navigation and entity configs
+ */
+export class AppsRegistry {
+  private apps: GoerpApp[] = []
+  private appsById = new Map<string, GoerpApp>()
+
+  /**
+   * Register an app. Later registrations override earlier entity configs for same entity.
+   */
+  register(app: GoerpApp): void {
+    if (this.appsById.has(app.appId)) {
+      console.warn(`[AppsRegistry] App "${app.appId}" already registered. Replacing.`)
+    }
+    this.appsById.set(app.appId, app)
+    this.apps = Array.from(this.appsById.values())
+  }
+
+  /**
+   * Register multiple apps in order
+   */
+  registerAll(apps: GoerpApp[]): void {
+    for (const app of apps) {
+      this.register(app)
+    }
+  }
+
+  /**
+   * Get app by appId
+   */
+  getApp(appId: string): GoerpApp | undefined {
+    return this.appsById.get(appId)
+  }
+
+  /**
+   * Get all registered apps
+   */
+  getAllApps(): GoerpApp[] {
+    return [...this.apps]
+  }
+
+  /**
+   * Get merged navigation from all apps (order: registration order)
+   * Groups with same title have their items merged
+   */
+  getNavigation(): NavigationType[] {
+    const byTitle = new Map<string, NavigationType>()
+
+    for (const app of this.apps) {
+      for (const group of app.navigation) {
+        const existing = byTitle.get(group.title)
+        const items = group.items ?? []
+        if (existing) {
+          existing.items = [...(existing.items ?? []), ...items]
+        } else {
+          byTitle.set(group.title, { ...group, items: [...items] })
+        }
+      }
+    }
+    return Array.from(byTitle.values())
+  }
+
+  /**
+   * Get entity config for entity key.
+   * Later-registered apps override earlier for same entity.
+   */
+  getEntityConfig(entity: string): EntityConfig | undefined {
+    for (let i = this.apps.length - 1; i >= 0; i--) {
+      const config = this.apps[i].entityConfigs[entity]
+      if (config) return config
+    }
+    return undefined
+  }
+
+  /**
+   * Check if entity exists in any app
+   */
+  hasEntity(entity: string): boolean {
+    return this.getEntityConfig(entity) !== undefined
+  }
+
+  /**
+   * Clear all registrations (for testing)
+   */
+  clear(): void {
+    this.apps = []
+    this.appsById.clear()
+  }
+}

package/src/plugin/index.ts

@@ -0,0 +1,5 @@
+// @goerp/core/plugin
+// GoerpApp API - Plugin/App types and registry
+
+export { AppsRegistry } from "./apps-registry"
+export type { GoerpApp, RouteDefinition } from "./types"

package/src/plugin/types.ts

@@ -0,0 +1,41 @@
+// @goerp/core/plugin
+// GoerpApp types - maps to AppDefinition in core-db
+
+import type { ComponentType } from "react"
+
+import type { EntityConfig, NavigationType } from "../types"
+
+/**
+ * Route definition for /app/[appId]/[pageId]
+ * Used when an app has custom pages beyond CRUD
+ */
+export interface RouteDefinition {
+  pageId: string
+  label: string
+  path: string
+  component: ComponentType<Record<string, unknown>>
+  permission?: string
+}
+
+/**
+ * GoerpApp - Plugin/App descriptor
+ * Maps to AppDefinition.appId in core-db
+ */
+export interface GoerpApp {
+  /** Unique app identifier - maps to AppDefinition.appId */
+  appId: string
+  /** Display name */
+  name: string
+  /** Semantic version */
+  version: string
+  /** Human-readable description */
+  description?: string
+  /** Core system app (always enabled) */
+  isCore?: boolean
+  /** Navigation items for sidebar */
+  navigation: NavigationType[]
+  /** Entity configs for CRUD (/crud/[entity]) */
+  entityConfigs: Record<string, EntityConfig>
+  /** Custom routes for /app/[appId]/[pageId] */
+  routes?: RouteDefinition[]
+}

package/src/providers/index.tsx

@@ -0,0 +1,109 @@
+// @goerp/core/providers
+// Core React context providers for GoERP platform
+// Consolidated from packages/shared/providers
+
+"use client";
+
+import * as React from "react";
+import { createContext, useCallback, useEffect, useState } from "react";
+import { useCookie } from "react-use";
+import { DirectionProvider as RadixDirectionProvider } from "@radix-ui/react-direction";
+
+import type { LocaleType, SettingsType, DirectionType } from "../types";
+import type { ReactNode } from "react";
+
+// ============================================================================
+// Settings Provider
+// ============================================================================
+
+export const defaultSettings: SettingsType = {
+  theme: "blue",
+  mode: "system",
+  radius: 0.5,
+  layout: "vertical",
+  locale: "vi",
+  sidebarVariant: "sidebar",
+  sidebarCollapsible: "icon",
+  density: "comfortable",
+};
+
+export const SettingsContext = createContext<
+  | {
+      settings: SettingsType;
+      updateSettings: (newSettings: SettingsType) => void;
+      resetSettings: () => void;
+    }
+  | undefined
+>(undefined);
+
+export function SettingsProvider({
+  locale,
+  children,
+}: {
+  locale: LocaleType;
+  children: ReactNode;
+}) {
+  const [storedSettings, setStoredSettings, deleteStoredSettings] =
+    useCookie("settings");
+  const [settings, setSettings] = useState<SettingsType>(() => ({
+    ...defaultSettings,
+    locale,
+  }));
+
+  useEffect(() => {
+    if (storedSettings) {
+      try {
+        const parsedSettings = JSON.parse(storedSettings);
+        setSettings({ ...defaultSettings, ...parsedSettings });
+      } catch {
+        setSettings({ ...defaultSettings, locale });
+      }
+    } else {
+      setSettings({ ...defaultSettings, locale });
+    }
+  }, [storedSettings, locale]);
+
+  const updateSettings = useCallback(
+    (newSettings: SettingsType) => {
+      setStoredSettings(JSON.stringify(newSettings));
+      setSettings(newSettings);
+    },
+    [setStoredSettings],
+  );
+
+  const resetSettings = useCallback(() => {
+    deleteStoredSettings();
+    setSettings(defaultSettings);
+  }, [deleteStoredSettings]);
+
+  return (
+    <SettingsContext.Provider
+      value={{ settings, updateSettings, resetSettings }}
+    >
+      {children}
+    </SettingsContext.Provider>
+  );
+}
+
+// ============================================================================
+// Direction Provider
+// ============================================================================
+
+interface DirectionProviderProps {
+  direction: DirectionType;
+  children: React.ReactNode;
+}
+
+export function DirectionProvider({
+  direction,
+  children,
+}: DirectionProviderProps) {
+  return (
+    <RadixDirectionProvider dir={direction}>{children}</RadixDirectionProvider>
+  );
+}
+// ============================================================================
+// Tenant Provider
+// ============================================================================
+
+export * from "./tenant-provider";