@next-vibe/checker 1.0.11 → 1.0.12

package/src/app/api/[locale]/system/generators/endpoint/repository.ts

@@ -0,0 +1,291 @@
+/**
+ * Endpoint Generator Repository
+ * Generates endpoint.ts with dynamic imports and flat path structure
+ */
+
+import "server-only";
+
+import { join } from "node:path";
+
+import type { ResponseType as BaseResponseType } 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 { EndpointLogger } from "@/app/api/[locale]/system/unified-interface/shared/logger/endpoint";
+import {
+  formatCount,
+  formatDuration,
+  formatGenerator,
+} from "@/app/api/[locale]/system/unified-interface/shared/logger/formatters";
+import { endpointToToolName } from "@/app/api/[locale]/system/unified-interface/shared/utils/path";
+
+import {
+  findFilesRecursively,
+  generateAbsoluteImportPath,
+  generateFileHeader,
+  writeGeneratedFile,
+} from "../shared/utils";
+
+// Type definitions
+interface EndpointRequestType {
+  outputFile: string;
+  dryRun: boolean;
+}
+
+interface EndpointResponseType {
+  success: boolean;
+  message: string;
+  endpointsFound: number;
+  duration: number;
+  outputFile?: string;
+}
+
+/**
+ * Endpoint Generator Repository Interface
+ */
+interface EndpointGeneratorRepository {
+  generateEndpoint(
+    data: EndpointRequestType,
+    logger: EndpointLogger,
+  ): Promise<BaseResponseType<EndpointResponseType>>;
+}
+
+/**
+ * Endpoint Generator Repository Implementation
+ */
+class EndpointGeneratorRepositoryImpl implements EndpointGeneratorRepository {
+  async generateEndpoint(
+    data: EndpointRequestType,
+    logger: EndpointLogger,
+  ): Promise<BaseResponseType<EndpointResponseType>> {
+    const startTime = Date.now();
+
+    try {
+      const outputFile = data.outputFile;
+      logger.debug("Starting endpoint generation", { outputFile });
+
+      // Discover definition files
+      // eslint-disable-next-line i18next/no-literal-string
+      const apiCorePath = ["src", "app", "api", "[locale]"];
+      const startDir = join(process.cwd(), ...apiCorePath);
+
+      logger.debug("Discovering definition files");
+      const definitionFiles = findFilesRecursively(startDir, "definition.ts");
+
+      logger.debug(`Found ${definitionFiles.length} definition files`);
+
+      // Generate content
+      const content = await this.generateContent(definitionFiles);
+
+      // Write file
+      await writeGeneratedFile(outputFile, content, data.dryRun);
+
+      const duration = Date.now() - startTime;
+
+      logger.info(
+        formatGenerator(
+          `Generated endpoint file with ${formatCount(definitionFiles.length, "endpoint")} in ${formatDuration(duration)}`,
+          "📄",
+        ),
+      );
+
+      return success({
+        success: true,
+        message: "app.api.system.generators.endpoints.success.generated",
+        endpointsFound: definitionFiles.length,
+        duration,
+        outputFile: data.dryRun ? undefined : outputFile,
+      });
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      logger.error("Endpoint generation failed", {
+        error: parseError(error),
+        duration,
+      });
+
+      return fail({
+        message: "app.api.system.generators.endpoints.post.errors.server.title",
+        errorType: ErrorResponseTypes.INTERNAL_ERROR,
+        messageParams: {
+          duration,
+        },
+      });
+    }
+  }
+
+  /**
+   * Generate endpoint content with dynamic imports and real aliases from definitions
+   * Main paths include method suffix (e.g., "core/agent/ai-stream/POST")
+   * Aliases also include method from their definition
+   */
+  private async generateContent(definitionFiles: string[]): Promise<string> {
+    const pathMap: Record<string, { importPath: string; method: string }> = {};
+    const allPaths: string[] = [];
+
+    // Build path map with real aliases (deduplicate)
+    for (const defFile of definitionFiles) {
+      const importPath = generateAbsoluteImportPath(defFile, "definition");
+
+      // Load the actual definition - let TypeScript infer the concrete type
+      const definition = await import(defFile);
+      const defaultExport = definition.default;
+
+      if (!defaultExport) {
+        continue;
+      }
+
+      // Explicitly access each HTTP method property
+      const methodEntries = [
+        { method: "GET" as const, endpoint: defaultExport.GET },
+        { method: "POST" as const, endpoint: defaultExport.POST },
+        { method: "PUT" as const, endpoint: defaultExport.PUT },
+        { method: "PATCH" as const, endpoint: defaultExport.PATCH },
+        { method: "DELETE" as const, endpoint: defaultExport.DELETE },
+        { method: "HEAD" as const, endpoint: defaultExport.HEAD },
+        { method: "OPTIONS" as const, endpoint: defaultExport.OPTIONS },
+      ];
+
+      for (const { method, endpoint } of methodEntries) {
+        if (!endpoint) {
+          continue;
+        }
+
+        // Use endpointToToolName to get properly sanitized tool name
+        const toolName = endpointToToolName(endpoint);
+
+        if (!pathMap[toolName]) {
+          pathMap[toolName] = { importPath, method };
+          allPaths.push(toolName);
+        }
+
+        // Add aliases if they exist
+        if (endpoint.aliases && Array.isArray(endpoint.aliases)) {
+          for (const alias of endpoint.aliases) {
+            if (!pathMap[alias]) {
+              pathMap[alias] = { importPath, method };
+              allPaths.push(alias);
+            }
+          }
+        }
+      }
+    }
+
+    // Sort paths for consistent output
+    allPaths.sort();
+
+    // Build alias to full path map (alias -> full path with method)
+    // Full paths map to themselves
+    const aliasToPathMap: Record<string, string> = {};
+
+    for (const defFile of definitionFiles) {
+      // Load the actual definition - let TypeScript infer the concrete type
+      const definition = await import(defFile);
+      const defaultExport = definition.default;
+
+      if (!defaultExport) {
+        continue;
+      }
+
+      // Explicitly access each HTTP method property
+      const methodEntries = [
+        { method: "GET" as const, endpoint: defaultExport.GET },
+        { method: "POST" as const, endpoint: defaultExport.POST },
+        { method: "PUT" as const, endpoint: defaultExport.PUT },
+        { method: "PATCH" as const, endpoint: defaultExport.PATCH },
+        { method: "DELETE" as const, endpoint: defaultExport.DELETE },
+        { method: "HEAD" as const, endpoint: defaultExport.HEAD },
+        { method: "OPTIONS" as const, endpoint: defaultExport.OPTIONS },
+      ];
+
+      for (const { endpoint } of methodEntries) {
+        if (!endpoint) {
+          continue;
+        }
+
+        // Use endpointToToolName to get properly sanitized canonical tool name
+        const canonicalName = endpointToToolName(endpoint);
+
+        // Canonical name maps to itself
+        aliasToPathMap[canonicalName] = canonicalName;
+
+        // Map aliases to their canonical names
+        if (endpoint.aliases && Array.isArray(endpoint.aliases)) {
+          for (const alias of endpoint.aliases) {
+            if (!aliasToPathMap[alias]) {
+              aliasToPathMap[alias] = canonicalName;
+            }
+          }
+        }
+      }
+    }
+
+    // Generate getEndpoint function cases
+    const cases: string[] = [];
+    for (const path of allPaths) {
+      const { importPath, method } = pathMap[path];
+      // eslint-disable-next-line i18next/no-literal-string
+      cases.push(`    case "${path}":
+      return (await import("${importPath}")).default.${method};`);
+    }
+
+    // eslint-disable-next-line i18next/no-literal-string
+    const autoGenTitle = "AUTO-GENERATED FILE - DO NOT EDIT";
+    const generatorName = "generators/endpoint";
+    const header = generateFileHeader(autoGenTitle, generatorName, {
+      "Endpoints found": definitionFiles.length,
+      "Total paths (with aliases)": allPaths.length,
+    });
+
+    // Generate alias map entries
+    const aliasMapEntries = Object.entries(aliasToPathMap)
+      .toSorted(([a], [b]) => a.localeCompare(b))
+      .map(([alias, fullPath]) => `  "${alias}": "${fullPath}"`)
+      .join(",\n");
+
+    // eslint-disable-next-line i18next/no-literal-string
+    return `${header}
+
+/* eslint-disable prettier/prettier */
+/* eslint-disable i18next/no-literal-string */
+
+import type { CreateApiEndpointAny } from "@/app/api/[locale]/system/unified-interface/shared/types/endpoint";
+
+/**
+ * Map of aliases to their canonical full paths
+ * Full paths map to themselves
+ */
+export const aliasToPathMap = {
+${aliasMapEntries}
+} as const;
+
+/**
+ * Get the canonical full path from an alias or full path
+ * @param aliasOrPath - An alias or full path
+ * @returns The canonical full path, or null if not found
+ */
+export function getFullPath(aliasOrPath: string): typeof aliasToPathMap[keyof typeof aliasToPathMap] | null {
+  return aliasToPathMap[aliasOrPath as keyof typeof aliasToPathMap] ?? null;
+}
+
+/**
+ * Dynamically import endpoint definition by path
+ * @param path - The endpoint path (e.g., "core/agent/chat/threads")
+ * @returns The endpoint definition or null if not found
+ */
+export async function getEndpoint(path: string): Promise<CreateApiEndpointAny | null> {
+  switch (path) {
+${cases.join("\n")}
+    default:
+      return null;
+  }
+}
+`;
+  }
+}
+
+export const endpointGeneratorRepository =
+  new EndpointGeneratorRepositoryImpl();

package/src/app/api/[locale]/system/generators/endpoint/route.ts

@@ -0,0 +1,21 @@
+/**
+ * Endpoint Generator Route Handler
+ */
+
+import { endpointsHandler } from "@/app/api/[locale]/system/unified-interface/shared/endpoints/route/multi";
+import { Methods } from "@/app/api/[locale]/system/unified-interface/shared/types/enums";
+
+import definitions from "./definition";
+import { endpointGeneratorRepository } from "./repository";
+
+export const { POST, tools } = endpointsHandler({
+  endpoint: definitions,
+  [Methods.POST]: {
+    handler: async (props) => {
+      return await endpointGeneratorRepository.generateEndpoint(
+        props.data,
+        props.logger,
+      );
+    },
+  },
+});

package/src/app/api/[locale]/system/generators/endpoints/definition.ts

@@ -0,0 +1,246 @@
+/**
+ * Generators Functional API Definition
+ * Defines endpoints for functional generator operations
+ */
+
+import { z } from "zod";
+
+import { createEndpoint } from "@/app/api/[locale]/system/unified-interface/shared/endpoints/definition/create";
+import {
+  objectField,
+  requestDataField,
+  responseField,
+} from "@/app/api/[locale]/system/unified-interface/shared/field/utils";
+import {
+  EndpointErrorTypes,
+  FieldDataType,
+  Methods,
+  WidgetType,
+} from "@/app/api/[locale]/system/unified-interface/shared/types/enums";
+
+import { UserRole } from "../../../user/user-roles/enum";
+
+/**
+ * Functional Generators Endpoint Definition
+ */
+const { POST } = createEndpoint({
+  method: Methods.POST,
+  path: ["system", "generators", "endpoints"],
+  title: "app.api.system.dev.category",
+  description: "app.api.system.dev.typecheck.description",
+  category: "app.api.system.dev.category",
+  tags: ["app.api.system.dev.category"],
+  icon: "sparkles",
+
+  // === ROLES ===
+  allowedRoles: [
+    UserRole.ADMIN,
+    UserRole.WEB_OFF,
+    UserRole.AI_TOOL_OFF,
+    UserRole.MCP_OFF,
+    UserRole.PRODUCTION_OFF,
+  ],
+
+  // === FIELDS ===
+  fields: objectField(
+    {
+      type: WidgetType.FORM_FIELD,
+      fieldType: FieldDataType.TEXT,
+      label: "app.api.system.dev.lint.container.title",
+      columns: 12,
+    },
+    { request: "data", response: true },
+    {
+      // === REQUEST FIELDS ===
+      skipEndpoints: requestDataField(
+        {
+          type: WidgetType.FORM_FIELD,
+          fieldType: FieldDataType.BOOLEAN,
+          label: "app.api.system.dev.typecheck.title",
+          description: "app.api.system.dev.typecheck.description",
+          columns: 6,
+        },
+        z.boolean().default(false),
+      ),
+
+      skipSeeds: requestDataField(
+        {
+          type: WidgetType.FORM_FIELD,
+          fieldType: FieldDataType.BOOLEAN,
+          label: "app.api.system.dev.typecheck.title",
+          description: "app.api.system.dev.typecheck.description",
+          columns: 6,
+        },
+        z.boolean().default(false),
+      ),
+
+      skipCronTasks: requestDataField(
+        {
+          type: WidgetType.FORM_FIELD,
+          fieldType: FieldDataType.BOOLEAN,
+          label: "app.api.system.dev.typecheck.title",
+          description: "app.api.system.dev.typecheck.description",
+          columns: 6,
+        },
+        z.boolean().default(false),
+      ),
+
+      skipTRPCRouter: requestDataField(
+        {
+          type: WidgetType.FORM_FIELD,
+          fieldType: FieldDataType.BOOLEAN,
+          label: "app.api.system.dev.typecheck.title",
+          description: "app.api.system.dev.typecheck.description",
+          columns: 6,
+        },
+        z.boolean().default(false),
+      ),
+
+      rootDir: requestDataField(
+        {
+          type: WidgetType.FORM_FIELD,
+          fieldType: FieldDataType.TEXT,
+          label: "app.api.system.dev.typecheck.title",
+          description: "app.api.system.dev.typecheck.description",
+          columns: 6,
+        },
+        z.string().optional(),
+      ),
+
+      verbose: requestDataField(
+        {
+          type: WidgetType.FORM_FIELD,
+          fieldType: FieldDataType.BOOLEAN,
+          label: "app.api.system.dev.typecheck.title",
+          description: "app.api.system.dev.typecheck.description",
+          columns: 6,
+        },
+        z.boolean().default(false),
+      ),
+
+      // === RESPONSE FIELDS ===
+      success: responseField(
+        {
+          type: WidgetType.TEXT,
+          content: "app.api.system.dev.typecheck.success.title",
+        },
+        z.boolean(),
+      ),
+      generatorsRun: responseField(
+        {
+          type: WidgetType.TEXT,
+          content: "app.api.system.dev.typecheck.success.title",
+        },
+        z.coerce.number(),
+      ),
+      generatorsSkipped: responseField(
+        {
+          type: WidgetType.TEXT,
+          content: "app.api.system.dev.typecheck.success.title",
+        },
+        z.coerce.number(),
+      ),
+      output: responseField(
+        {
+          type: WidgetType.TEXT,
+          content: "app.api.system.dev.typecheck.success.title",
+        },
+        z.array(z.string()),
+      ),
+      results: responseField(
+        {
+          type: WidgetType.TEXT,
+          content: "app.api.system.dev.typecheck.success.title",
+        },
+        z.object({
+          endpoints: z.boolean(),
+          seeds: z.boolean(),
+          cronTasks: z.boolean(),
+          trpcRouter: z.boolean(),
+        }),
+      ),
+    },
+  ),
+
+  // === ERROR HANDLING ===
+  errorTypes: {
+    [EndpointErrorTypes.VALIDATION_FAILED]: {
+      title: "app.api.system.dev.typecheck.title",
+      description: "app.api.system.dev.typecheck.description",
+    },
+    [EndpointErrorTypes.UNAUTHORIZED]: {
+      title: "app.api.system.dev.typecheck.title",
+      description: "app.api.system.dev.typecheck.description",
+    },
+    [EndpointErrorTypes.SERVER_ERROR]: {
+      title: "app.api.system.dev.typecheck.title",
+      description: "app.api.system.dev.typecheck.description",
+    },
+    [EndpointErrorTypes.NETWORK_ERROR]: {
+      title: "app.api.system.dev.typecheck.title",
+      description: "app.api.system.dev.typecheck.description",
+    },
+    [EndpointErrorTypes.FORBIDDEN]: {
+      title: "app.api.system.dev.typecheck.title",
+      description: "app.api.system.dev.typecheck.description",
+    },
+    [EndpointErrorTypes.NOT_FOUND]: {
+      title: "app.api.system.dev.typecheck.title",
+      description: "app.api.system.dev.typecheck.description",
+    },
+    [EndpointErrorTypes.CONFLICT]: {
+      title: "app.api.system.dev.typecheck.title",
+      description: "app.api.system.dev.typecheck.description",
+    },
+    [EndpointErrorTypes.UNKNOWN_ERROR]: {
+      title: "app.api.system.dev.typecheck.title",
+      description: "app.api.system.dev.typecheck.description",
+    },
+    [EndpointErrorTypes.UNSAVED_CHANGES]: {
+      title: "app.api.system.dev.typecheck.title",
+      description: "app.api.system.dev.typecheck.description",
+    },
+  },
+
+  // === SUCCESS HANDLING ===
+  successTypes: {
+    title: "app.api.system.dev.typecheck.success.title",
+    description: "app.api.system.dev.typecheck.success.description",
+  },
+
+  // === EXAMPLES ===
+  examples: {
+    requests: {
+      default: {
+        skipEndpoints: false,
+        skipSeeds: false,
+        skipCronTasks: false,
+        skipTRPCRouter: false,
+        verbose: false,
+      },
+    },
+    responses: {
+      default: {
+        success: true,
+        generatorsRun: 4,
+        generatorsSkipped: 0,
+        output: [
+          "Generated endpoints",
+          "Generated seeds",
+          "Generated cron tasks",
+          "Generated tRPC router",
+        ],
+        results: {
+          endpoints: true,
+          seeds: true,
+          cronTasks: true,
+          trpcRouter: true,
+        },
+      },
+    },
+    urlPathParams: undefined,
+  },
+});
+
+const endpointsGeneratorEndpoints = { POST };
+export default endpointsGeneratorEndpoints;

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

@@ -0,0 +1,54 @@
+import type { translations as enTranslations } from "../en";
+
+export const translations: typeof enTranslations = {
+  post: {
+    title: "Titel",
+    description: "Endpunkt-Beschreibung",
+    form: {
+      title: "Konfiguration",
+      description: "Parameter konfigurieren",
+    },
+    response: {
+      title: "Antwort",
+      description: "Antwortdaten",
+    },
+    errors: {
+      unauthorized: {
+        title: "Nicht autorisiert",
+        description: "Authentifizierung erforderlich",
+      },
+      validation: {
+        title: "Validierungsfehler",
+        description: "Ungültige Anfrageparameter",
+      },
+      server: {
+        title: "Serverfehler",
+        description: "Interner Serverfehler",
+      },
+      unknown: {
+        title: "Unbekannter Fehler",
+        description: "Ein unbekannter Fehler ist aufgetreten",
+      },
+      network: {
+        title: "Netzwerkfehler",
+        description: "Netzwerkfehler aufgetreten",
+      },
+      forbidden: {
+        title: "Verboten",
+        description: "Zugriff verboten",
+      },
+      notFound: {
+        title: "Nicht gefunden",
+        description: "Ressource nicht gefunden",
+      },
+      conflict: {
+        title: "Konflikt",
+        description: "Datenkonflikt aufgetreten",
+      },
+    },
+    success: {
+      title: "Erfolg",
+      description: "Vorgang erfolgreich abgeschlossen",
+    },
+  },
+};

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

@@ -0,0 +1,52 @@
+export const translations = {
+  post: {
+    title: "Endpoints",
+    description: "Endpoints endpoint",
+    form: {
+      title: "Endpoints Configuration",
+      description: "Configure endpoints parameters",
+    },
+    response: {
+      title: "Response",
+      description: "Endpoints response data",
+    },
+    errors: {
+      unauthorized: {
+        title: "Unauthorized",
+        description: "Authentication required",
+      },
+      validation: {
+        title: "Validation Error",
+        description: "Invalid request parameters",
+      },
+      server: {
+        title: "Server Error",
+        description: "Internal server error occurred",
+      },
+      unknown: {
+        title: "Unknown Error",
+        description: "An unknown error occurred",
+      },
+      network: {
+        title: "Network Error",
+        description: "Network error occurred",
+      },
+      forbidden: {
+        title: "Forbidden",
+        description: "Access forbidden",
+      },
+      notFound: {
+        title: "Not Found",
+        description: "Resource not found",
+      },
+      conflict: {
+        title: "Conflict",
+        description: "Data conflict occurred",
+      },
+    },
+    success: {
+      title: "Success",
+      description: "Operation completed successfully",
+    },
+  },
+};