@goplusvn/core 0.1.0 → 0.1.1

package/src/crud/lib/import-server-utils.ts

@@ -0,0 +1,109 @@
+import type { EntityConfig, FieldConfig, ImportResult } from "../../types";
+
+export function getRowValue(
+  row: Record<string, unknown>,
+  field: Pick<FieldConfig, "name" | "label">,
+): unknown {
+  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;
+}
+
+export function normalizeRowForConfig(
+  row: Record<string, unknown>,
+  config: EntityConfig,
+): Record<string, unknown> {
+  const normalized: Record<string, unknown> = { ...row };
+  config.fields.forEach((field) => {
+    normalized[field.name] = getRowValue(row, field);
+  });
+  return normalized;
+}
+
+function coerceBoolean(value: unknown): boolean | undefined {
+  if (value === undefined || value === null || value === "") return undefined;
+  if (typeof value === "boolean") return value;
+  const v = String(value).trim().toLowerCase();
+  if (["true", "1", "yes", "y", "on"].includes(v)) return true;
+  if (["false", "0", "no", "n", "off"].includes(v)) return false;
+  return undefined;
+}
+
+function coerceNumber(value: unknown): number | undefined {
+  if (value === undefined || value === null || value === "") return undefined;
+  const n = typeof value === "number" ? value : Number(String(value).trim());
+  if (Number.isNaN(n)) return undefined;
+  return n;
+}
+
+function coerceDate(value: unknown): Date | undefined {
+  if (value === undefined || value === null || value === "") return undefined;
+  if (value instanceof Date) return value;
+  const d = new Date(String(value));
+  if (Number.isNaN(d.getTime())) return undefined;
+  return d;
+}
+
+function coerceString(value: unknown): string | undefined {
+  if (value === undefined || value === null) return undefined;
+  const s = String(value);
+  return s === "" ? undefined : s;
+}
+
+function coerceStringArray(value: unknown): string[] | undefined {
+  if (value === undefined || value === null || value === "") return undefined;
+  if (Array.isArray(value)) return value.map((v) => String(v)).filter(Boolean);
+  return String(value)
+    .split(",")
+    .map((v) => v.trim())
+    .filter(Boolean);
+}
+
+export function coerceRowForConfig(
+  row: Record<string, unknown>,
+  config: EntityConfig,
+): Record<string, unknown> {
+  const normalized = normalizeRowForConfig(row, config);
+  const out: Record<string, unknown> = {};
+
+  config.fields.forEach((field) => {
+    if (field.hideInForm) return;
+
+    const raw = normalized[field.name];
+
+    switch (field.type) {
+      case "number":
+      case "integer":
+        out[field.name] = coerceNumber(raw);
+        break;
+      case "boolean":
+        out[field.name] = coerceBoolean(raw);
+        break;
+      case "date":
+      case "datetime":
+        out[field.name] = coerceDate(raw);
+        break;
+      case "multiselect":
+        out[field.name] = coerceStringArray(raw);
+        break;
+      default:
+        out[field.name] = coerceString(raw);
+        break;
+    }
+  });
+
+  return out;
+}
+
+export function emptyImportResult(): ImportResult {
+  return {
+    success: true,
+    imported: 0,
+    failed: 0,
+    errors: [],
+  };
+}

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

@@ -0,0 +1,241 @@
+import type { CrudQueryParams, CrudResponse } from "../../types";
+
+import { crudConfig } from "../../configs";
+
+import { crudService } from "./crud-service";
+
+interface LazyLoadOptions {
+  endpoint: string;
+  initialPageSize?: number;
+  loadMoreSize?: number;
+}
+
+interface LazyLoadState {
+  data: unknown[];
+  total: number;
+  loadedPages: Set<number>;
+  hasMore: boolean;
+  loading: boolean;
+}
+
+export class LazyLoader {
+  private state: Map<string, LazyLoadState> = new Map();
+  private lastAccessTime: Map<string, number> = new Map();
+  // Configure via CRUD_LAZY_LOADER_MAX_STATES env variable (default: 50)
+  private readonly MAX_STATES = crudConfig.lazyLoader.maxStates;
+  // Configure via CRUD_LAZY_LOADER_MAX_AGE_MS env variable (default: 600000 = 10 minutes)
+  private readonly MAX_AGE = crudConfig.lazyLoader.maxAge;
+  private cleanupInterval: NodeJS.Timeout | null = null;
+
+  constructor() {
+    // Start cleanup interval if in browser environment
+    if (typeof window !== "undefined") {
+      this.startCleanupInterval();
+    }
+  }
+
+  /**
+   * Start periodic cleanup of old states
+   */
+  private startCleanupInterval(): void {
+    if (this.cleanupInterval) return;
+
+    this.cleanupInterval = setInterval(() => {
+      this.cleanupOldStates();
+    }, 300000); // Run cleanup every 5 minutes
+  }
+
+  /**
+   * Stop cleanup interval
+   */
+  private stopCleanupInterval(): void {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+  }
+
+  /**
+   * Cleanup old and unused states
+   */
+  private cleanupOldStates(): void {
+    const now = Date.now();
+
+    // Remove states older than MAX_AGE
+    const keysToDelete: string[] = [];
+    this.lastAccessTime.forEach((time, endpoint) => {
+      if (now - time > this.MAX_AGE) {
+        keysToDelete.push(endpoint);
+      }
+    });
+
+    keysToDelete.forEach((endpoint) => {
+      this.state.delete(endpoint);
+      this.lastAccessTime.delete(endpoint);
+    });
+
+    // If still too many states, remove oldest ones
+    if (this.state.size > this.MAX_STATES) {
+      const sorted = Array.from(this.lastAccessTime.entries()).sort(
+        (a, b) => a[1] - b[1],
+      );
+
+      const toRemove = sorted.slice(0, this.state.size - this.MAX_STATES);
+      toRemove.forEach(([endpoint]) => {
+        this.state.delete(endpoint);
+        this.lastAccessTime.delete(endpoint);
+      });
+    }
+  }
+
+  /**
+   * Get or initialize state for an endpoint
+   */
+  private getState(endpoint: string): LazyLoadState {
+    // Track access time for cleanup
+    this.lastAccessTime.set(endpoint, Date.now());
+
+    if (!this.state.has(endpoint)) {
+      this.state.set(endpoint, {
+        data: [],
+        total: 0,
+        loadedPages: new Set(),
+        hasMore: true,
+        loading: false,
+      });
+    }
+    return this.state.get(endpoint)!;
+  }
+
+  /**
+   * Load initial data
+   */
+  async loadInitial(
+    endpoint: string,
+    queryParams: CrudQueryParams,
+  ): Promise<CrudResponse> {
+    const state = this.getState(endpoint);
+    state.loading = true;
+
+    try {
+      const response = await crudService.fetch(endpoint, {
+        ...queryParams,
+        page: 1,
+        pageSize: queryParams.pageSize,
+      });
+
+      state.data = response.data;
+      state.total = response.total;
+      state.loadedPages.clear();
+      state.loadedPages.add(1);
+      state.hasMore = response.data.length < response.total;
+
+      return response;
+    } finally {
+      state.loading = false;
+    }
+  }
+
+  /**
+   * Load more data (next page)
+   */
+  async loadMore(
+    endpoint: string,
+    queryParams: CrudQueryParams,
+  ): Promise<CrudResponse> {
+    const state = this.getState(endpoint);
+
+    if (state.loading || !state.hasMore) {
+      return {
+        data: [],
+        total: state.total,
+        page: queryParams.page,
+        pageSize: queryParams.pageSize,
+      };
+    }
+
+    const nextPage = state.loadedPages.size + 1;
+
+    // Check if page already loaded
+    if (state.loadedPages.has(nextPage)) {
+      return {
+        data: [],
+        total: state.total,
+        page: nextPage,
+        pageSize: queryParams.pageSize,
+      };
+    }
+
+    state.loading = true;
+
+    try {
+      const response = await crudService.fetch(endpoint, {
+        ...queryParams,
+        page: nextPage,
+        pageSize: queryParams.pageSize,
+      });
+
+      // Merge new data with existing
+      state.data = [...state.data, ...response.data];
+      state.loadedPages.add(nextPage);
+      state.hasMore = state.data.length < state.total;
+
+      return {
+        ...response,
+        data: state.data,
+      };
+    } finally {
+      state.loading = false;
+    }
+  }
+
+  /**
+   * Reset state for an endpoint
+   */
+  reset(endpoint: string): void {
+    this.state.delete(endpoint);
+    this.lastAccessTime.delete(endpoint);
+  }
+
+  /**
+   * Cleanup all states (useful for testing or memory management)
+   */
+  cleanupAll(): void {
+    this.state.clear();
+    this.lastAccessTime.clear();
+  }
+
+  /**
+   * Get current cache size
+   */
+  getCacheSize(): number {
+    return this.state.size;
+  }
+
+  /**
+   * Check if has more data to load
+   */
+  hasMore(endpoint: string): boolean {
+    const state = this.state.get(endpoint);
+    return state?.hasMore ?? false;
+  }
+
+  /**
+   * Get current data
+   */
+  getData(endpoint: string): unknown[] {
+    const state = this.state.get(endpoint);
+    return state?.data ?? [];
+  }
+
+  /**
+   * Get loading state
+   */
+  isLoading(endpoint: string): boolean {
+    const state = this.state.get(endpoint);
+    return state?.loading ?? false;
+  }
+}
+
+// Singleton instance
+export const lazyLoader = new LazyLoader();

package/src/crud/lib/parse-filters.ts

@@ -0,0 +1,85 @@
+/**
+ * Parse filters from CRUD query params
+ * Extracts filter values from filters array format
+ */
+
+interface FilterItem {
+  name: string;
+  value: unknown;
+  operator?: string;
+}
+
+/**
+ * Parse filters from query params and extract specific filter values
+ * @param filtersParam - JSON string of filters array
+ * @param filterName - Name of the filter to extract
+ * @returns Filter value or undefined
+ */
+export function parseFilterValue(
+  filtersParam: string | null,
+  filterName: string,
+): string | undefined {
+  if (!filtersParam) {
+    return undefined;
+  }
+
+  try {
+    const filters = JSON.parse(filtersParam) as FilterItem[];
+
+    const filter = filters.find((f) => f.name === filterName);
+    if (!filter) {
+      return undefined;
+    }
+
+    // Handle "in" operator - take first value from array
+    if (filter.operator === "in" && Array.isArray(filter.value)) {
+      return filter.value[0] as string;
+    }
+
+    // Handle single value
+    if (typeof filter.value === "string") {
+      return filter.value;
+    }
+
+    return undefined;
+  } catch (error) {
+    console.error(`Error parsing filter ${filterName}:`, error);
+    return undefined;
+  }
+}
+
+/**
+ * Parse multiple filter values from query params
+ * @param filtersParam - JSON string of filters array
+ * @param filterNames - Array of filter names to extract
+ * @returns Object with filter values
+ */
+export function parseFilterValues<T extends string>(
+  filtersParam: string | null,
+  filterNames: T[],
+): Partial<Record<T, string>> {
+  if (!filtersParam) {
+    return {};
+  }
+
+  try {
+    const filters = JSON.parse(filtersParam) as FilterItem[];
+    const result: Partial<Record<T, string>> = {};
+
+    for (const filterName of filterNames) {
+      const filter = filters.find((f) => f.name === filterName);
+      if (filter) {
+        if (filter.operator === "in" && Array.isArray(filter.value)) {
+          result[filterName] = filter.value[0] as string;
+        } else if (typeof filter.value === "string") {
+          result[filterName] = filter.value;
+        }
+      }
+    }
+
+    return result;
+  } catch (error) {
+    console.error("Error parsing filters:", error);
+    return {};
+  }
+}

package/src/crud/lib/permissions.ts

@@ -0,0 +1,52 @@
+import type { CrudPermissions, EntityConfig } from "../../types";
+import type { Session } from "next-auth";
+
+import { getCrudPermissionsFromSession } from "../../rbac/permissions";
+
+/**
+ * Get CRUD permissions for a user based on their session
+ * Permissions are read from session (loaded from cache in session callback)
+ * Uses memoization to return stable object references with TTL
+ */
+export async function getCrudPermissions(
+  session: Session | null,
+  entity: string,
+): Promise<CrudPermissions> {
+  // Get permissions from session (already loaded in JWT)
+  const perms = getCrudPermissionsFromSession(session, entity);
+  return {
+    create: perms.create,
+    read: perms.view,
+    update: perms.update,
+    delete: perms.delete,
+    export: perms.export,
+    import: perms.import,
+    approve: perms.approve,
+    reject: perms.reject,
+  };
+}
+
+/**
+ * Merge config permissions with user permissions
+ * User permissions take precedence
+ * Config permissions are optional, so undefined means "allow if user has permission"
+ */
+export function mergePermissions(
+  configPermissions: EntityConfig["permissions"],
+  userPermissions: CrudPermissions,
+): CrudPermissions {
+  if (!configPermissions) {
+    return userPermissions;
+  }
+
+  return {
+    create: (configPermissions.create ?? true) && userPermissions.create,
+    read: (configPermissions.read ?? true) && userPermissions.read,
+    update: (configPermissions.update ?? true) && userPermissions.update,
+    delete: (configPermissions.delete ?? true) && userPermissions.delete,
+    export: (configPermissions.export ?? true) && userPermissions.export,
+    import: (configPermissions.import ?? true) && userPermissions.import,
+    approve: (configPermissions.approve ?? true) && userPermissions.approve,
+    reject: (configPermissions.reject ?? true) && userPermissions.reject,
+  };
+}

package/src/crud/lib/serialize-config.ts

@@ -0,0 +1,60 @@
+/**
+ * Serialize EntityConfig for passing to Client Components
+ * Removes non-serializable React components and functions
+ */
+
+import type { EntityConfig, FilterConfig } from '../../types'
+
+export function serializeConfig(config: EntityConfig): Omit<EntityConfig, 'icon'> {
+  const { icon, fields, filters, ...rest } = config
+
+  if (icon && !rest.iconName) {
+    const iconComponent = icon as { displayName?: string }
+    if (iconComponent.displayName) {
+      rest.iconName = iconComponent.displayName
+    }
+  }
+
+  const serializedFields = fields.map((field) => {
+    const {
+      renderCell: _renderCell,
+      renderForm: _renderForm,
+      renderInput: _renderInput,
+      validation: _validation,
+      dataSource,
+      ...fieldRest
+    } = field
+
+    if (dataSource?.transform) {
+      const { transform: _transform, ...dataSourceRest } = dataSource
+      return {
+        ...fieldRest,
+        dataSource: dataSourceRest,
+      }
+    }
+
+    return dataSource ? { ...fieldRest, dataSource } : fieldRest
+  })
+
+  const serializedFilters = filters?.map((filter) => {
+    const { renderFilter: _renderFilter, ...filterRest } = filter
+    return filterRest as Omit<FilterConfig, 'renderFilter'>
+  })
+
+  const serializedRowActions = rest.rowActions?.map((action) => {
+    const {
+      handler: _handler,
+      transformData: _transformData,
+      visibleWhen: _visibleWhen,
+      ...actionRest
+    } = action
+    return actionRest
+  })
+
+  return {
+    ...rest,
+    fields: serializedFields,
+    filters: serializedFilters,
+    rowActions: serializedRowActions,
+  }
+}

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

@@ -0,0 +1,145 @@
+import type { CrudQueryParams, CrudResponse } from "../../types";
+
+interface StreamChunk {
+  type: "data" | "error" | "done";
+  data?: unknown[];
+  error?: string;
+  total?: number;
+}
+
+/**
+ * Stream data from API using fetch streaming
+ */
+export async function* streamData(
+  endpoint: string,
+  queryParams: CrudQueryParams,
+): AsyncGenerator<StreamChunk, void, unknown> {
+  const queryString = new URLSearchParams({
+    page: String(queryParams.page),
+    pageSize: String(queryParams.pageSize),
+    ...(queryParams.search && { search: queryParams.search }),
+    ...(queryParams.sort && {
+      sortField: queryParams.sort.field,
+      sortDirection: queryParams.sort.direction,
+    }),
+    ...(queryParams.filters && {
+      filters: JSON.stringify(queryParams.filters),
+    }),
+  }).toString();
+
+  const url = `${endpoint}?${queryString}`;
+
+  try {
+    const response = await fetch(url, {
+      headers: {
+        Accept: "application/x-ndjson", // Newline-delimited JSON
+      },
+    });
+
+    if (!response.ok) {
+      yield {
+        type: "error",
+        error: `Failed to fetch: ${response.statusText}`,
+      };
+      return;
+    }
+
+    const reader = response.body?.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+
+    if (!reader) {
+      yield {
+        type: "error",
+        error: "No response body",
+      };
+      return;
+    }
+
+    while (true) {
+      const { done, value } = await reader.read();
+
+      if (done) {
+        // Process remaining buffer
+        if (buffer.trim()) {
+          try {
+            const data = JSON.parse(buffer);
+            yield {
+              type: "data",
+              data: Array.isArray(data) ? data : [data],
+            };
+          } catch {
+            // Ignore parse errors for last chunk
+          }
+        }
+        yield { type: "done" };
+        break;
+      }
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || ""; // Keep incomplete line in buffer
+
+      for (const line of lines) {
+        if (line.trim()) {
+          try {
+            const data = JSON.parse(line);
+            yield {
+              type: "data",
+              data: Array.isArray(data) ? data : [data],
+              total: data.total,
+            };
+          } catch (error) {
+            yield {
+              type: "error",
+              error: `Parse error: ${error instanceof Error ? error.message : "Unknown error"}`,
+            };
+          }
+        }
+      }
+    }
+  } catch (error) {
+    yield {
+      type: "error",
+      error: error instanceof Error ? error.message : "Stream failed",
+    };
+  }
+}
+
+/**
+ * Load data progressively from stream
+ */
+export async function loadStreamData(
+  endpoint: string,
+  queryParams: CrudQueryParams,
+  onChunk: (chunk: unknown[]) => void,
+): Promise<CrudResponse> {
+  const allData: unknown[] = [];
+  let total = 0;
+
+  try {
+    for await (const chunk of streamData(endpoint, queryParams)) {
+      if (chunk.type === "data" && chunk.data) {
+        allData.push(...chunk.data);
+        if (chunk.total) {
+          total = chunk.total;
+        }
+        onChunk(chunk.data);
+      } else if (chunk.type === "error") {
+        throw new Error(chunk.error);
+      } else if (chunk.type === "done") {
+        break;
+      }
+    }
+
+    return {
+      data: allData,
+      total,
+      page: queryParams.page,
+      pageSize: queryParams.pageSize,
+    };
+  } catch (error) {
+    console.error("Stream loading error:", error);
+    throw error;
+  }
+}