@spfn/core 0.1.0-alpha.88 → 0.2.0-beta.10

package/dist/nextjs/server.js

@@ -0,0 +1,637 @@
+import { NextResponse } from 'next/server';
+import { env } from '@spfn/core/config';
+import { logger } from '@spfn/core/logger';
+
+// src/nextjs/proxy/rpc.ts
+
+// src/nextjs/shared.ts
+function buildUrlWithParams(path, params) {
+  let url = path;
+  for (const [key, value] of Object.entries(params)) {
+    url = url.replace(`:${key}`, encodeURIComponent(String(value)));
+  }
+  return url;
+}
+function buildQueryString(query) {
+  if (Object.keys(query).length === 0) {
+    return "";
+  }
+  const searchParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (Array.isArray(value)) {
+      value.forEach((v) => searchParams.append(key, String(v)));
+    } else {
+      searchParams.append(key, String(value));
+    }
+  }
+  return `?${searchParams.toString()}`;
+}
+async function parseResponseBody(response) {
+  if (response.status === 204) {
+    return null;
+  }
+  const contentType = response.headers.get("content-type");
+  if (contentType?.includes("application/json")) {
+    const text = await response.text();
+    return text ? JSON.parse(text) : null;
+  } else {
+    return await response.text();
+  }
+}
+
+// src/nextjs/proxy/interceptors/helpers.ts
+function matchPath(path, pattern) {
+  if (pattern === "*") {
+    return true;
+  }
+  if (pattern instanceof RegExp) {
+    return pattern.test(path);
+  }
+  const regexPattern = pattern.replace(/\*/g, ".*").replace(/:[^/]+/g, "[^/]+").replace(/\//g, "\\/");
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(path);
+}
+function matchMethod(method, pattern) {
+  if (!pattern) {
+    return true;
+  }
+  if (typeof pattern === "string") {
+    return method.toUpperCase() === pattern.toUpperCase();
+  }
+  return pattern.some((m) => m.toUpperCase() === method.toUpperCase());
+}
+function filterMatchingInterceptors(rules, path, method) {
+  return rules.filter((rule) => {
+    return matchPath(path, rule.pathPattern) && matchMethod(method, rule.method);
+  });
+}
+async function executeRequestInterceptors(context, interceptors) {
+  let index = 0;
+  const next = async () => {
+    if (index >= interceptors.length) {
+      return;
+    }
+    const interceptor = interceptors[index];
+    index++;
+    await interceptor(context, next);
+  };
+  await next();
+}
+async function executeResponseInterceptors(context, interceptors) {
+  let index = 0;
+  const next = async () => {
+    if (index >= interceptors.length) {
+      return;
+    }
+    const interceptor = interceptors[index];
+    index++;
+    await interceptor(context, next);
+  };
+  await next();
+}
+
+// src/nextjs/proxy/interceptors/registry.ts
+var InterceptorRegistry = class {
+  interceptors = /* @__PURE__ */ new Map();
+  /**
+   * Register interceptors for a package
+   *
+   * @param packageName - Unique package identifier (e.g., 'auth', 'storage')
+   * @param interceptors - Array of interceptor rules
+   *
+   * @example
+   * ```typescript
+   * registerInterceptors('auth', [
+   *   {
+   *     pathPattern: '/_auth/*',
+   *     request: async (ctx, next) => { ... }
+   *   }
+   * ]);
+   * ```
+   */
+  register(packageName, interceptors) {
+    if (!this.interceptors.has(packageName)) {
+      this.interceptors.set(packageName, interceptors);
+    }
+  }
+  /**
+   * Get all registered interceptors
+   *
+   * @param exclude - Package names to exclude
+   * @returns Flat array of all interceptor rules
+   */
+  getAll(exclude = []) {
+    const all = [];
+    for (const [packageName, interceptors] of this.interceptors.entries()) {
+      if (!exclude.includes(packageName)) {
+        all.push(...interceptors);
+      }
+    }
+    return all;
+  }
+  /**
+   * Get interceptors for specific package
+   *
+   * @param packageName - Package identifier
+   * @returns Interceptor rules or undefined
+   */
+  get(packageName) {
+    return this.interceptors.get(packageName);
+  }
+  /**
+   * Get list of registered package names
+   */
+  getPackageNames() {
+    return Array.from(this.interceptors.keys());
+  }
+  /**
+   * Check if package has registered interceptors
+   */
+  has(packageName) {
+    return this.interceptors.has(packageName);
+  }
+  /**
+   * Unregister interceptors for a package
+   *
+   * @param packageName - Package identifier
+   */
+  unregister(packageName) {
+    this.interceptors.delete(packageName);
+  }
+  /**
+   * Clear all registered interceptors
+   *
+   * Useful for testing
+   */
+  clear() {
+    this.interceptors.clear();
+  }
+  /**
+   * Get total count of registered interceptors
+   */
+  count() {
+    let total = 0;
+    for (const interceptors of this.interceptors.values()) {
+      total += interceptors.length;
+    }
+    return total;
+  }
+};
+var interceptorRegistry = (() => {
+  if (!globalThis.__SPFN_INTERCEPTOR_REGISTRY__) {
+    globalThis.__SPFN_INTERCEPTOR_REGISTRY__ = new InterceptorRegistry();
+  }
+  return globalThis.__SPFN_INTERCEPTOR_REGISTRY__;
+})();
+function registerInterceptors(packageName, interceptors) {
+  interceptorRegistry.register(packageName, interceptors);
+}
+
+// src/nextjs/proxy/helpers.ts
+function buildProxyHeaders(sourceHeaders, defaultHeaders) {
+  const headers = new Headers();
+  const headersToForward2 = [
+    "content-type",
+    "authorization",
+    "cookie",
+    "user-agent",
+    "accept",
+    "accept-language"
+  ];
+  for (const header of headersToForward2) {
+    const value = sourceHeaders instanceof Headers ? sourceHeaders.get(header) : sourceHeaders[header];
+    if (value) {
+      headers.set(header, value);
+    }
+  }
+  for (const [key, value] of Object.entries(defaultHeaders)) {
+    headers.set(key, value);
+  }
+  return headers;
+}
+function parseCookies(cookieHeader) {
+  const cookiesMap = /* @__PURE__ */ new Map();
+  if (!cookieHeader) {
+    return cookiesMap;
+  }
+  const cookiePairs = cookieHeader.split(";").map((c) => c.trim());
+  for (const pair of cookiePairs) {
+    const [name, ...valueParts] = pair.split("=");
+    if (name && valueParts.length > 0) {
+      const value = valueParts.join("=");
+      cookiesMap.set(name.trim(), value.trim());
+    }
+  }
+  return cookiesMap;
+}
+function parseCookiesFromNextRequest(request) {
+  const cookiesMap = /* @__PURE__ */ new Map();
+  for (const cookie of request.cookies.getAll()) {
+    cookiesMap.set(cookie.name, cookie.value);
+  }
+  const cookieHeader = request.headers.get("cookie");
+  if (cookieHeader) {
+    const parsed = parseCookies(cookieHeader);
+    for (const [name, value] of parsed.entries()) {
+      cookiesMap.set(name, value);
+    }
+  }
+  return cookiesMap;
+}
+var optionMappings = [
+  { key: "httpOnly", format: (v) => v ? "HttpOnly" : null },
+  { key: "secure", format: (v) => v ? "Secure" : null },
+  { key: "sameSite", format: (v) => v ? `SameSite=${v}` : null },
+  { key: "maxAge", format: (v) => v !== void 0 ? `Max-Age=${v}` : null },
+  { key: "path", format: (v) => v ? `Path=${v}` : null },
+  { key: "domain", format: (v) => v ? `Domain=${v}` : null }
+];
+function buildSetCookieHeader(cookie) {
+  const parts = [`${cookie.name}=${cookie.value}`];
+  const options = cookie.options || {};
+  for (const { key, format } of optionMappings) {
+    const value = options[key];
+    if (value !== void 0 && value !== false) {
+      const formatted = format(value);
+      if (formatted) {
+        parts.push(formatted);
+      }
+    }
+  }
+  return parts.join("; ");
+}
+function buildErrorResponse(errorType, message, debug, error) {
+  return {
+    error: errorType,
+    message,
+    ...debug && error?.stack && { stack: error.stack }
+  };
+}
+var headersToForward = [
+  "content-type",
+  "cache-control",
+  "set-cookie",
+  "etag",
+  "last-modified"
+];
+function forwardResponseHeaders(sourceHeaders, targetHeaders) {
+  for (const header of headersToForward) {
+    const value = sourceHeaders.get(header);
+    if (value) {
+      targetHeaders.set(header, value);
+    }
+  }
+}
+function collectInterceptors(autoDiscoverInterceptors, disableAutoInterceptors, configInterceptors, registry) {
+  const allInterceptors = [];
+  if (autoDiscoverInterceptors) {
+    const registeredInterceptors = registry.getAll(disableAutoInterceptors || []);
+    allInterceptors.push(...registeredInterceptors);
+  }
+  if (configInterceptors) {
+    allInterceptors.push(...configInterceptors);
+  }
+  return allInterceptors;
+}
+function buildRequestContext(path, method, headers, body, searchParams, cookiesMap, request) {
+  return {
+    path: `/${path}`,
+    method,
+    headers: Object.fromEntries(headers.entries()),
+    body,
+    query: Object.fromEntries(searchParams.entries()),
+    cookies: cookiesMap,
+    request,
+    metadata: {}
+  };
+}
+function buildResponseContext(path, method, requestHeaders, requestBody, response, responseBody, requestMetadata) {
+  return {
+    path: `/${path}`,
+    method,
+    request: {
+      headers: Object.fromEntries(requestHeaders.entries()),
+      body: requestBody
+    },
+    response: {
+      ok: response.ok,
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers,
+      body: responseBody
+    },
+    setCookies: [],
+    metadata: requestMetadata
+  };
+}
+
+// src/nextjs/proxy/rpc.ts
+var rpcLogger = logger.child("@spfn/core:rpc-proxy");
+function isRouteDef(value) {
+  return value !== null && typeof value === "object" && "handler" in value && "method" in value && "path" in value;
+}
+function isRouter(value) {
+  return value !== null && typeof value === "object" && "routes" in value && "_routes" in value;
+}
+function getRouteByPath(router, routePath) {
+  const parts = routePath.split(".");
+  let current = router.routes;
+  for (const part of parts) {
+    if (!current || typeof current !== "object") {
+      return null;
+    }
+    const next = current[part];
+    if (isRouter(next)) {
+      current = next.routes;
+    } else if (isRouteDef(next)) {
+      return next;
+    } else {
+      current = next;
+    }
+  }
+  if (isRouteDef(current)) {
+    return current;
+  }
+  return null;
+}
+function createRpcProxy(config) {
+  const {
+    apiUrl = env.SPFN_API_URL || "http://localhost:8790",
+    debug = env.NODE_ENV === "development",
+    timeout = 3e4,
+    headers: defaultHeaders = {},
+    interceptors,
+    autoDiscoverInterceptors = true,
+    disableAutoInterceptors
+  } = config;
+  const useRouteMap = "routeMap" in config && config.routeMap !== void 0;
+  const routeMap = useRouteMap ? config.routeMap : null;
+  const router = !useRouteMap && "router" in config ? config.router : null;
+  const packageRouters = router?._packageRouters || [];
+  function resolveRoute(routeName) {
+    if (routeMap) {
+      const entry = routeMap[routeName];
+      if (entry) {
+        return { method: entry.method, path: entry.path };
+      }
+      return null;
+    }
+    if (router) {
+      let routeDef = getRouteByPath(router, routeName);
+      if (!routeDef && packageRouters.length > 0) {
+        for (const pkgRouter of packageRouters) {
+          routeDef = getRouteByPath(pkgRouter, routeName);
+          if (routeDef) {
+            if (debug) {
+              rpcLogger.debug(`Route "${routeName}" found in package router`);
+            }
+            break;
+          }
+        }
+      }
+      if (routeDef && routeDef.method && routeDef.path) {
+        return { method: routeDef.method, path: routeDef.path };
+      }
+    }
+    return null;
+  }
+  async function handleRpc(request, context) {
+    const startTime = Date.now();
+    const params = await context.params;
+    try {
+      const routeName = params.routeName;
+      if (!routeName) {
+        return NextResponse.json(
+          buildErrorResponse("Bad Request", "Missing routeName parameter", debug),
+          { status: 400 }
+        );
+      }
+      let input = {};
+      let rawFormData = null;
+      if (request.method === "GET") {
+        const inputParam = request.nextUrl.searchParams.get("input");
+        if (inputParam) {
+          try {
+            input = JSON.parse(decodeURIComponent(inputParam));
+          } catch {
+            return NextResponse.json(
+              buildErrorResponse("Bad Request", "Invalid input parameter", debug),
+              { status: 400 }
+            );
+          }
+        }
+      } else {
+        const contentType = request.headers.get("content-type") || "";
+        if (contentType.includes("multipart/form-data")) {
+          try {
+            rawFormData = await request.formData();
+            const metadataStr = rawFormData.get("__metadata");
+            if (metadataStr && typeof metadataStr === "string") {
+              const metadata = JSON.parse(metadataStr);
+              input.params = metadata.params;
+              input.query = metadata.query;
+              input.headers = metadata.headers;
+              input.cookies = metadata.cookies;
+            }
+            input.formData = {};
+            rawFormData.forEach((value, key) => {
+              if (key === "__metadata") return;
+              const existing = input.formData[key];
+              if (existing !== void 0) {
+                if (Array.isArray(existing)) {
+                  existing.push(value);
+                } else {
+                  input.formData[key] = [existing, value];
+                }
+              } else {
+                input.formData[key] = value;
+              }
+            });
+          } catch (error) {
+            return NextResponse.json(
+              buildErrorResponse("Bad Request", "Invalid form data", debug),
+              { status: 400 }
+            );
+          }
+        } else {
+          try {
+            input = await request.json();
+          } catch {
+            return NextResponse.json(
+              buildErrorResponse("Bad Request", "Invalid JSON body", debug),
+              { status: 400 }
+            );
+          }
+        }
+      }
+      const routeInfo = resolveRoute(routeName);
+      if (!routeInfo) {
+        rpcLogger.warn(`Route not found: ${routeName}`);
+        return NextResponse.json(
+          buildErrorResponse("Not Found", `Route "${routeName}" not found`, debug),
+          { status: 404 }
+        );
+      }
+      const { method: targetMethod, path: targetPath } = routeInfo;
+      const inputParams = input.params || {};
+      const inputQuery = input.query || {};
+      const inputBody = input.body;
+      const inputFormData = input.formData;
+      const hasFormData = rawFormData !== null && inputFormData && Object.keys(inputFormData).length > 0;
+      const resolvedPath = buildUrlWithParams(targetPath, inputParams);
+      const queryString = buildQueryString(inputQuery);
+      const targetUrl = `${apiUrl}${resolvedPath}${queryString}`;
+      if (debug) {
+        rpcLogger.debug("\u2192 RPC request", {
+          routeName,
+          targetMethod,
+          targetPath: resolvedPath,
+          targetUrl,
+          hasBody: !!inputBody,
+          hasFormData
+        });
+      }
+      const headers = buildProxyHeaders(request.headers, defaultHeaders);
+      if (hasFormData) {
+        headers.delete("content-type");
+      }
+      const fetchOptions = {
+        method: targetMethod,
+        headers
+      };
+      if (["POST", "PUT", "PATCH"].includes(targetMethod)) {
+        if (hasFormData && rawFormData) {
+          const forwardFormData = new FormData();
+          rawFormData.forEach((value, key) => {
+            if (key !== "__metadata") {
+              forwardFormData.append(key, value);
+            }
+          });
+          fetchOptions.body = forwardFormData;
+        } else if (inputBody) {
+          fetchOptions.body = JSON.stringify(inputBody);
+        }
+      }
+      const allInterceptors = collectInterceptors(autoDiscoverInterceptors, disableAutoInterceptors, interceptors, interceptorRegistry);
+      const matchingInterceptors = filterMatchingInterceptors(allInterceptors, resolvedPath, targetMethod);
+      if (debug && matchingInterceptors.length > 0) {
+        rpcLogger.debug(`\u{1F3AF} Found ${matchingInterceptors.length} matching interceptors for ${targetMethod} ${resolvedPath}`);
+      }
+      const cookiesMap = parseCookiesFromNextRequest(request);
+      const requestCtx = buildRequestContext(
+        resolvedPath.slice(1),
+        // Remove leading slash
+        targetMethod,
+        headers,
+        inputBody,
+        new URLSearchParams(queryString.slice(1)),
+        // Remove leading ?
+        cookiesMap,
+        request
+      );
+      const requestInterceptorsToRun = matchingInterceptors.map((r) => r.request).filter((i) => !!i);
+      if (requestInterceptorsToRun.length > 0) {
+        await executeRequestInterceptors(requestCtx, requestInterceptorsToRun);
+        for (const [key, value] of Object.entries(requestCtx.headers)) {
+          headers.set(key, value);
+        }
+        if (requestCtx.body) {
+          fetchOptions.body = JSON.stringify(requestCtx.body);
+        }
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      try {
+        const response = await fetch(targetUrl, {
+          ...fetchOptions,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        let body = await parseResponseBody(response);
+        const responseCtx = buildResponseContext(
+          resolvedPath.slice(1),
+          targetMethod,
+          headers,
+          inputBody,
+          response,
+          body,
+          requestCtx.metadata
+        );
+        const responseInterceptorsToRun = matchingInterceptors.map((r) => r.response).filter((i) => !!i);
+        if (responseInterceptorsToRun.length > 0) {
+          await executeResponseInterceptors(responseCtx, responseInterceptorsToRun);
+          body = responseCtx.response.body;
+        }
+        const duration = Date.now() - startTime;
+        if (debug) {
+          rpcLogger.debug("\u2190 RPC response", {
+            routeName,
+            status: responseCtx.response.status,
+            duration: `${duration}ms`
+          });
+        }
+        const nextResponse = responseCtx.response.status === 204 ? new NextResponse(null, {
+          status: 204,
+          statusText: responseCtx.response.statusText
+        }) : NextResponse.json(body, {
+          status: responseCtx.response.status,
+          statusText: responseCtx.response.statusText
+        });
+        forwardResponseHeaders(response.headers, nextResponse.headers);
+        for (const cookie of responseCtx.setCookies) {
+          const setCookieHeader = buildSetCookieHeader(cookie);
+          nextResponse.headers.append("Set-Cookie", setCookieHeader);
+          if (debug) {
+            rpcLogger.debug("\u{1F36A} Set-Cookie header added", {
+              name: cookie.name
+            });
+          }
+        }
+        return nextResponse;
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof Error && error.name === "AbortError") {
+          rpcLogger.error("Request timeout", {
+            routeName,
+            targetUrl,
+            timeout
+          });
+          return NextResponse.json(
+            buildErrorResponse("Gateway Timeout", `Request timed out after ${timeout}ms`, debug, error),
+            { status: 504 }
+          );
+        }
+        const fetchErr = error;
+        rpcLogger.error("Fetch error", {
+          routeName,
+          targetUrl,
+          error: fetchErr.message
+        });
+        return NextResponse.json(
+          buildErrorResponse("Bad Gateway", fetchErr.message || "Failed to connect to backend", debug, fetchErr),
+          { status: 502 }
+        );
+      }
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      const err = error;
+      rpcLogger.error("RPC proxy error", {
+        error: err.message,
+        stack: err.stack,
+        duration: `${duration}ms`
+      });
+      return NextResponse.json(
+        buildErrorResponse("Internal Server Error", err.message || "Unknown error", debug, err),
+        { status: 500 }
+      );
+    }
+  }
+  return {
+    GET: (req, context) => handleRpc(req, context),
+    POST: (req, context) => handleRpc(req, context)
+  };
+}
+
+export { createRpcProxy, executeRequestInterceptors, executeResponseInterceptors, filterMatchingInterceptors, interceptorRegistry, matchMethod, matchPath, registerInterceptors };
+//# sourceMappingURL=server.js.map
+//# sourceMappingURL=server.js.map