@spfn/core 0.1.0-alpha.64 → 0.1.0-alpha.68

package/dist/route/index.js

@@ -4,6 +4,7 @@ import { join, dirname, relative } from 'path';
 import { readdir, stat } from 'fs/promises';
 import { Value } from '@sinclair/typebox/value';
 import { Hono } from 'hono';
+import { Type } from '@sinclair/typebox';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -118,11 +119,11 @@ function formatTimestampHuman(date) {
   const ms = String(date.getMilliseconds()).padStart(3, "0");
   return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${ms}`;
 }
-function formatError(error) {
+function formatError(error2) {
   const lines = [];
-  lines.push(`${error.name}: ${error.message}`);
-  if (error.stack) {
-    const stackLines = error.stack.split("\n").slice(1);
+  lines.push(`${error2.name}: ${error2.message}`);
+  if (error2.stack) {
+    const stackLines = error2.stack.split("\n").slice(1);
     lines.push(...stackLines);
   }
   return lines.join("\n");
@@ -308,7 +309,7 @@ var init_logger = __esm({
       /**
        * Log processing (internal)
        */
-      log(level, message, error, context) {
+      log(level, message, error2, context) {
         if (LOG_LEVEL_PRIORITY[level] < LOG_LEVEL_PRIORITY[this.config.level]) {
           return;
         }
@@ -317,7 +318,7 @@ var init_logger = __esm({
           level,
           message,
           module: this.module,
-          error,
+          error: error2,
           // Mask sensitive information in context to prevent credential leaks
           context: context ? maskSensitiveData(context) : void 0
         };
@@ -328,8 +329,8 @@ var init_logger = __esm({
        */
       processTransports(metadata) {
         const promises = this.config.transports.filter((transport) => transport.enabled).map((transport) => this.safeTransportLog(transport, metadata));
-        Promise.all(promises).catch((error) => {
-          const errorMessage = error instanceof Error ? error.message : String(error);
+        Promise.all(promises).catch((error2) => {
+          const errorMessage = error2 instanceof Error ? error2.message : String(error2);
           process.stderr.write(`[Logger] Transport error: ${errorMessage}
 `);
         });
@@ -340,8 +341,8 @@ var init_logger = __esm({
       async safeTransportLog(transport, metadata) {
         try {
           await transport.log(metadata);
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
+        } catch (error2) {
+          const errorMessage = error2 instanceof Error ? error2.message : String(error2);
           process.stderr.write(`[Logger] Transport "${transport.name}" failed: ${errorMessage}
 `);
         }
@@ -431,11 +432,11 @@ var init_file = __esm({
         }
         if (this.currentStream) {
           return new Promise((resolve, reject) => {
-            this.currentStream.write(message + "\n", "utf-8", (error) => {
-              if (error) {
-                process.stderr.write(`[FileTransport] Failed to write log: ${error.message}
+            this.currentStream.write(message + "\n", "utf-8", (error2) => {
+              if (error2) {
+                process.stderr.write(`[FileTransport] Failed to write log: ${error2.message}
 `);
-                reject(error);
+                reject(error2);
               } else {
                 resolve();
               }
@@ -457,8 +458,8 @@ var init_file = __esm({
           encoding: "utf-8"
         });
         this.currentFilename = filename;
-        this.currentStream.on("error", (error) => {
-          process.stderr.write(`[FileTransport] Stream error: ${error.message}
+        this.currentStream.on("error", (error2) => {
+          process.stderr.write(`[FileTransport] Stream error: ${error2.message}
 `);
           this.currentStream = null;
           this.currentFilename = null;
@@ -472,9 +473,9 @@ var init_file = __esm({
           return;
         }
         return new Promise((resolve, reject) => {
-          this.currentStream.end((error) => {
-            if (error) {
-              reject(error);
+          this.currentStream.end((error2) => {
+            if (error2) {
+              reject(error2);
             } else {
               this.currentStream = null;
               this.currentFilename = null;
@@ -499,8 +500,8 @@ var init_file = __esm({
           if (stats.size >= this.maxFileSize) {
             await this.rotateBySize();
           }
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
+        } catch (error2) {
+          const errorMessage = error2 instanceof Error ? error2.message : String(error2);
           process.stderr.write(`[FileTransport] Failed to check file size: ${errorMessage}
 `);
         }
@@ -526,8 +527,8 @@ var init_file = __esm({
             const newPath2 = join(this.logDir, `${baseName}.${newNum}.log`);
             try {
               renameSync(oldPath, newPath2);
-            } catch (error) {
-              const errorMessage = error instanceof Error ? error.message : String(error);
+            } catch (error2) {
+              const errorMessage = error2 instanceof Error ? error2.message : String(error2);
               process.stderr.write(`[FileTransport] Failed to rotate file: ${errorMessage}
 `);
             }
@@ -539,8 +540,8 @@ var init_file = __esm({
           if (existsSync(currentPath)) {
             renameSync(currentPath, newPath);
           }
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
+        } catch (error2) {
+          const errorMessage = error2 instanceof Error ? error2.message : String(error2);
           process.stderr.write(`[FileTransport] Failed to rotate current file: ${errorMessage}
 `);
         }
@@ -567,15 +568,15 @@ var init_file = __esm({
               const filepath = join(this.logDir, file);
               try {
                 unlinkSync(filepath);
-              } catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
+              } catch (error2) {
+                const errorMessage = error2 instanceof Error ? error2.message : String(error2);
                 process.stderr.write(`[FileTransport] Failed to delete old file "${file}": ${errorMessage}
 `);
               }
             }
           }
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
+        } catch (error2) {
+          const errorMessage = error2 instanceof Error ? error2.message : String(error2);
           process.stderr.write(`[FileTransport] Failed to clean old files: ${errorMessage}
 `);
         }
@@ -634,8 +635,8 @@ function validateDirectoryWritable(dirPath) {
   if (!existsSync(dirPath)) {
     try {
       mkdirSync(dirPath, { recursive: true });
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
+    } catch (error2) {
+      const errorMessage = error2 instanceof Error ? error2.message : String(error2);
       throw new Error(`Failed to create log directory "${dirPath}": ${errorMessage}`);
     }
   }
@@ -648,8 +649,8 @@ function validateDirectoryWritable(dirPath) {
   try {
     writeFileSync(testFile, "test", "utf-8");
     unlinkSync(testFile);
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
+  } catch (error2) {
+    const errorMessage = error2 instanceof Error ? error2.message : String(error2);
     throw new Error(`Cannot write to log directory "${dirPath}": ${errorMessage}`);
   }
 }
@@ -726,11 +727,11 @@ function validateConfig() {
     validateFileConfig();
     validateSlackConfig();
     validateEmailConfig();
-  } catch (error) {
-    if (error instanceof Error) {
-      throw new Error(`[Logger] Configuration validation failed: ${error.message}`);
+  } catch (error2) {
+    if (error2 instanceof Error) {
+      throw new Error(`[Logger] Configuration validation failed: ${error2.message}`);
     }
-    throw error;
+    throw error2;
   }
 }
 var init_config = __esm({
@@ -868,24 +869,28 @@ function discoverFunctionRoutes(cwd = process.cwd()) {
         const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
         if (pkg.spfn?.routes?.dir) {
           const { dir } = pkg.spfn.routes;
+          const prefix = pkg.spfn.prefix;
           const packagePath = dirname(pkgPath);
           const routesDir = join(packagePath, dir);
           functions.push({
             packageName,
             routesDir,
-            packagePath
+            packagePath,
+            prefix
+            // Include prefix in function info
           });
           routeLogger.debug("Discovered function routes", {
             package: packageName,
-            dir
+            dir,
+            prefix: prefix || "(none)"
           });
         }
-      } catch (error) {
+      } catch (error2) {
       }
     }
-  } catch (error) {
+  } catch (error2) {
     routeLogger.warn("Failed to discover function routes", {
-      error: error instanceof Error ? error.message : "Unknown error"
+      error: error2 instanceof Error ? error2.message : "Unknown error"
     });
   }
   return functions;
@@ -919,8 +924,8 @@ var AutoRouteLoader = class {
     }
     let failureCount = 0;
     for (const file of files) {
-      const success = await this.loadRoute(app, file);
-      if (success) ; else {
+      const success2 = await this.loadRoute(app, file);
+      if (success2) ; else {
         failureCount++;
       }
     }
@@ -936,14 +941,15 @@ var AutoRouteLoader = class {
   }
   /**
    * Load routes from an external directory (e.g., from SPFN function packages)
-   * Routes use contract-based absolute paths, so no basePath prefix needed
+   * Reads package.json spfn.prefix and mounts routes under that prefix
    *
    * @param app - Hono app instance
    * @param routesDir - Directory containing route handlers
    * @param packageName - Name of the package (for logging)
+   * @param prefix - Optional prefix to mount routes under (from package.json spfn.prefix)
    * @returns Route statistics
    */
-  async loadExternalRoutes(app, routesDir, packageName) {
+  async loadExternalRoutes(app, routesDir, packageName, prefix) {
     const startTime = Date.now();
     const tempRoutesDir = this.routesDir;
     this.routesDir = routesDir;
@@ -956,8 +962,8 @@ var AutoRouteLoader = class {
     let successCount = 0;
     let failureCount = 0;
     for (const file of files) {
-      const success = await this.loadRoute(app, file);
-      if (success) {
+      const success2 = await this.loadRoute(app, file, prefix);
+      if (success2) {
         successCount++;
       } else {
         failureCount++;
@@ -967,6 +973,7 @@ var AutoRouteLoader = class {
     if (this.debug) {
       routeLogger2.info("External routes loaded", {
         package: packageName,
+        prefix: prefix || "/",
         total: successCount,
         failed: failureCount,
         elapsed: `${elapsed}ms`
@@ -1010,7 +1017,7 @@ var AutoRouteLoader = class {
   isValidRouteFile(fileName) {
     return fileName === "index.ts" || fileName === "index.js" || fileName === "index.mjs";
   }
-  async loadRoute(app, absolutePath) {
+  async loadRoute(app, absolutePath, prefix) {
     const relativePath = relative(this.routesDir, absolutePath);
     try {
       const module = await import(absolutePath);
@@ -1026,11 +1033,24 @@ var AutoRouteLoader = class {
         return false;
       }
       const contractPaths = this.extractContractPaths(module);
+      if (prefix) {
+        const invalidPaths = contractPaths.filter((path) => !path.startsWith(prefix));
+        if (invalidPaths.length > 0) {
+          routeLogger2.error("Contract paths must include the package prefix", {
+            file: relativePath,
+            prefix,
+            invalidPaths,
+            hint: `Contract paths should start with "${prefix}". Example: path: "${prefix}/labels"`
+          });
+          return false;
+        }
+      }
       this.registerContractBasedMiddlewares(app, contractPaths, module);
       app.route("/", module.default);
       contractPaths.forEach((path) => {
         this.routes.push({
           path,
+          // Use contract path as-is (already includes prefix)
           file: relativePath,
           meta: module.meta,
           priority: this.calculateContractPriority(path)
@@ -1041,8 +1061,8 @@ var AutoRouteLoader = class {
         }
       });
       return true;
-    } catch (error) {
-      this.categorizeAndLogError(error, relativePath);
+    } catch (error2) {
+      this.categorizeAndLogError(error2, relativePath);
       return false;
     }
   }
@@ -1098,9 +1118,9 @@ var AutoRouteLoader = class {
       }
     }
   }
-  categorizeAndLogError(error, relativePath) {
-    const message = error.message;
-    const stack = error.stack;
+  categorizeAndLogError(error2, relativePath) {
+    const message = error2.message;
+    const stack = error2.stack;
     if (message.includes("Cannot find module") || message.includes("MODULE_NOT_FOUND")) {
       routeLogger2.error("Missing dependency", {
         file: relativePath,
@@ -1157,15 +1177,16 @@ async function loadRoutes(app, options) {
       routeLogger2.info("Loading function routes", { count: functionRoutes.length });
       for (const func of functionRoutes) {
         try {
-          await loader.loadExternalRoutes(app, func.routesDir, func.packageName);
+          await loader.loadExternalRoutes(app, func.routesDir, func.packageName, func.prefix);
           routeLogger2.info("Function routes loaded", {
             package: func.packageName,
-            routesDir: func.routesDir
+            routesDir: func.routesDir,
+            prefix: func.prefix || "/"
           });
-        } catch (error) {
+        } catch (error2) {
           routeLogger2.error("Failed to load function routes", {
             package: func.packageName,
-            error: error instanceof Error ? error.message : "Unknown error"
+            error: error2 instanceof Error ? error2.message : "Unknown error"
           });
         }
       }
@@ -1174,14 +1195,14 @@ async function loadRoutes(app, options) {
   return stats;
 }
 
-// src/errors/database-errors.ts
-var DatabaseError = class extends Error {
+// src/errors/http-errors.ts
+var HttpError = class extends Error {
   statusCode;
   details;
   timestamp;
-  constructor(message, statusCode = 500, details) {
+  constructor(message, statusCode, details) {
     super(message);
-    this.name = "DatabaseError";
+    this.name = "HttpError";
     this.statusCode = statusCode;
     this.details = details;
     this.timestamp = /* @__PURE__ */ new Date();
@@ -1200,13 +1221,7 @@ var DatabaseError = class extends Error {
     };
   }
 };
-var QueryError = class extends DatabaseError {
-  constructor(message, statusCode = 500, details) {
-    super(message, statusCode, details);
-    this.name = "QueryError";
-  }
-};
-var ValidationError = class extends QueryError {
+var ValidationError = class extends HttpError {
   constructor(message, details) {
     super(message, 400, details);
     this.name = "ValidationError";
@@ -1290,10 +1305,56 @@ function bind(contract, handler) {
     return handler(routeContext);
   };
 }
+
+// src/middleware/error-handler.ts
+init_logger2();
+var errorLogger = logger.child("error-handler");
+function ErrorHandler(options = {}) {
+  const {
+    includeStack = process.env.NODE_ENV !== "production",
+    enableLogging = true
+  } = options;
+  return (err, c) => {
+    const errorWithCode = err;
+    const statusCode = errorWithCode.statusCode || 500;
+    const errorType = err.name || "Error";
+    if (enableLogging) {
+      const logLevel = statusCode >= 500 ? "error" : "warn";
+      errorLogger[logLevel]("Error occurred", {
+        type: errorType,
+        message: err.message,
+        statusCode,
+        path: c.req.path,
+        method: c.req.method
+      });
+    }
+    const response = {
+      success: false,
+      error: {
+        message: err.message || "Internal Server Error",
+        type: errorType,
+        statusCode
+      }
+    };
+    if (errorWithCode.details) {
+      response.error.details = errorWithCode.details;
+    }
+    if (includeStack) {
+      response.error.stack = err.stack;
+    }
+    return c.json(response, statusCode);
+  };
+}
+
+// src/middleware/request-logger.ts
+init_logger2();
+
+// src/route/create-app.ts
 function createApp() {
   const hono = new Hono();
   const app = hono;
   app._contractMetas = /* @__PURE__ */ new Map();
+  app.onError(ErrorHandler());
   const methodMap = /* @__PURE__ */ new Map([
     ["get", (path, handlers) => hono.get(path, ...handlers)],
     ["post", (path, handlers) => hono.post(path, ...handlers)],
@@ -1317,12 +1378,90 @@ function createApp() {
   };
   return app;
 }
+function ApiSuccessSchema(dataSchema) {
+  return Type.Object({
+    success: Type.Literal(true),
+    data: dataSchema,
+    meta: Type.Optional(Type.Object({
+      timestamp: Type.Optional(Type.String()),
+      requestId: Type.Optional(Type.String()),
+      pagination: Type.Optional(Type.Object({
+        page: Type.Number(),
+        limit: Type.Number(),
+        total: Type.Number(),
+        totalPages: Type.Number()
+      }))
+    }))
+  });
+}
+function ApiErrorSchema() {
+  return Type.Object({
+    success: Type.Literal(false),
+    error: Type.Object({
+      message: Type.String(),
+      type: Type.String(),
+      statusCode: Type.Number(),
+      stack: Type.Optional(Type.String()),
+      details: Type.Optional(Type.Any())
+    })
+  });
+}
+function ApiResponseSchema(dataSchema) {
+  return Type.Union([
+    ApiSuccessSchema(dataSchema),
+    ApiErrorSchema()
+  ]);
+}
+function success(c, data, meta, status = 200) {
+  const response = {
+    success: true,
+    data
+  };
+  if (meta) {
+    response.meta = meta;
+  }
+  return c.json(response, status);
+}
+function error(c, message, statusCode = 400, details) {
+  const response = {
+    success: false,
+    error: {
+      message,
+      type: getErrorType(statusCode),
+      statusCode
+    }
+  };
+  if (details) {
+    response.error.details = details;
+  }
+  return c.json(response, statusCode);
+}
+function paginated(c, data, page, limit, total) {
+  return success(c, data, {
+    pagination: {
+      page,
+      limit,
+      total,
+      totalPages: Math.ceil(total / limit)
+    }
+  });
+}
+function getErrorType(statusCode) {
+  if (statusCode >= 500) return "InternalServerError";
+  if (statusCode === 404) return "NotFoundError";
+  if (statusCode === 401) return "UnauthorizedError";
+  if (statusCode === 403) return "ForbiddenError";
+  if (statusCode === 400) return "ValidationError";
+  if (statusCode === 409) return "ConflictError";
+  if (statusCode === 422) return "UnprocessableEntityError";
+  return "ClientError";
+}
 
 // src/route/types.ts
 function isHttpMethod(value) {
   return typeof value === "string" && ["GET", "POST", "PUT", "PATCH", "DELETE"].includes(value);
 }
 
-export { AutoRouteLoader, bind, createApp, isHttpMethod, loadRoutes };
+export { ApiErrorSchema, ApiResponseSchema, ApiSuccessSchema, AutoRouteLoader, bind, createApp, error, isHttpMethod, loadRoutes, paginated, success };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map