@goplusvn/core 0.1.0 → 0.1.2

package/src/crud/lib/crud-validator.ts

@@ -0,0 +1,247 @@
+import { z } from "zod";
+
+import type { EntityConfig, FieldConfig } from "../../types";
+
+import { getFieldDefaultValue } from "./crud-utils";
+
+/**
+ * Build Zod schema from FieldConfig
+ */
+export function buildSchemaFromConfig(
+  fields: FieldConfig[],
+): z.ZodObject<Record<string, z.ZodTypeAny>> {
+  const schemaObject: Record<string, z.ZodTypeAny> = {};
+
+  fields.forEach((field) => {
+    if (field.hideInForm) {
+      return; // Skip hidden fields
+    }
+
+    let fieldSchema: z.ZodTypeAny;
+
+    // Base type schema
+    switch (field.type) {
+      case "text":
+      case "email":
+      case "url":
+        fieldSchema = z.string();
+        break;
+      case "number":
+        fieldSchema = z.preprocess(
+          (val) =>
+            val === "" || val === null || val === undefined
+              ? undefined
+              : Number(val),
+          z.number(),
+        );
+        break;
+      case "integer":
+        fieldSchema = z.preprocess(
+          (val) =>
+            val === "" || val === null || val === undefined
+              ? undefined
+              : Number(val),
+          z.number().int(),
+        );
+        break;
+      case "textarea":
+        fieldSchema = z.string();
+        break;
+      case "boolean":
+        fieldSchema = z.boolean();
+        break;
+      case "switch":
+        // Switch can be boolean or string (active/inactive)
+        // We default to string validation here as it's primarily used for status
+        fieldSchema = z.string().or(z.boolean());
+        break;
+      case "date":
+      case "datetime":
+      case "time":
+        fieldSchema = z.string().datetime().or(z.date()).or(z.null());
+        break;
+      case "select":
+        fieldSchema = z.string();
+        break;
+      case "multiselect":
+        fieldSchema = z.array(z.string());
+        break;
+      case "file":
+      case "image":
+        fieldSchema = z.instanceof(File).or(z.string()).or(z.null());
+        break;
+      case "json":
+        fieldSchema = z.unknown();
+        break;
+      case "custom":
+        // For custom fields, use unknown or provided validation
+        fieldSchema = field.validation || z.unknown();
+        break;
+      default:
+        fieldSchema = z.string();
+    }
+
+    // Apply required validation
+    if (field.required) {
+      if (field.type === "multiselect") {
+        // Array: use min length
+        fieldSchema = (fieldSchema as z.ZodArray<z.ZodString>).min(
+          1,
+          `${field.label} is required`,
+        );
+      } else if (field.type === "boolean") {
+        // Boolean fields are always required (true/false)
+        // No need to add required message
+      } else if (
+        field.type === "text" ||
+        field.type === "email" ||
+        field.type === "url" ||
+        field.type === "textarea" ||
+        field.type === "select"
+      ) {
+        // String: use min length
+        fieldSchema = (fieldSchema as z.ZodString).min(
+          1,
+          `${field.label} is required`,
+        );
+      } else if (field.type === "number" || field.type === "integer") {
+        // Number: Zod numbers are required by default if not optional
+        // No additional validation needed
+      } else if (
+        field.type === "date" ||
+        field.type === "datetime" ||
+        field.type === "time"
+      ) {
+        // Date/datetime: use refine to ensure it's not null/undefined
+        fieldSchema = (fieldSchema as z.ZodTypeAny).refine(
+          (val) => val !== null && val !== undefined,
+          {
+            message: `${field.label} is required`,
+          },
+        );
+      } else {
+        // Other types (file, image, json, custom): use refine
+        fieldSchema = (fieldSchema as z.ZodTypeAny).refine(
+          (val) => val !== null && val !== undefined,
+          {
+            message: `${field.label} is required`,
+          },
+        );
+      }
+    } else {
+      // Make optional - allow null and undefined
+      if (field.type === "multiselect") {
+        fieldSchema = (fieldSchema as z.ZodArray<z.ZodString>)
+          .nullable()
+          .optional();
+      } else {
+        fieldSchema = (fieldSchema as z.ZodTypeAny).nullable().optional();
+      }
+    }
+
+    // Apply custom validation if provided
+    if (field.validation) {
+      fieldSchema = field.validation as z.ZodTypeAny;
+    }
+
+    // Apply type-specific validations
+    if (field.type === "email") {
+      fieldSchema = z.string().email(`${field.label} must be a valid email`);
+    } else if (field.type === "url") {
+      fieldSchema = z.string().url(`${field.label} must be a valid URL`);
+    }
+
+    schemaObject[field.name] = fieldSchema;
+  });
+
+  return z.object(schemaObject);
+}
+
+/**
+ * Validate form data against EntityConfig
+ */
+export function validateFormData(
+  data: Record<string, unknown>,
+  config: EntityConfig,
+): { valid: boolean; errors: Record<string, string> } {
+  const schema = buildSchemaFromConfig(config.fields);
+  const result = schema.safeParse(data);
+
+  if (result.success) {
+    return { valid: true, errors: {} };
+  }
+
+  const errors: Record<string, string> = {};
+  result.error.errors.forEach((error) => {
+    const fieldName = error.path[0] as string;
+    errors[fieldName] = error.message;
+  });
+
+  return { valid: false, errors };
+}
+
+/**
+ * Get default values object from config
+ */
+export function getDefaultValuesFromConfig(
+  config: EntityConfig,
+): Record<string, unknown> {
+  const defaults: Record<string, unknown> = {};
+
+  config.fields.forEach((field) => {
+    if (!field.hideInForm) {
+      defaults[field.name] = getFieldDefaultValue(field);
+    }
+  });
+
+  return defaults;
+}
+
+/**
+ * Transform form data to match API format
+ */
+export function transformFormData(
+  data: Record<string, unknown>,
+  config: EntityConfig,
+): Record<string, unknown> {
+  const transformed: Record<string, unknown> = {};
+
+  config.fields.forEach((field) => {
+    const value = data[field.name];
+
+    // Nếu có transform.output thì ưu tiên dùng (ví dụ: mảng -> CSV string)
+    if (field.transform?.output) {
+      transformed[field.name] = field.transform.output(value);
+      return;
+    }
+
+    // Handle different field types
+    switch (field.type) {
+      case "date":
+      case "datetime":
+      case "time":
+        if (value instanceof Date) {
+          transformed[field.name] = value.toISOString();
+        } else if (typeof value === "string") {
+          transformed[field.name] = value;
+        }
+        break;
+      case "number":
+      case "integer":
+        if (value !== null && value !== undefined && value !== "") {
+          transformed[field.name] = Number(value);
+        }
+        break;
+      case "boolean":
+        transformed[field.name] = Boolean(value);
+        break;
+      case "multiselect":
+        transformed[field.name] = Array.isArray(value) ? value : [];
+        break;
+      default:
+        transformed[field.name] = value;
+    }
+  });
+
+  return transformed;
+}

package/src/crud/lib/data-loader.ts

@@ -0,0 +1,234 @@
+import type { DataSource } from "../../types";
+
+import { crudConfig } from "../../configs";
+
+interface CachedData {
+  data: Array<{ label: string; value: string | number | boolean }>;
+  timestamp: number;
+}
+
+export class DataLoader {
+  private cache = new Map<string, CachedData>();
+  // Cache enabled để tránh duplicate API calls
+  // Configure via CRUD_CACHE_ENABLED env variable (default: true)
+  private cacheEnabled = crudConfig.dataLoader.cacheEnabled;
+  // Default cache time in milliseconds
+  // Configure via CRUD_CACHE_TIME_MS env variable (default: 300000 = 5 minutes)
+  private defaultCacheTime = crudConfig.dataLoader.defaultCacheTime;
+  // Track pending requests to prevent duplicate calls
+  private pendingRequests = new Map<
+    string,
+    Promise<Array<{ label: string; value: string | number | boolean }>>
+  >();
+
+  /**
+   * Load options from dataSource (static or API)
+   */
+  async loadOptions(
+    dataSource: DataSource,
+  ): Promise<Array<{ label: string; value: string | number | boolean }>> {
+    // Static data source
+    if (dataSource.type === "static" && dataSource.options) {
+      return dataSource.options;
+    }
+
+    // API data source
+    if (dataSource.type === "api" && dataSource.endpoint) {
+      return this.loadFromAPI(dataSource);
+    }
+
+    throw new Error("Invalid dataSource configuration");
+  }
+
+  /**
+   * Load options from API with caching
+   */
+  private async loadFromAPI(
+    dataSource: DataSource,
+  ): Promise<Array<{ label: string; value: string | number | boolean }>> {
+    const cacheKey = this.getCacheKey(dataSource);
+
+    // Check cache
+    if (this.cacheEnabled) {
+      const cached = this.cache.get(cacheKey);
+      if (cached) {
+        const cacheTime = dataSource.cacheTime || this.defaultCacheTime;
+        if (Date.now() - cached.timestamp < cacheTime) {
+          console.log("DataLoader: Using cached data for", cacheKey);
+          return cached.data;
+        }
+        // Cache expired, remove it
+        this.cache.delete(cacheKey);
+      }
+    }
+
+    // Check if there's already a pending request for this cacheKey
+    const pendingRequest = this.pendingRequests.get(cacheKey);
+    if (pendingRequest) {
+      console.log("DataLoader: Reusing pending request for", cacheKey);
+      return pendingRequest;
+    }
+
+    // Create new request promise
+    const requestPromise = this.fetchFromAPI(dataSource, cacheKey);
+
+    // Store pending request
+    this.pendingRequests.set(cacheKey, requestPromise);
+
+    // Clean up after request completes (success or error)
+    requestPromise
+      .finally(() => {
+        this.pendingRequests.delete(cacheKey);
+      })
+      .catch(() => {
+        // Error already logged in fetchFromAPI
+      });
+
+    return requestPromise;
+  }
+
+  /**
+   * Actually fetch data from API
+   */
+  private async fetchFromAPI(
+    dataSource: DataSource,
+    cacheKey: string,
+  ): Promise<Array<{ label: string; value: string | number | boolean }>> {
+    try {
+      // Build URL with params
+      const url = new URL(dataSource.endpoint!, window.location.origin);
+      if (dataSource.params) {
+        Object.entries(dataSource.params).forEach(([key, value]) => {
+          url.searchParams.append(key, String(value));
+        });
+      }
+
+      console.log("DataLoader: Fetching from API", url.toString());
+      // Fetch from API
+      const response = await fetch(url.toString());
+
+      // Check Content-Type first
+      const contentType = response.headers.get("content-type");
+      const isJSON = contentType && contentType.includes("application/json");
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        console.error(
+          `API fetch failed (${response.status}):`,
+          errorText.substring(0, 200),
+        );
+        throw new Error(`Failed to fetch data: ${response.statusText}`);
+      }
+
+      // Check Content-Type to ensure it's JSON
+      if (!isJSON) {
+        const text = await response.text();
+        console.error("Invalid Content-Type:", contentType);
+        console.error("Response text:", text.substring(0, 200));
+        throw new Error(
+          `Invalid response format. Expected JSON but got ${contentType || "unknown"}. The endpoint might not exist or returned an error page.`,
+        );
+      }
+
+      const data = await response.json();
+      console.log("DataLoader received data:", {
+        endpoint: dataSource.endpoint,
+        data,
+      });
+
+      // Transform data
+      let options: Array<{ label: string; value: string | number | boolean }>;
+
+      if (dataSource.transform) {
+        // Use custom transform function
+        options = dataSource.transform(data);
+      } else if (Array.isArray(data)) {
+        // Default transformation - direct array
+        const labelField = dataSource.labelField || "label";
+        const valueField = dataSource.valueField || "value";
+
+        options = data.map((item) => ({
+          label: String(item[labelField]),
+          value: item[valueField],
+        }));
+      } else if (data.data && Array.isArray(data.data)) {
+        // Handle paginated response with 'data' property
+        const labelField = dataSource.labelField || "label";
+        const valueField = dataSource.valueField || "value";
+
+        options = data.data.map((item: Record<string, unknown>) => ({
+          label: String(item[labelField]),
+          value: item[valueField],
+        }));
+      } else if (data.items && Array.isArray(data.items)) {
+        // Handle paginated response with 'items' property (common in CRUD APIs)
+        const labelField = dataSource.labelField || "label";
+        const valueField = dataSource.valueField || "value";
+
+        options = data.items.map((item: Record<string, unknown>) => ({
+          label: String(item[labelField]),
+          value: item[valueField],
+        }));
+      } else {
+        console.error("Invalid API response format:", data);
+        throw new Error(
+          `Invalid API response format. Expected array, {data: []}, or {items: []}, but got: ${JSON.stringify(data).substring(0, 200)}`,
+        );
+      }
+
+      // Cache the result
+      if (this.cacheEnabled) {
+        this.cache.set(cacheKey, {
+          data: options,
+          timestamp: Date.now(),
+        });
+      }
+
+      return options;
+    } catch (error) {
+      console.error("Error loading data from API:", error);
+      throw error;
+    }
+  }
+
+  /**
+   * Generate cache key from dataSource
+   */
+  private getCacheKey(dataSource: DataSource): string {
+    if (dataSource.type === "static") {
+      return `static-${JSON.stringify(dataSource.options)}`;
+    }
+
+    const params = dataSource.params ? JSON.stringify(dataSource.params) : "";
+    return `${dataSource.endpoint}-${dataSource.labelField}-${dataSource.valueField}-${params}`;
+  }
+
+  /**
+   * Clear cache for a specific endpoint or all cache
+   */
+  clearCache(endpoint?: string): void {
+    if (endpoint) {
+      // Clear specific endpoint cache
+      const keysToDelete: string[] = [];
+      this.cache.forEach((_, key) => {
+        if (key.startsWith(endpoint)) {
+          keysToDelete.push(key);
+        }
+      });
+      keysToDelete.forEach((key) => this.cache.delete(key));
+    } else {
+      // Clear all cache
+      this.cache.clear();
+    }
+  }
+
+  /**
+   * Get cache size
+   */
+  getCacheSize(): number {
+    return this.cache.size;
+  }
+}
+
+// Singleton instance
+export const dataLoader = new DataLoader();