@goplusvn/core 0.1.0 → 0.1.1

package/src/crud/lib/field-calculator.ts

@@ -0,0 +1,241 @@
+/**
+ * Field Calculator - Handles field calculations based on dependencies
+ */
+
+import type { FieldConfig } from "../../types";
+
+/**
+ * Safe expression evaluator - replaces eval() to prevent code injection
+ * Supports: +, -, *, /, (), numbers
+ * Uses a simple recursive descent parser - NO eval() or Function()
+ */
+function safeEvaluate(expression: string): number {
+  // Remove all whitespace
+  expression = expression.replace(/\s+/g, "");
+
+  // Validate expression only contains safe characters
+  // Allowed: numbers, operators (+, -, *, /), parentheses, and decimal points
+  if (!/^[0-9+\-*/().]+$/.test(expression)) {
+    throw new Error("Invalid characters in expression");
+  }
+
+  let index = 0;
+
+  // Parse a number
+  function parseNumber(): number {
+    let numStr = "";
+    while (index < expression.length && /[0-9.]/.test(expression[index])) {
+      numStr += expression[index];
+      index++;
+    }
+    const num = parseFloat(numStr);
+    if (isNaN(num)) {
+      throw new Error(`Invalid number: ${numStr}`);
+    }
+    return num;
+  }
+
+  // Parse expression with addition and subtraction
+  function parseExpression(): number {
+    let result = parseTerm();
+    while (index < expression.length) {
+      const op = expression[index];
+      if (op === "+") {
+        index++;
+        result += parseTerm();
+      } else if (op === "-") {
+        index++;
+        result -= parseTerm();
+      } else {
+        break;
+      }
+    }
+    return result;
+  }
+
+  // Parse term with multiplication and division
+  function parseTerm(): number {
+    let result = parseFactor();
+    while (index < expression.length) {
+      const op = expression[index];
+      if (op === "*") {
+        index++;
+        result *= parseFactor();
+      } else if (op === "/") {
+        index++;
+        const divisor = parseFactor();
+        if (divisor === 0) {
+          throw new Error("Division by zero");
+        }
+        result /= divisor;
+      } else {
+        break;
+      }
+    }
+    return result;
+  }
+
+  // Parse factor (number or parenthesized expression)
+  function parseFactor(): number {
+    if (index >= expression.length) {
+      throw new Error("Unexpected end of expression");
+    }
+
+    if (expression[index] === "(") {
+      index++; // skip '('
+      const result = parseExpression();
+      if (index >= expression.length || expression[index] !== ")") {
+        throw new Error("Missing closing parenthesis");
+      }
+      index++; // skip ')'
+      return result;
+    }
+
+    if (expression[index] === "-") {
+      index++; // unary minus
+      return -parseFactor();
+    }
+
+    if (expression[index] === "+") {
+      index++; // unary plus
+      return parseFactor();
+    }
+
+    return parseNumber();
+  }
+
+  try {
+    const result = parseExpression();
+    if (index < expression.length) {
+      throw new Error(
+        `Unexpected character: ${expression[index]} at position ${index}`,
+      );
+    }
+    return result;
+  } catch (error) {
+    throw new Error(
+      `Invalid expression: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+}
+
+/**
+ * Sanitize and validate field names
+ */
+function isValidFieldName(name: string): boolean {
+  // Only allow alphanumeric and underscore, must start with letter or underscore
+  return /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name);
+}
+
+/**
+ * Evaluate a formula string or function
+ * SECURITY: No longer uses eval() - uses safe evaluator instead
+ */
+export function evaluateFormula(
+  formula: string | ((values: Record<string, unknown>) => unknown),
+  values: Record<string, unknown>,
+): unknown {
+  if (typeof formula === "function") {
+    return formula(values);
+  }
+
+  // Simple formula parser for common operations
+  // Supports: +, -, *, /, ()
+  try {
+    // Replace field names with their values
+    let expression = formula.trim();
+    const fieldNames = Object.keys(values);
+
+    // Validate all field names first
+    fieldNames.forEach((fieldName) => {
+      if (!isValidFieldName(fieldName)) {
+        throw new Error(`Invalid field name: ${fieldName}`);
+      }
+    });
+
+    // Replace field names with their numeric values
+    fieldNames.forEach((fieldName) => {
+      const value = values[fieldName];
+      const numValue = Number(value);
+      if (!isNaN(numValue) && isFinite(numValue)) {
+        // Replace field name with its numeric value
+        // Use word boundary to avoid partial matches
+        expression = expression.replace(
+          new RegExp(`\\b${fieldName}\\b`, "g"),
+          String(numValue),
+        );
+      } else {
+        // If field value is not a valid number, throw error
+        throw new Error(
+          `Field "${fieldName}" must be a valid number for calculation`,
+        );
+      }
+    });
+
+    // Validate expression after replacement
+    // Check that all field names have been replaced
+    const remainingFieldNames = fieldNames.filter((fieldName) => {
+      return new RegExp(`\\b${fieldName}\\b`).test(expression);
+    });
+
+    if (remainingFieldNames.length > 0) {
+      throw new Error(
+        `Fields not found in values: ${remainingFieldNames.join(", ")}`,
+      );
+    }
+
+    // Evaluate the expression safely (no eval!)
+    return safeEvaluate(expression);
+  } catch (error) {
+    console.error("Error evaluating formula:", error);
+    return null;
+  }
+}
+
+/**
+ * Calculate field value based on dependencies
+ */
+export function calculateFieldValue(
+  field: FieldConfig,
+  formValues: Record<string, unknown>,
+): unknown {
+  if (!field.calculate) return undefined;
+
+  const { dependsOn, formula } = field.calculate;
+
+  // Get values of dependent fields
+  const dependentValues: Record<string, unknown> = {};
+  dependsOn.forEach((depField) => {
+    dependentValues[depField] = formValues[depField];
+  });
+
+  // Check if all required fields have values
+  const hasAllValues = dependsOn.every(
+    (depField) =>
+      formValues[depField] !== undefined &&
+      formValues[depField] !== null &&
+      formValues[depField] !== "",
+  );
+
+  if (!hasAllValues) {
+    return undefined;
+  }
+
+  // Evaluate formula
+  return evaluateFormula(formula, dependentValues);
+}
+
+/**
+ * Get all fields that depend on a given field
+ */
+export function getDependentFields(
+  fieldName: string,
+  allFields: FieldConfig[],
+): FieldConfig[] {
+  return allFields.filter(
+    (field) =>
+      field.calculate?.dependsOn?.includes(fieldName) ||
+      field.dependencies?.fields?.includes(fieldName) ||
+      field.cascade?.triggerField === fieldName,
+  );
+}

package/src/crud/lib/field-formatter.ts

@@ -0,0 +1,240 @@
+/**
+ * Field Formatter - Handles field value formatting for display
+ */
+
+import type { FieldConfig } from "../../types";
+
+/**
+ * Format a value based on field configuration
+ */
+export function formatFieldValue(value: unknown, field: FieldConfig): string {
+  if (value === undefined || value === null || value === "") {
+    return "";
+  }
+
+  // Apply output transformation if exists
+  if (field.transform?.output) {
+    value = field.transform.output(value);
+  }
+
+  // Apply formatting if exists
+  // Priority: Explicit format config
+  if (field.format) {
+    const { type, options = {} } = field.format;
+
+    switch (type) {
+      case "currency":
+        return formatCurrency(value, options);
+
+      case "percentage":
+        return formatPercentage(value, options);
+
+      case "number":
+        return formatNumber(value, options);
+
+      case "date":
+        return formatDate(value, options);
+
+      case "datetime":
+        return formatDateTime(value, options);
+
+      case "custom":
+        if (options.custom) {
+          return options.custom(value);
+        }
+        return String(value);
+
+      default:
+        return String(value);
+    }
+  }
+
+  // Fallback: Default formatting based on field type
+  switch (field.type) {
+    case "integer":
+      return formatNumber(value, { useGrouping: true, decimals: 0 });
+
+    case "number":
+      return formatNumber(value, { useGrouping: true });
+
+    case "date":
+      return formatDate(value, {});
+
+    case "datetime":
+      return formatDateTime(value, {});
+
+    case "boolean":
+      return value ? "Yes" : "No";
+
+    case "select":
+    case "multiselect":
+      if (field.options && Array.isArray(field.options)) {
+        // Handle multiselect
+        if (field.type === "multiselect" && Array.isArray(value)) {
+          return value
+            .map((val) => {
+              const option = field.options?.find((opt) => {
+                const optValue = typeof opt === "object" ? opt.value : opt;
+                return String(optValue) === String(val);
+              });
+              return option
+                ? typeof option === "object"
+                  ? option.label
+                  : String(option)
+                : String(val);
+            })
+            .join(", ");
+        }
+
+        // Handle single select
+        const option = field.options.find((opt) => {
+          const optValue = typeof opt === "object" ? opt.value : opt;
+          const valToCheck =
+            typeof value === "object" && value !== null
+              ? (value as Record<string, unknown>).value || value
+              : value;
+          return String(optValue) === String(valToCheck);
+        });
+
+        if (option) {
+          return typeof option === "object" ? option.label : String(option);
+        }
+      }
+      return String(value);
+  }
+
+  return String(value);
+}
+
+/**
+ * Format as currency
+ */
+function formatCurrency(
+  value: unknown,
+  options: {
+    currency?: string;
+    locale?: string;
+    decimals?: number;
+  },
+): string {
+  const numValue = Number(value);
+  if (isNaN(numValue)) return String(value);
+
+  const { currency = "USD", locale = "en-US", decimals = 2 } = options;
+
+  return new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency,
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals,
+  }).format(numValue);
+}
+
+/**
+ * Format as percentage
+ */
+function formatPercentage(
+  value: unknown,
+  options: {
+    decimals?: number;
+    locale?: string;
+  },
+): string {
+  const numValue = Number(value);
+  if (isNaN(numValue)) return String(value);
+
+  const { decimals = 2, locale = "en-US" } = options;
+
+  return new Intl.NumberFormat(locale, {
+    style: "percent",
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals,
+  }).format(numValue / 100);
+}
+
+/**
+ * Format as number
+ */
+function formatNumber(
+  value: unknown,
+  options: {
+    decimals?: number;
+    locale?: string;
+    useGrouping?: boolean;
+  },
+): string {
+  const numValue = Number(value);
+  if (isNaN(numValue)) return String(value);
+
+  const { decimals = 2, locale = "en-US", useGrouping = true } = options;
+
+  return new Intl.NumberFormat(locale, {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals,
+    useGrouping,
+  }).format(numValue);
+}
+
+/**
+ * Format as date (Asia/Ho_Chi_Minh timezone)
+ */
+function formatDate(
+  value: unknown,
+  options: {
+    dateFormat?: string;
+    locale?: string;
+  },
+): string {
+  if (!value) return "";
+
+  const date = value instanceof Date ? value : new Date(String(value));
+  if (isNaN(date.getTime())) return String(value);
+
+  const { dateFormat, locale = "en-US" } = options;
+
+  if (dateFormat) {
+    // Custom format using date-fns or similar
+    // For now, use Intl.DateTimeFormat
+    return new Intl.DateTimeFormat(locale, {
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      timeZone: "Asia/Ho_Chi_Minh",
+    }).format(date);
+  }
+
+  return new Intl.DateTimeFormat(locale, {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    timeZone: "Asia/Ho_Chi_Minh",
+  }).format(date);
+}
+
+/**
+ * Format as datetime (Asia/Ho_Chi_Minh timezone)
+ */
+function formatDateTime(
+  value: unknown,
+  options: {
+    dateFormat?: string;
+    locale?: string;
+  },
+): string {
+  if (!value) return "";
+
+  const date = value instanceof Date ? value : new Date(String(value));
+  if (isNaN(date.getTime())) return String(value);
+
+  const { dateFormat, locale = "en-US" } = options;
+
+  return new Intl.DateTimeFormat(locale, {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    timeZone: "Asia/Ho_Chi_Minh",
+  }).format(date);
+}