@next-vibe/checker 1.0.11 → 1.0.12

package/src/app/api/[locale]/system/unified-interface/shared/utils/scanner.ts

@@ -0,0 +1,241 @@
+/**
+ * Directory Scanner Utility
+ * Consolidated directory scanning logic used across the codebase
+ * Eliminates 8+ duplicate implementations
+ */
+
+import "server-only";
+
+import { existsSync, readdirSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+
+/**
+ * Options for directory scanning
+ */
+export interface DirectoryScanOptions {
+  /**
+   * File name pattern to match (e.g., "route.ts", "seed.ts")
+   * Can be exact match or regex pattern
+   */
+  filePattern?: string | RegExp;
+
+  /**
+   * File extension patterns to match (e.g., [".ts", ".tsx"])
+   */
+  extensions?: string[];
+
+  /**
+   * Directory names to exclude from scanning
+   */
+  excludeDirs?: string[];
+
+  /**
+   * File names to exclude from results
+   */
+  excludeFiles?: string[];
+
+  /**
+   * Path patterns to exclude (checked against relative path)
+   */
+  excludePatterns?: string[];
+
+  /**
+   * Whether to include the relative path in results
+   * If true, returns { fullPath, relativePath }
+   * If false, returns just fullPath
+   */
+  includeRelativePath?: boolean;
+
+  /**
+   * Whether to include path segments (directory structure as array)
+   */
+  includePathSegments?: boolean;
+
+  /**
+   * Maximum depth to scan (undefined = unlimited)
+   */
+  maxDepth?: number;
+
+  /**
+   * Whether to follow symbolic links
+   */
+  followSymlinks?: boolean;
+
+  /**
+   * Custom filter function for additional filtering
+   */
+  customFilter?: (fullPath: string, relativePath: string) => boolean;
+}
+
+/**
+ * Result of directory scan with full path
+ */
+export interface ScanResultSimple {
+  fullPath: string;
+}
+
+/**
+ * Result of directory scan with relative path
+ */
+export interface ScanResultWithRelative extends ScanResultSimple {
+  relativePath: string;
+}
+
+/**
+ * Result of directory scan with path segments
+ */
+export interface ScanResultWithSegments extends ScanResultWithRelative {
+  pathSegments: string[];
+}
+
+/**
+ * Default directories to exclude
+ */
+const DEFAULT_EXCLUDE_DIRS = [
+  "node_modules",
+  ".git",
+  ".next",
+  ".tmp",
+  "dist",
+  ".dist",
+];
+
+/**
+ * Scan directory recursively and find matching files
+ */
+export function scanDirectory(
+  baseDir: string,
+  options: DirectoryScanOptions = {},
+): ScanResultWithSegments[] {
+  const {
+    filePattern,
+    extensions = [],
+    excludeDirs = DEFAULT_EXCLUDE_DIRS,
+    excludeFiles = [],
+    excludePatterns = [],
+    maxDepth,
+    followSymlinks = false,
+    customFilter,
+  } = options;
+
+  const results: ScanResultWithSegments[] = [];
+  const resolvedBaseDir = resolve(baseDir);
+
+  if (!existsSync(resolvedBaseDir)) {
+    return results;
+  }
+
+  /**
+   * Recursive scan function
+   */
+  function scan(
+    currentDir: string,
+    currentSegments: string[] = [],
+    depth = 0,
+  ): void {
+    // Check max depth
+    if (maxDepth !== undefined && depth > maxDepth) {
+      return;
+    }
+
+    try {
+      const entries = readdirSync(currentDir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = join(currentDir, entry.name);
+        const relativePath = relative(resolvedBaseDir, fullPath);
+
+        // Skip excluded directories
+        if (entry.isDirectory()) {
+          if (excludeDirs.includes(entry.name) || entry.name.startsWith(".")) {
+            continue;
+          }
+
+          // Check exclude patterns
+          if (
+            excludePatterns.some((pattern) => relativePath.includes(pattern))
+          ) {
+            continue;
+          }
+
+          // Recurse into subdirectory
+          const newSegments = [...currentSegments, entry.name];
+          scan(fullPath, newSegments, depth + 1);
+        } else if (
+          entry.isFile() ||
+          (followSymlinks && entry.isSymbolicLink())
+        ) {
+          // Skip excluded files
+          if (excludeFiles.includes(entry.name)) {
+            continue;
+          }
+
+          // Check file pattern
+          let matches = false;
+
+          if (filePattern) {
+            if (typeof filePattern === "string") {
+              matches = entry.name === filePattern;
+            } else {
+              matches = filePattern.test(entry.name);
+            }
+          } else if (extensions.length > 0) {
+            matches = extensions.some((ext) => entry.name.endsWith(ext));
+          } else {
+            // No pattern specified, match all files
+            matches = true;
+          }
+
+          if (!matches) {
+            continue;
+          }
+
+          // Apply custom filter
+          if (customFilter && !customFilter(fullPath, relativePath)) {
+            continue;
+          }
+
+          // Add to results
+          results.push({
+            fullPath,
+            relativePath,
+            pathSegments: currentSegments,
+          });
+        }
+      }
+    } catch {
+      // Skip directories we can't read
+    }
+  }
+
+  scan(resolvedBaseDir);
+  return results;
+}
+
+/**
+ * Find files by exact name pattern
+ */
+export function findFilesByName(
+  baseDir: string,
+  fileName: string,
+  options: Omit<DirectoryScanOptions, "filePattern"> = {},
+): ScanResultWithSegments[] {
+  return scanDirectory(baseDir, {
+    ...options,
+    filePattern: fileName,
+  });
+}
+
+/**
+ * Get all route.ts files in a directory
+ */
+export function findRouteFiles(
+  directory: string,
+  excludePatterns: string[] = [],
+): ScanResultWithSegments[] {
+  return scanDirectory(directory, {
+    filePattern: "route.ts",
+    excludePatterns,
+    excludeDirs: [...DEFAULT_EXCLUDE_DIRS, "trpc", "generated"],
+  });
+}

package/src/app/api/[locale]/system/unified-interface/shared/widgets/actions.ts

@@ -0,0 +1,256 @@
+/**
+ * Action and Field Configuration Types
+ *
+ * This file contains action configurations, field behaviors, and related types.
+ * For widget configurations, import from widget-configs.ts.
+ */
+
+import type { Route } from "next";
+
+import type { TranslationKey } from "@/i18n/core/static-types";
+
+// Import types from core enums
+import type {
+  ActionTiming,
+  ActionType,
+  ComponentSize,
+  ComponentVariant,
+  InterfaceContext,
+} from "../types/enums";
+
+// ============================================================================
+// FIELD USAGE TYPES
+// ============================================================================
+
+/**
+ * Field usage configuration
+ */
+export type FieldUsageConfig =
+  | {
+      request: "data" | "urlPathParams" | "data&urlPathParams";
+      response?: never;
+    }
+  | { request?: never; response: true }
+  | {
+      request: "data" | "urlPathParams" | "data&urlPathParams";
+      response: true;
+    };
+
+/**
+ * Action condition for conditional execution
+ */
+export interface ActionCondition {
+  field: string;
+  operator:
+    | "equals"
+    | "not_equals"
+    | "contains"
+    | "not_contains"
+    | "exists"
+    | "not_exists"
+    | "greater_than"
+    | "less_than";
+  value?: string | number | boolean;
+}
+
+/**
+ * Base action configuration
+ */
+export interface BaseActionConfig {
+  type: ActionType;
+  timing?: ActionTiming;
+  delay?: number;
+  conditions?: ActionCondition[];
+  contexts?: InterfaceContext[];
+}
+
+/**
+ * Toast/Notification action
+ */
+export interface ToastActionConfig extends BaseActionConfig {
+  type: ActionType.TOAST | ActionType.NOTIFICATION | ActionType.ALERT;
+  message: TranslationKey;
+  variant?: ComponentVariant;
+  duration?: number;
+  title?: TranslationKey;
+  description?: TranslationKey;
+}
+
+/**
+ * Navigation action
+ */
+export interface NavigationActionConfig extends BaseActionConfig {
+  type:
+    | ActionType.ROUTER_PUSH
+    | ActionType.ROUTER_REPLACE
+    | ActionType.ROUTER_BACK
+    | ActionType.REDIRECT;
+  path?: string;
+  route?: Route;
+  params?: Record<string, string>;
+  query?: Record<string, string>;
+  replace?: boolean;
+  external?: boolean;
+}
+
+/**
+ * Data/Cache action
+ */
+export interface RefetchActionConfig extends BaseActionConfig {
+  type:
+    | ActionType.REFETCH
+    | ActionType.INVALIDATE_CACHE
+    | ActionType.UPDATE_CACHE
+    | ActionType.CLEAR_CACHE;
+  queryKeys?: string[][];
+  exact?: boolean;
+  data?: Record<string, string | number | boolean>;
+}
+
+/**
+ * Form action
+ */
+export interface FormActionConfig extends BaseActionConfig {
+  type:
+    | ActionType.RESET_FORM
+    | ActionType.CLEAR_FORM
+    | ActionType.SET_FORM_VALUES
+    | ActionType.FOCUS_FIELD;
+  formId?: string;
+  values?: Record<string, string | number | boolean>;
+  fieldName?: string;
+  resetToDefaults?: boolean;
+}
+
+/**
+ * State action
+ */
+export interface StateActionConfig extends BaseActionConfig {
+  type:
+    | ActionType.SET_STATE
+    | ActionType.TOGGLE_STATE
+    | ActionType.UPDATE_STATE;
+  key: string;
+  value?: string | number | boolean;
+  updater?: (current: string | number | boolean) => string | number | boolean;
+}
+
+/**
+ * Custom action
+ */
+export interface CustomActionConfig extends BaseActionConfig {
+  type: ActionType.CUSTOM;
+  handler: string | ((context: ActionContext) => Promise<ActionResult>);
+  payload?: Record<string, string | number | boolean>;
+}
+
+/**
+ * Union type for all action configurations
+ */
+export type ActionConfig =
+  | ToastActionConfig
+  | NavigationActionConfig
+  | RefetchActionConfig
+  | FormActionConfig
+  | StateActionConfig
+  | CustomActionConfig;
+
+/**
+ * Action execution context
+ */
+export interface ActionContext {
+  context: InterfaceContext;
+  data?: Record<string, string | number | boolean>;
+  error?: Error;
+  endpoint?: Record<string, string | number | boolean>;
+  timestamp: string;
+  user: {
+    id: string;
+    roles: string[];
+  };
+  metadata?: Record<string, string | number | boolean>;
+  formValues?: Record<string, string | number | boolean>;
+  fieldValue?: string | number | boolean;
+}
+
+/**
+ * Action execution result
+ */
+export interface ActionResult {
+  success: boolean;
+  data?: Record<string, string | number | boolean>;
+  error?: string;
+  metadata?: Record<string, string | number | boolean>;
+}
+
+/**
+ * Lifecycle actions
+ */
+export interface LifecycleActions {
+  onSuccess?: ActionConfig[];
+  onError?: ActionConfig[];
+  onLoading?: ActionConfig[];
+  onComplete?: ActionConfig[];
+  onMount?: ActionConfig[];
+  onUnmount?: ActionConfig[];
+}
+
+/**
+ * Interactive actions
+ */
+export interface InteractiveActions {
+  onClick?: ActionConfig[];
+  onDoubleClick?: ActionConfig[];
+  onHover?: ActionConfig[];
+  onFocus?: ActionConfig[];
+  onBlur?: ActionConfig[];
+}
+
+/**
+ * Form field actions
+ */
+export interface FieldActions {
+  onChange?: ActionConfig[];
+  onValidation?: ActionConfig[];
+  onError?: ActionConfig[];
+  onClear?: ActionConfig[];
+}
+
+/**
+ * Button action configuration
+ */
+export interface ButtonAction {
+  label: TranslationKey;
+  icon?: string;
+  variant?: ComponentVariant;
+  size?: ComponentSize;
+  actions: ActionConfig[];
+  conditions?: ActionCondition[];
+  disabled?: boolean;
+  loading?: boolean;
+}
+
+/**
+ * Context menu action
+ */
+export interface ContextMenuAction {
+  label: TranslationKey;
+  icon?: string;
+  actions: ActionConfig[];
+  separator?: boolean;
+  disabled?: boolean;
+  dangerous?: boolean;
+}
+
+/**
+ * Bulk action for data tables
+ */
+export interface BulkAction {
+  label: TranslationKey;
+  icon?: string;
+  variant?: ComponentVariant;
+  actions: ActionConfig[];
+  confirmationMessage?: TranslationKey;
+  requiresSelection?: boolean;
+  maxSelection?: number;
+}