@next-vibe/checker 1.0.11 → 1.0.13

package/src/app/api/[locale]/system/generators/endpoints/i18n/pl/index.ts

@@ -0,0 +1,54 @@
+import type { translations as enTranslations } from "../en";
+
+export const translations: typeof enTranslations = {
+  post: {
+    title: "Tytuł",
+    description: "Opis endpointu",
+    form: {
+      title: "Konfiguracja",
+      description: "Skonfiguruj parametry",
+    },
+    response: {
+      title: "Odpowiedź",
+      description: "Dane odpowiedzi",
+    },
+    errors: {
+      unauthorized: {
+        title: "Brak autoryzacji",
+        description: "Wymagana autoryzacja",
+      },
+      validation: {
+        title: "Błąd walidacji",
+        description: "Nieprawidłowe parametry żądania",
+      },
+      server: {
+        title: "Błąd serwera",
+        description: "Wystąpił wewnętrzny błąd serwera",
+      },
+      unknown: {
+        title: "Nieznany błąd",
+        description: "Wystąpił nieznany błąd",
+      },
+      network: {
+        title: "Błąd sieci",
+        description: "Wystąpił błąd sieci",
+      },
+      forbidden: {
+        title: "Zabronione",
+        description: "Dostęp zabroniony",
+      },
+      notFound: {
+        title: "Nie znaleziono",
+        description: "Zasób nie został znaleziony",
+      },
+      conflict: {
+        title: "Konflikt",
+        description: "Wystąpił konflikt danych",
+      },
+    },
+    success: {
+      title: "Sukces",
+      description: "Operacja zakończona pomyślnie",
+    },
+  },
+};

package/src/app/api/[locale]/system/generators/endpoints/options-repository.ts

@@ -0,0 +1,463 @@
+/**
+ * CLI Options Repository
+ * Consolidated CLI option management functionality
+ * Migrated from cli/utils/options.ts
+ */
+
+import "server-only";
+
+import type { ResponseType } from "next-vibe/shared/types/response.schema";
+import {
+  ErrorResponseTypes,
+  fail,
+  success,
+} from "next-vibe/shared/types/response.schema";
+import { parseError } from "next-vibe/shared/utils/parse-error";
+
+import type { JwtPayloadType } from "@/app/api/[locale]/user/auth/types";
+import type { CountryLanguage } from "@/i18n/core/config";
+import { simpleT } from "@/i18n/core/shared";
+
+// CLI Options types
+export interface CliOptionsRequestOutput {
+  [key: string]: string | number | boolean | string[] | undefined;
+}
+
+export interface CliOptionsResponseOutput {
+  success: boolean;
+  options: string[];
+  validation: {
+    isValid: boolean;
+    errors: string[];
+  };
+}
+
+// ===== OPTION TYPES =====
+
+/**
+ * Represents a CLI option with its metadata
+ */
+export interface OptionDefinition {
+  /** The name of the option (e.g., 'debug') */
+  name: string;
+  /** Short alias for the option (e.g., 'd' for --debug) */
+  alias?: string;
+  /** Default value for the option */
+  default?: boolean | string | number | string[];
+  /** Description of what the option does */
+  description: string;
+  /** Type of the option value */
+  type: "boolean" | "string" | "number" | "array";
+  /** Whether the option is required */
+  required?: boolean;
+  /** Category for organizing options in help display */
+  category?: string;
+  /** Examples of how to use the option */
+  examples?: string[];
+}
+
+/**
+ * Option definitions mapping for a specific type
+ */
+type OptionDefinitionsMap<T> = {
+  [K in keyof T]: OptionDefinition;
+};
+
+// ===== REPOSITORY INTERFACE =====
+
+/**
+ * CLI Options Repository Interface
+ */
+export interface CliOptionsRepository {
+  processOptions(
+    data: CliOptionsRequestOutput,
+    user: JwtPayloadType,
+    locale: CountryLanguage,
+  ): Promise<ResponseType<CliOptionsResponseOutput>>;
+
+  validateOption(
+    name: string,
+    value: string | number | boolean | null | string[],
+  ): Promise<ResponseType<boolean>>;
+  generateHelp(category?: string): Promise<ResponseType<string>>;
+}
+
+/**
+ * CLI Options Repository Implementation
+ */
+export class CliOptionsRepositoryImpl implements CliOptionsRepository {
+  private optionDefinitions: Map<string, OptionDefinition> = new Map();
+
+  constructor() {
+    this.loadDefaultOptions();
+  }
+
+  /**
+   * Process CLI options based on operation
+   */
+  async processOptions(
+    data: CliOptionsRequestOutput,
+    user: JwtPayloadType,
+    locale: CountryLanguage,
+  ): Promise<ResponseType<CliOptionsResponseOutput>> {
+    const { t } = simpleT(locale);
+
+    // Validate user permissions
+    if (!user?.id) {
+      return fail({
+        message:
+          "app.api.system.unifiedInterface.cli.setup.install.post.errors.unauthorized.title",
+        errorType: ErrorResponseTypes.UNAUTHORIZED,
+        messageParams: {
+          error: t(
+            "app.api.system.unifiedInterface.cli.setup.install.post.errors.unauthorized.description",
+          ),
+        },
+      });
+    }
+
+    try {
+      const response = {
+        success: true,
+        options: [] as string[],
+        validation: { isValid: true, errors: [] as string[] },
+      };
+
+      switch (data.operation) {
+        case "list": {
+          const category =
+            typeof data.category === "string" ? data.category : undefined;
+          response.options = Object.keys(this.listOptions(category));
+          break;
+        }
+        case "validate":
+          if (data.optionName && data.optionValue !== undefined) {
+            const validation = this.validateOptionValue(
+              String(data.optionName),
+              data.optionValue,
+            );
+            response.validation = {
+              isValid: validation.valid,
+              errors: validation.errors,
+            };
+          } else {
+            response.validation = {
+              isValid: false,
+              errors: [
+                t(
+                  "app.api.system.unifiedInterface.cli.setup.install.post.errors.validation.title",
+                ),
+              ],
+            };
+          }
+          break;
+        case "define":
+          // Define new option (implementation would go here)
+          response.options = [
+            t(
+              "app.api.system.unifiedInterface.cli.setup.install.post.success.title",
+            ),
+          ];
+          break;
+        case "parse":
+          // Parse option values (implementation would go here)
+          response.options = [
+            t(
+              "app.api.system.unifiedInterface.cli.setup.install.post.success.title",
+            ),
+          ];
+          break;
+        default:
+          return fail({
+            message:
+              "app.api.system.generators.endpoints.post.errors.server.title",
+            errorType: ErrorResponseTypes.INTERNAL_ERROR,
+            messageParams: {
+              error: t(
+                "app.api.system.generators.endpoints.post.errors.server.description",
+              ),
+            },
+          });
+      }
+
+      return success(response);
+    } catch (error) {
+      return fail({
+        message: "app.api.shared.errorTypes.internal_error",
+        errorType: ErrorResponseTypes.INTERNAL_ERROR,
+        messageParams: { error: parseError(error).message },
+      });
+    }
+  }
+
+  /**
+   * Validate a single option
+   */
+  validateOption(
+    name: string,
+    value: string | number | boolean | null | string[],
+  ): Promise<ResponseType<boolean>> {
+    try {
+      const validation = this.validateOptionValue(name, value);
+      return Promise.resolve(success(validation.valid));
+    } catch (error) {
+      return Promise.resolve(
+        fail({
+          message: "app.api.shared.errorTypes.validation_error",
+          errorType: ErrorResponseTypes.INTERNAL_ERROR,
+          messageParams: { error: parseError(error).message },
+        }),
+      );
+    }
+  }
+
+  /**
+   * Generate help text
+   */
+  generateHelp(category?: string): Promise<ResponseType<string>> {
+    try {
+      const help = this.generateOptionsHelp(category);
+      return Promise.resolve(success(help));
+    } catch (error) {
+      return Promise.resolve(
+        fail({
+          message: "app.api.shared.errorTypes.internal_error",
+          errorType: ErrorResponseTypes.INTERNAL_ERROR,
+          messageParams: { error: parseError(error).message },
+        }),
+      );
+    }
+  }
+
+  // ===== PRIVATE METHODS =====
+
+  /**
+   * Load default CLI options
+   */
+  private loadDefaultOptions(): void {
+    const defaultOptions: OptionDefinition[] = [
+      {
+        name: "verbose",
+        alias: "v",
+        type: "boolean",
+        default: false,
+        description: "Enable verbose output",
+        category: "General",
+        examples: ["--verbose", "-v"],
+      },
+      {
+        name: "dry-run",
+        alias: "n",
+        type: "boolean",
+        default: false,
+        description: "Show what would be done without executing",
+        category: "General",
+        examples: ["--dry-run", "-n"],
+      },
+      {
+        name: "output",
+        alias: "o",
+        type: "string",
+        default: "json",
+        description: "Output format (json, table, pretty)",
+        category: "Output",
+        examples: ["--output=json", "-o table"],
+      },
+      {
+        name: "interactive",
+        alias: "i",
+        type: "boolean",
+        default: false,
+        description: "Enable interactive mode",
+        category: "General",
+        examples: ["--interactive", "-i"],
+      },
+    ];
+
+    for (const option of defaultOptions) {
+      this.optionDefinitions.set(option.name, option);
+    }
+  }
+
+  /**
+   * List options by category
+   */
+  private listOptions(
+    category?: string,
+    // eslint-disable-next-line oxlint-plugin-restricted/restricted-syntax -- Generic utility type for runtime object handling
+  ): Record<string, string | number | boolean | null | object> {
+    // eslint-disable-next-line oxlint-plugin-restricted/restricted-syntax -- Generic utility type for runtime object handling
+    const options: Record<string, string | number | boolean | null | object> =
+      {};
+
+    for (const [name, definition] of this.optionDefinitions) {
+      if (!category || definition.category === category) {
+        options[name] = {
+          name: definition.name,
+          alias: definition.alias,
+          type: definition.type,
+          default: definition.default,
+          description: definition.description,
+          category: definition.category,
+          required: definition.required,
+          examples: definition.examples,
+        };
+      }
+    }
+
+    return options;
+  }
+
+  /**
+   * Validate option value
+   */
+  private validateOptionValue(
+    name: string,
+    value: string | number | boolean | null | string[],
+  ): {
+    valid: boolean;
+    errors: string[];
+  } {
+    const errors: string[] = [];
+    const definition = this.optionDefinitions.get(name);
+
+    if (!definition) {
+      errors.push(`Unknown option: ${name}`);
+      return { valid: false, errors };
+    }
+
+    // Type validation
+    switch (definition.type) {
+      case "boolean":
+        if (
+          typeof value !== "boolean" &&
+          value !== "true" &&
+          value !== "false"
+        ) {
+          errors.push(`Option ${name} must be a boolean value`);
+        }
+        break;
+      case "string":
+        if (typeof value !== "string") {
+          errors.push(`Option ${name} must be a string value`);
+        }
+        break;
+      case "number":
+        if (typeof value !== "number" && isNaN(Number(value))) {
+          errors.push(`Option ${name} must be a number value`);
+        }
+        break;
+      case "array":
+        if (!Array.isArray(value)) {
+          errors.push(`Option ${name} must be an array value`);
+        }
+        break;
+    }
+
+    // Required validation
+    if (definition.required && (value === undefined || value === null)) {
+      errors.push(`Option ${name} is required`);
+    }
+
+    return { valid: errors.length === 0, errors };
+  }
+
+  /**
+   * Generate help text for options
+   */
+  private generateOptionsHelp(categoryFilter?: string): string {
+    let helpText = "";
+
+    // Group options by category
+    const categories: { [categoryName: string]: OptionDefinition[] } = {};
+
+    for (const [, option] of this.optionDefinitions) {
+      const category = option.category || "General";
+
+      if (categoryFilter && category !== categoryFilter) {
+        continue;
+      }
+
+      if (!categories[category]) {
+        categories[category] = [];
+      }
+
+      categories[category].push(option);
+    }
+
+    // Generate help text for each category
+    for (const category in categories) {
+      helpText += `\n${category} Options:\n`;
+
+      for (const option of categories[category]) {
+        const aliasText = option.alias ? `, -${option.alias}` : "";
+        const defaultText =
+          option.default !== undefined
+            ? ` [default: ${String(option.default)}]`
+            : "";
+        const requiredText = option.required ? " [required]" : "";
+
+        helpText += `  --${option.name}${aliasText}\t${option.description}${defaultText}${requiredText}\n`;
+      }
+    }
+
+    return helpText;
+  }
+
+  /**
+   * Utility function to create standardized option definitions
+   */
+  defineOptions<T>(options: OptionDefinitionsMap<T>): OptionDefinitionsMap<T> {
+    return options;
+  }
+
+  /**
+   * Apply default values to options object and map CLI option names to property names
+   */
+  applyOptionDefaults<T>(
+    options: Partial<T>,
+    definitions: OptionDefinitionsMap<T>,
+  ): T {
+    const result = { ...options } as T;
+
+    for (const key in definitions) {
+      const definition = definitions[key];
+      const cliOptionName = definition.name;
+
+      // Check if the CLI option name exists in the options (kebab-case)
+      if (
+        cliOptionName in options &&
+        options[cliOptionName as keyof T] !== undefined
+      ) {
+        // Map the CLI option name to the property name (camelCase) with type conversion
+        const value = options[cliOptionName as keyof T];
+
+        // Convert string values to proper types for boolean options
+        if (definition.type === "boolean" && typeof value === "string") {
+          result[key] = (value.toLowerCase() === "true") as T[Extract<
+            keyof T,
+            string
+          >];
+        } else {
+          result[key] = value as T[Extract<keyof T, string>];
+        }
+      } else if (
+        definitions[key].default !== undefined &&
+        options[key] === undefined
+      ) {
+        // Apply default value if the option is not set
+        result[key] = definitions[key].default as T[Extract<keyof T, string>];
+      }
+    }
+
+    return result;
+  }
+}
+
+export const cliOptionsRepository = new CliOptionsRepositoryImpl();
+
+// Export utility functions for backward compatibility
+export const defineOptions =
+  cliOptionsRepository.defineOptions.bind(cliOptionsRepository);
+export const applyOptionDefaults =
+  cliOptionsRepository.applyOptionDefaults.bind(cliOptionsRepository);