@goplusvn/core 0.1.0 → 0.1.2

package/src/crud/lib/import-export-service.test.ts

@@ -0,0 +1,290 @@
+import { describe, it, expect, vi } from "vitest";
+import {
+  parseCSV,
+  parseJSON,
+  validateImportData,
+  exportToCSV,
+  exportToJSON,
+  exportToXLSX,
+} from "./import-export-service";
+import type { EntityConfig } from "../../types";
+import * as XLSX from "xlsx";
+
+// Polyfill File.text() if missing or just mock it on instances
+function createFile(content: string, name: string, type: string) {
+  const file = new File([content], name, { type });
+  // Mock text method
+  Object.defineProperty(file, "text", {
+    value: () => Promise.resolve(content),
+    writable: true,
+  });
+  // Mock arrayBuffer
+  Object.defineProperty(file, "arrayBuffer", {
+    value: () => Promise.resolve(new TextEncoder().encode(content)),
+    writable: true,
+  });
+  return file;
+}
+
+// Mock xlsx
+vi.mock("xlsx", () => ({
+  read: vi.fn(() => ({
+    SheetNames: ["Sheet1"],
+    Sheets: {
+      Sheet1: {},
+    },
+  })),
+  utils: {
+    sheet_to_json: vi.fn(() => [{ name: "Alice", age: 30 }]),
+    book_new: vi.fn(() => ({})),
+    aoa_to_sheet: vi.fn(),
+    book_append_sheet: vi.fn(),
+    json_to_sheet: vi.fn(),
+  },
+  write: vi.fn(() => new ArrayBuffer(8)),
+}));
+
+describe("ImportExportService", () => {
+  describe("parseCSV", () => {
+    it("should parse valid CSV", async () => {
+      const csvContent = "name,age\nAlice,30\nBob,25";
+      const file = createFile(csvContent, "test.csv", "text/csv");
+      const result = await parseCSV(file);
+      expect(result).toHaveLength(2);
+      expect(result[0]).toEqual({ name: "Alice", age: "30" });
+      expect(result[1]).toEqual({ name: "Bob", age: "25" });
+    });
+
+    it("should handle empty file", async () => {
+      const file = createFile("", "empty.csv", "text/csv");
+      const result = await parseCSV(file);
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe("parseJSON", () => {
+    it("should parse valid JSON array", async () => {
+      const jsonContent = JSON.stringify([{ name: "Alice", age: 30 }]);
+      const file = createFile(jsonContent, "test.json", "application/json");
+      const result = await parseJSON(file);
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({ name: "Alice", age: 30 });
+    });
+
+    it("should parse single JSON object", async () => {
+      const jsonContent = JSON.stringify({ name: "Alice", age: 30 });
+      const file = createFile(jsonContent, "test.json", "application/json");
+      const result = await parseJSON(file);
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({ name: "Alice", age: 30 });
+    });
+  });
+
+  describe("validateImportData", () => {
+    const mockConfig: EntityConfig = {
+      fields: [
+        { name: "name", label: "Name", type: "text", required: true },
+        { name: "age", label: "Age", type: "number" },
+        { name: "email", label: "Email", type: "email" },
+      ],
+      apiEndpoint: "/api/test",
+      name: "test",
+      label: "Test",
+      pluralLabel: "Tests",
+      idField: "id",
+      displayField: "name",
+    } as unknown as EntityConfig; // Partial mock
+
+    it("should validate valid data", () => {
+      const data = [{ name: "Alice", age: "30", email: "alice@example.com" }];
+      const result = validateImportData(data, mockConfig);
+      expect(result.success).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("should catch required field errors", () => {
+      const data = [{ age: "30" }]; // missing name
+      const result = validateImportData(data, mockConfig);
+      expect(result.success).toBe(false);
+      expect(result.errors[0].message).toContain("Name là bắt buộc");
+    });
+
+    it("should catch type errors", () => {
+      const data = [
+        { name: "Bob", age: "invalid" },
+        { name: "Charlie", email: "not-an-email" },
+      ];
+      const result = validateImportData(data, mockConfig);
+      expect(result.success).toBe(false);
+      expect(result.errors).toHaveLength(2);
+    });
+
+    it("should validate case-insensitive options", () => {
+      const configWithOptions: EntityConfig = {
+        ...mockConfig,
+        fields: [
+          ...mockConfig.fields,
+          {
+            name: "status",
+            label: "Status",
+            type: "select",
+            options: [
+              { label: "Active", value: "active" },
+              { label: "Inactive", value: "inactive" },
+            ],
+          },
+        ],
+      };
+
+      const data = [
+        { name: "User1", status: "Active" },
+        { name: "User2", status: "ACTIVE" },
+        { name: "User3", status: "active" },
+      ];
+      const result = validateImportData(data, configWithOptions);
+      expect(result.success).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("should reject invalid options", () => {
+      const configWithOptions: EntityConfig = {
+        ...mockConfig,
+        fields: [
+          ...mockConfig.fields,
+          {
+            name: "status",
+            label: "Status",
+            type: "select",
+            options: ["red", "blue"],
+          },
+        ],
+      };
+
+      const data = [{ name: "User1", status: "green" }];
+      const result = validateImportData(data, configWithOptions);
+      expect(result.success).toBe(false);
+      expect(result.errors[0].message).toContain("Status không hợp lệ");
+    });
+  });
+
+  describe("exportToCSV", () => {
+    it("should export data to CSV", () => {
+      const data = [{ name: "Alice", age: 30 }];
+      const result = exportToCSV(data);
+      expect(result).toContain("name,age");
+      expect(result).toContain("Alice,30");
+    });
+
+    it("should handle specific fields", () => {
+      const data = [{ name: "Alice", age: 30, hidden: "secret" }];
+      const result = exportToCSV(data, ["name"]);
+      expect(result).toContain("name");
+      expect(result).not.toContain("age");
+      expect(result).toContain("Alice");
+    });
+  });
+
+  describe("exportToJSON", () => {
+    it("should export data to JSON", () => {
+      const data = [{ name: "Alice", age: 30 }];
+      const result = exportToJSON(data);
+      expect(JSON.parse(result)).toEqual(data);
+    });
+
+    it("should handle specific fields", () => {
+      const data = [{ name: "Alice", age: 30, hidden: "secret" }];
+      const result = exportToJSON(data, ["name"]);
+      const parsed = JSON.parse(result);
+      expect(parsed[0]).toHaveProperty("name");
+      expect(parsed[0]).not.toHaveProperty("age");
+    });
+  });
+
+  // Since we mocked xlsx, we can test using those mocks
+  describe("XLSX functions", () => {
+    it("should parse XLSX", async () => {
+      const { parseXLSX } = await import("./import-export-service");
+      const file = createFile(
+        "dummy",
+        "test.xlsx",
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      );
+      const result = await parseXLSX(file);
+      expect(result).toEqual([{ name: "Alice", age: 30 }]);
+    });
+
+    it("should generate XLSX template", async () => {
+      const { generateXLSXTemplate } = await import("./import-export-service");
+      const mockConfig: EntityConfig = {
+        fields: [{ name: "name", label: "Name", type: "text" }],
+        apiEndpoint: "/api",
+        name: "test",
+        label: "Test",
+        pluralLabel: "Tests",
+        idField: "id",
+        displayField: "name",
+      } as any;
+      const blob = await generateXLSXTemplate(mockConfig);
+      expect(blob).toBeInstanceOf(Blob);
+    });
+
+    it("should export to XLSX", async () => {
+      const { exportToXLSX } = await import("./import-export-service");
+      const data = [{ name: "Alice" }];
+      const blob = await exportToXLSX(data);
+      expect(blob).toBeInstanceOf(Blob);
+    });
+
+    it("should export to XLSX with specific fields", async () => {
+      const { exportToXLSX } = await import("./import-export-service");
+      const data = [{ name: "Alice", age: 30 }];
+      const blob = await exportToXLSX(data, ["name"]);
+      expect(blob).toBeInstanceOf(Blob);
+      // Verify filtered data passed to xlsx (via mock)
+      const XLSX = await import("xlsx");
+      expect(XLSX.utils.json_to_sheet).toHaveBeenCalledWith(
+        expect.arrayContaining([expect.objectContaining({ name: "Alice" })]),
+      );
+      // Should NOT check for age absence strictly on the mock call args because json_to_sheet receives the mapped array
+      // But we can check expected structure if we spy carefully.
+      // In this mock, we just check call happened.
+    });
+  });
+
+  describe("downloadFile", () => {
+    it("should trigger download", async () => {
+      const { downloadFile } = await import("./import-export-service");
+      const blob = new Blob(["test"]);
+
+      // Mock DOM
+      const link = {
+        href: "",
+        download: "",
+        click: vi.fn(),
+        style: {},
+      };
+      const createElementSpy = vi
+        .spyOn(document, "createElement")
+        .mockReturnValue(link as any);
+      const appendChildSpy = vi
+        .spyOn(document.body, "appendChild")
+        .mockImplementation(() => link as any);
+      const removeChildSpy = vi
+        .spyOn(document.body, "removeChild")
+        .mockImplementation(() => link as any);
+
+      // Mock URL
+      global.URL.createObjectURL = vi.fn(() => "blob:url");
+      global.URL.revokeObjectURL = vi.fn();
+
+      downloadFile(blob, "test.csv");
+
+      expect(createElementSpy).toHaveBeenCalledWith("a");
+      expect(link.download).toBe("test.csv");
+      expect(link.click).toHaveBeenCalled();
+      expect(appendChildSpy).toHaveBeenCalled();
+      expect(removeChildSpy).toHaveBeenCalled();
+      expect(global.URL.revokeObjectURL).toHaveBeenCalledWith("blob:url");
+    });
+  });
+});

package/src/crud/lib/import-export-service.ts

@@ -0,0 +1,352 @@
+import type { EntityConfig, ImportOptions, ImportResult } from "../../types";
+
+function getRowValue(
+  row: Record<string, unknown>,
+  field: { name: string; label: string },
+): unknown {
+  // Prefer machine key (field.name), but support human header (field.label)
+  // for backward compatibility with older templates.
+  if (Object.prototype.hasOwnProperty.call(row, field.name)) {
+    return row[field.name];
+  }
+  if (Object.prototype.hasOwnProperty.call(row, field.label)) {
+    return row[field.label];
+  }
+  return undefined;
+}
+
+/**
+ * Parse CSV file
+ */
+export async function parseCSV(file: File): Promise<Record<string, unknown>[]> {
+  const text = await file.text();
+  const lines = text.split("\n").filter((line) => line.trim());
+  if (lines.length === 0) return [];
+
+  const headers = lines[0].split(",").map((h) => h.trim());
+  const rows: Record<string, unknown>[] = [];
+
+  for (let i = 1; i < lines.length; i++) {
+    const values = lines[i].split(",").map((v) => v.trim());
+    const row: Record<string, unknown> = {};
+    headers.forEach((header, index) => {
+      row[header] = values[index] || "";
+    });
+    rows.push(row);
+  }
+
+  return rows;
+}
+
+/**
+ * Parse JSON file
+ */
+export async function parseJSON(
+  file: File,
+): Promise<Record<string, unknown>[]> {
+  const text = await file.text();
+  const data = JSON.parse(text);
+  return Array.isArray(data) ? data : [data];
+}
+
+/**
+ * Parse XLSX file (requires xlsx library)
+ */
+export async function parseXLSX(
+  file: File,
+): Promise<Record<string, unknown>[]> {
+  // Dynamic import to avoid bundling xlsx if not needed
+  const XLSX = await import("xlsx");
+  const arrayBuffer = await file.arrayBuffer();
+  const workbook = XLSX.read(arrayBuffer, { type: "array" });
+  const firstSheet = workbook.Sheets[workbook.SheetNames[0]];
+  return XLSX.utils.sheet_to_json(firstSheet);
+}
+
+/**
+ * Parse file based on format
+ */
+export async function parseFile(
+  file: File,
+  format: ImportOptions["format"],
+): Promise<Record<string, unknown>[]> {
+  switch (format) {
+    case "csv":
+      return parseCSV(file);
+    case "json":
+      return parseJSON(file);
+    case "xlsx":
+      return parseXLSX(file);
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+  }
+}
+
+/**
+ * Validate import data against field configs
+ */
+export function validateImportData(
+  data: Record<string, unknown>[],
+  config: EntityConfig,
+  options: Partial<ImportOptions> = {},
+): ImportResult {
+  const errors: ImportResult["errors"] = [];
+  let imported = 0;
+  let failed = 0;
+
+  data.forEach((row, index) => {
+    const rowErrors: string[] = [];
+
+    config.fields.forEach((field) => {
+      if (field.hideInForm) return;
+
+      const value = getRowValue(row, { name: field.name, label: field.label });
+
+      // Required check
+      if (
+        field.required &&
+        (value === null || value === undefined || value === "")
+      ) {
+        rowErrors.push(`${field.label} là bắt buộc`);
+      }
+
+      // List validation (check if value is in options)
+      if (
+        value !== null &&
+        value !== undefined &&
+        value !== "" &&
+        field.options &&
+        field.options.length > 0
+      ) {
+        const stringValue = String(value).toLowerCase();
+        const validOption = field.options.some((opt) => {
+          const isObject = typeof opt === "object" && opt !== null;
+          const optValue = isObject ? opt.value : opt;
+          return String(optValue).toLowerCase() === stringValue;
+        });
+
+        if (!validOption) {
+          // Collect valid labels for error message
+          const validLabels = field.options
+            .map((opt) => {
+              const isObject = typeof opt === "object" && opt !== null;
+              return isObject ? (opt as any).label : String(opt);
+            })
+            .join(", ");
+          rowErrors.push(
+            `${field.label} không hợp lệ. Chỉ chấp nhận: ${validLabels}`,
+          );
+        }
+      } else if (value !== null && value !== undefined && value !== "") {
+        // Type validation (only if not a list field or validated above)
+        switch (field.type) {
+          case "email":
+            if (
+              typeof value === "string" &&
+              !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)
+            ) {
+              rowErrors.push(`${field.label} phải là email hợp lệ`);
+            }
+            break;
+          case "number":
+          case "integer":
+            if (isNaN(Number(value))) {
+              rowErrors.push(`${field.label} phải là số`);
+            }
+            break;
+        }
+      }
+      // End validation
+    });
+
+    if (rowErrors.length > 0) {
+      failed++;
+      rowErrors.forEach((error) => {
+        errors.push({
+          row: index + 1,
+          field: "",
+          message: error,
+        });
+      });
+    } else {
+      imported++;
+    }
+  });
+
+  return {
+    success: failed === 0 || options.skipErrors === true,
+    imported,
+    failed,
+    errors,
+  };
+}
+
+/**
+ * Generate CSV template from config
+ */
+export function generateCSVTemplate(config: EntityConfig): string {
+  const headers = config.fields
+    .filter((field) => !field.hideInForm || field.showInImport)
+    .map((field) => field.label);
+
+  return headers.join(",") + "\n";
+}
+
+/**
+ * Generate JSON template from config
+ */
+export function generateJSONTemplate(
+  config: EntityConfig,
+): Record<string, unknown> {
+  const template: Record<string, unknown> = {};
+
+  config.fields
+    .filter((field) => !field.hideInForm || field.showInImport)
+    .forEach((field) => {
+      // For JSON, we still use technical names as keys because JSON is developer-centric
+      // and usually requires strict structure.
+      template[field.name] = field.defaultValue || "";
+    });
+
+  return template;
+}
+
+/**
+ * Generate XLSX template (requires xlsx library)
+ */
+export async function generateXLSXTemplate(
+  config: EntityConfig,
+): Promise<Blob> {
+  const XLSX = await import("xlsx");
+
+  const importHeaders = config.fields
+    .filter((field) => !field.hideInForm || field.showInImport)
+    .map((field) => field.label);
+
+  const workbook = XLSX.utils.book_new();
+
+  // Sheet 1: actual import template (machine headers)
+  const templateSheet = XLSX.utils.aoa_to_sheet([importHeaders]);
+  XLSX.utils.book_append_sheet(workbook, templateSheet, "Import");
+
+  // Sheet 2: guide for humans (doesn't affect parsing because parser reads first sheet)
+  const guideRows = [
+    ["field", "label", "type", "required"],
+    ...config.fields
+      .filter((field) => !field.hideInForm || field.showInImport)
+      .map((field) => [
+        field.name,
+        field.label,
+        field.type,
+        field.required ? "yes" : "no",
+      ]),
+  ];
+  const guideSheet = XLSX.utils.aoa_to_sheet(guideRows);
+  XLSX.utils.book_append_sheet(workbook, guideSheet, "Guide");
+
+  const buffer = XLSX.write(workbook, { type: "array", bookType: "xlsx" });
+  return new Blob([buffer], {
+    type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  });
+}
+
+/**
+ * Export data to CSV
+ */
+export function exportToCSV(
+  data: Record<string, unknown>[],
+  fields?: string[],
+): string {
+  if (data.length === 0) return "";
+
+  const keys = fields || Object.keys(data[0]);
+  const headers = keys.join(",");
+  const rows = data.map((row) =>
+    keys.map((key) => String(row[key] || "")).join(","),
+  );
+
+  return [headers, ...rows].join("\n");
+}
+
+/**
+ * Export data to JSON
+ */
+export function exportToJSON(
+  data: Record<string, unknown>[],
+  fields?: string[],
+): string {
+  if (fields) {
+    const filtered = data.map((row) => {
+      const filteredRow: Record<string, unknown> = {};
+      fields.forEach((field) => {
+        filteredRow[field] = row[field];
+      });
+      return filteredRow;
+    });
+    return JSON.stringify(filtered, null, 2);
+  }
+
+  return JSON.stringify(data, null, 2);
+}
+
+/**
+ * Export data to XLSX (requires xlsx library)
+ */
+export async function exportToXLSX(
+  data: Record<string, unknown>[],
+  fields?: string[],
+): Promise<Blob> {
+  const XLSX = await import("xlsx");
+
+  let exportData: Record<string, unknown>[];
+  if (fields) {
+    exportData = data.map((row) => {
+      const filteredRow: Record<string, unknown> = {};
+      fields.forEach((field) => {
+        const value = row[field];
+        filteredRow[field] = Array.isArray(value)
+          ? value.join(", ")
+          : typeof value === "object" && value !== null
+            ? JSON.stringify(value)
+            : value;
+      });
+      return filteredRow;
+    });
+  } else {
+    exportData = data.map((row) => {
+      const newRow: Record<string, unknown> = {};
+      Object.keys(row).forEach((key) => {
+        const value = row[key];
+        newRow[key] = Array.isArray(value)
+          ? value.join(", ")
+          : typeof value === "object" && value !== null
+            ? JSON.stringify(value)
+            : value;
+      });
+      return newRow;
+    });
+  }
+
+  const worksheet = XLSX.utils.json_to_sheet(exportData);
+  const workbook = XLSX.utils.book_new();
+  XLSX.utils.book_append_sheet(workbook, worksheet, "Data");
+
+  const buffer = XLSX.write(workbook, { type: "array", bookType: "xlsx" });
+  return new Blob([buffer], {
+    type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  });
+}
+
+/**
+ * Download file
+ */
+export function downloadFile(blob: Blob, filename: string): void {
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = filename;
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+  URL.revokeObjectURL(url);
+}