@spfn/core 0.2.0-beta.3 → 0.2.0-beta.30

package/dist/route/index.js

@@ -1,7 +1,7 @@
 import { logger } from '@spfn/core/logger';
+import { FormatRegistry, Type, Kind } from '@sinclair/typebox';
 import { Value } from '@sinclair/typebox/value';
 import { ValidationError } from '@spfn/core/errors';
-import { Type } from '@sinclair/typebox';
 
 // src/route/route-builder.ts
 var RouteBuilder = class _RouteBuilder {
@@ -260,6 +260,108 @@ function createRouterInstance(routes, packageRouters = [], globalMiddlewares = [
 function defineRouter(routes) {
   return createRouterInstance(routes);
 }
+function FileSchema(options) {
+  return Type.Unsafe({
+    [Kind]: "File",
+    type: "object",
+    fileOptions: options
+  });
+}
+function FileArraySchema(options) {
+  return Type.Unsafe({
+    [Kind]: "FileArray",
+    type: "array",
+    items: { [Kind]: "File", type: "object" },
+    fileOptions: options
+  });
+}
+function OptionalFileSchema(options) {
+  return Type.Optional(FileSchema(options));
+}
+function isFileSchema(schema) {
+  const kind = schema[Symbol.for("TypeBox.Kind")];
+  return kind === "File";
+}
+function isFileArraySchema(schema) {
+  const kind = schema[Symbol.for("TypeBox.Kind")];
+  return kind === "FileArray";
+}
+function getFileOptions(schema) {
+  return schema.fileOptions;
+}
+function formatFileSize(bytes) {
+  if (bytes >= 1024 * 1024 * 1024) {
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`;
+  }
+  if (bytes >= 1024 * 1024) {
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+  }
+  if (bytes >= 1024) {
+    return `${(bytes / 1024).toFixed(1)}KB`;
+  }
+  return `${bytes}B`;
+}
+
+// src/route/validation.ts
+FormatRegistry.Set(
+  "email",
+  (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)
+);
+FormatRegistry.Set(
+  "uri",
+  (value) => /^https?:\/\/.+/.test(value)
+);
+FormatRegistry.Set(
+  "uuid",
+  (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value)
+);
+FormatRegistry.Set(
+  "date",
+  (value) => /^\d{4}-\d{2}-\d{2}$/.test(value)
+);
+FormatRegistry.Set(
+  "date-time",
+  (value) => !isNaN(Date.parse(value))
+);
+function isFile(value) {
+  return value instanceof File || typeof value === "object" && value !== null && "name" in value && "size" in value && "type" in value && typeof value.arrayBuffer === "function";
+}
+function isFileSchemaDef(schema) {
+  const kind = schema[Symbol.for("TypeBox.Kind")];
+  return kind === "File";
+}
+function isFileArraySchemaDef(schema) {
+  const kind = schema[Symbol.for("TypeBox.Kind")];
+  return kind === "FileArray";
+}
+function getSchemaFileOptions(schema) {
+  return schema.fileOptions;
+}
+function validateSingleFile(file, fieldPath, options, errors) {
+  if (!options) return;
+  const { maxSize, minSize, allowedTypes } = options;
+  if (maxSize !== void 0 && file.size > maxSize) {
+    errors.push({
+      path: fieldPath,
+      message: `File size ${formatFileSize(file.size)} exceeds maximum ${formatFileSize(maxSize)}`,
+      value: file.size
+    });
+  }
+  if (minSize !== void 0 && file.size < minSize) {
+    errors.push({
+      path: fieldPath,
+      message: `File size ${formatFileSize(file.size)} is below minimum ${formatFileSize(minSize)}`,
+      value: file.size
+    });
+  }
+  if (allowedTypes && allowedTypes.length > 0 && !allowedTypes.includes(file.type)) {
+    errors.push({
+      path: fieldPath,
+      message: `File type "${file.type}" is not allowed. Allowed: ${allowedTypes.join(", ")}`,
+      value: file.type
+    });
+  }
+}
 function validateField(schema, rawValue, fieldName) {
   if (!schema) {
     return {};
@@ -278,6 +380,87 @@ function validateField(schema, rawValue, fieldName) {
   }
   return converted;
 }
+function validateFormData(schema, rawValue, fieldName) {
+  if (!schema) {
+    return {};
+  }
+  const schemaProps = schema.properties;
+  if (!schemaProps) {
+    return rawValue;
+  }
+  const result = {};
+  const nonFileData = {};
+  const nonFileSchema = {};
+  const fileErrors = [];
+  for (const [key, value] of Object.entries(rawValue)) {
+    const propSchema = schemaProps[key];
+    if (propSchema && isFileSchemaDef(propSchema)) {
+      result[key] = value;
+      if (isFile(value)) {
+        const fileOptions = getSchemaFileOptions(propSchema);
+        validateSingleFile(value, `/${key}`, fileOptions, fileErrors);
+      }
+    } else if (propSchema && isFileArraySchemaDef(propSchema)) {
+      result[key] = value;
+      const fileOptions = getSchemaFileOptions(propSchema);
+      const files = Array.isArray(value) ? value : [value];
+      const fileArray = files.filter(isFile);
+      if (fileOptions?.maxFiles !== void 0 && fileArray.length > fileOptions.maxFiles) {
+        fileErrors.push({
+          path: `/${key}`,
+          message: `Too many files. Maximum: ${fileOptions.maxFiles}, received: ${fileArray.length}`,
+          value: fileArray.length
+        });
+      }
+      if (fileOptions?.minFiles !== void 0 && fileArray.length < fileOptions.minFiles) {
+        fileErrors.push({
+          path: `/${key}`,
+          message: `Too few files. Minimum: ${fileOptions.minFiles}, received: ${fileArray.length}`,
+          value: fileArray.length
+        });
+      }
+      fileArray.forEach((file, index) => {
+        validateSingleFile(file, `/${key}/${index}`, fileOptions, fileErrors);
+      });
+    } else if (isFile(value) || Array.isArray(value) && value.some(isFile)) {
+      result[key] = value;
+    } else {
+      nonFileData[key] = value;
+      if (propSchema) {
+        nonFileSchema[key] = propSchema;
+      }
+    }
+  }
+  if (fileErrors.length > 0) {
+    throw new ValidationError({
+      message: `Invalid ${fieldName}`,
+      fields: fileErrors
+    });
+  }
+  if (Object.keys(nonFileSchema).length > 0) {
+    const tempSchema = {
+      ...schema,
+      properties: nonFileSchema,
+      required: schema.required?.filter((r) => r in nonFileSchema) ?? []
+    };
+    const converted = Value.Convert(tempSchema, nonFileData);
+    const errors = [...Value.Errors(tempSchema, converted)];
+    if (errors.length > 0) {
+      throw new ValidationError({
+        message: `Invalid ${fieldName}`,
+        fields: errors.map((e) => ({
+          path: e.path,
+          message: e.message,
+          value: e.value
+        }))
+      });
+    }
+    Object.assign(result, converted);
+  } else {
+    Object.assign(result, nonFileData);
+  }
+  return result;
+}
 function extractQueryParams(c) {
   const url = new URL(c.req.url);
   const queryObj = {};
@@ -325,6 +508,34 @@ async function parseJsonBody(c) {
     });
   }
 }
+async function parseFormData(c) {
+  try {
+    const formData = await c.req.formData();
+    const result = {};
+    formData.forEach((value, key) => {
+      const existing = result[key];
+      if (existing !== void 0) {
+        if (Array.isArray(existing)) {
+          existing.push(value);
+        } else {
+          result[key] = [existing, value];
+        }
+      } else {
+        result[key] = value;
+      }
+    });
+    return result;
+  } catch (error) {
+    throw new ValidationError({
+      message: "Invalid form data",
+      fields: [{
+        path: "/",
+        message: "Failed to parse form data",
+        value: error instanceof Error ? error.message : "Unknown error"
+      }]
+    });
+  }
+}
 
 // src/route/register-routes.ts
 function isRouter(value) {
@@ -336,16 +547,20 @@ function isRouteDef(value) {
 function isNamedMiddleware(value) {
   return value !== null && typeof value === "object" && "name" in value && "handler" in value && "_name" in value;
 }
-function registerRoutes(app, router, namedMiddlewares) {
+function registerRoutes(app, router, namedMiddlewares, collectedRoutes) {
+  const routes = collectedRoutes ?? [];
   const allNamedMiddlewares = [
     ...namedMiddlewares ?? [],
     ...router._globalMiddlewares.map((mw) => ({ name: mw.name, handler: mw.handler }))
   ];
   for (const [name, routeOrRouter] of Object.entries(router.routes)) {
     if (isRouter(routeOrRouter)) {
-      registerRoutes(app, routeOrRouter, allNamedMiddlewares);
+      registerRoutes(app, routeOrRouter, allNamedMiddlewares, routes);
     } else if (isRouteDef(routeOrRouter)) {
-      registerRoute(app, name, routeOrRouter, allNamedMiddlewares);
+      const registered = registerRoute(app, name, routeOrRouter, allNamedMiddlewares);
+      if (registered) {
+        routes.push(registered);
+      }
     } else {
       logger.warn(`Unknown route type for "${name}" - skipping`, {
         type: typeof routeOrRouter
@@ -354,9 +569,10 @@ function registerRoutes(app, router, namedMiddlewares) {
   }
   if (router._packageRouters && router._packageRouters.length > 0) {
     for (const pkgRouter of router._packageRouters) {
-      registerRoutes(app, pkgRouter, allNamedMiddlewares);
+      registerRoutes(app, pkgRouter, allNamedMiddlewares, routes);
     }
   }
+  return routes;
 }
 function registerRoute(app, name, routeDef, namedMiddlewares) {
   const { method, path, input, middlewares = [], skipMiddlewares, handler } = routeDef;
@@ -365,7 +581,7 @@ function registerRoute(app, name, routeDef, namedMiddlewares) {
       method,
       path
     });
-    return;
+    return null;
   }
   const wrappedHandler = async (c) => {
     const { context, responseMeta } = await createRouteBuilderContext(c, input || {});
@@ -386,18 +602,28 @@ function registerRoute(app, name, routeDef, namedMiddlewares) {
   const registeredNames = /* @__PURE__ */ new Set();
   const registeredHandlers = /* @__PURE__ */ new Set();
   const skipAll = skipMiddlewares === "*";
+  const autoSkips = /* @__PURE__ */ new Set();
+  for (const mw of middlewares) {
+    if (isNamedMiddleware(mw) && mw.skips) {
+      for (const skipName of mw.skips) {
+        autoSkips.add(skipName);
+      }
+    }
+  }
   if (namedMiddlewares && namedMiddlewares.length > 0) {
     if (skipAll) {
       logger.debug(`\u23ED\uFE0F  Skipping all middlewares (*) for route: ${method} ${path}`, { name });
     } else {
       const skipSet = new Set(Array.isArray(skipMiddlewares) ? skipMiddlewares : []);
       for (const middleware of namedMiddlewares) {
-        if (!skipSet.has(middleware.name)) {
+        if (skipSet.has(middleware.name)) {
+          logger.debug(`\u23ED\uFE0F  Skipping middleware '${middleware.name}' for route: ${method} ${path}`, { name });
+        } else if (autoSkips.has(middleware.name)) {
+          logger.debug(`\u23ED\uFE0F  Auto-skipping middleware '${middleware.name}' for route: ${method} ${path}`, { name });
+        } else {
           allMiddlewares.push(middleware.handler);
           registeredNames.add(middleware.name);
           registeredHandlers.add(middleware.handler);
-        } else {
-          logger.debug(`\u23ED\uFE0F  Skipping middleware '${middleware.name}' for route: ${method} ${path}`, { name });
         }
       }
     }
@@ -426,6 +652,7 @@ function registerRoute(app, name, routeDef, namedMiddlewares) {
     app[methodLower](path, wrappedHandler);
   }
   logger.debug(`Registered route: ${method} ${path}`, { name });
+  return { method, path, name };
 }
 async function createRouteBuilderContext(c, input) {
   const params = validateField(input.params, c.req.param(), "path parameters");
@@ -433,9 +660,16 @@ async function createRouteBuilderContext(c, input) {
   const headers = validateField(input.headers, extractHeaders(c), "headers");
   const cookies = validateField(input.cookies, extractCookies(c), "cookies");
   let body = {};
-  if (input.body) {
-    const rawBody = await parseJsonBody(c);
-    body = validateField(input.body, rawBody, "request body");
+  let formData = {};
+  if (input.body || input.formData) {
+    const contentType = c.req.header("content-type") || "";
+    if (contentType.includes("multipart/form-data") && input.formData) {
+      const rawFormData = await parseFormData(c);
+      formData = validateFormData(input.formData, rawFormData, "form data");
+    } else if (input.body) {
+      const rawBody = await parseJsonBody(c);
+      body = validateField(input.body, rawBody, "request body");
+    }
   }
   let cachedData = null;
   const responseMeta = {
@@ -446,7 +680,7 @@ async function createRouteBuilderContext(c, input) {
   const context = {
     data: async () => {
       if (!cachedData) {
-        cachedData = { params, query, body, headers, cookies };
+        cachedData = { params, query, body, formData, headers, cookies };
       }
       return cachedData;
     },
@@ -496,14 +730,16 @@ async function createRouteBuilderContext(c, input) {
 }
 
 // src/route/define-middleware.ts
-function defineMiddleware(name, handlerOrFactory) {
+function defineMiddleware(name, handlerOrFactory, options) {
+  const skips = options?.skips;
   if (typeof handlerOrFactory === "function") {
     const paramCount = handlerOrFactory.length;
     if (paramCount === 2) {
       return {
         name,
         handler: handlerOrFactory,
-        _name: name
+        _name: name,
+        ...skips && { skips }
       };
     } else {
       const factory = handlerOrFactory;
@@ -520,13 +756,22 @@ function defineMiddleware(name, handlerOrFactory) {
         enumerable: false,
         configurable: true
       });
+      if (skips) {
+        Object.defineProperty(wrapper, "skips", {
+          value: skips,
+          writable: false,
+          enumerable: false,
+          configurable: true
+        });
+      }
       return wrapper;
     }
   }
   return {
     name,
     handler: handlerOrFactory,
-    _name: name
+    _name: name,
+    ...skips && { skips }
   };
 }
 function defineMiddlewareFactory(name, factory) {
@@ -551,6 +796,6 @@ function isHttpMethod(value) {
 var Nullable = (schema) => Type.Union([schema, Type.Null()]);
 var OptionalNullable = (schema) => Type.Optional(Type.Union([schema, Type.Null()]));
 
-export { Nullable, OptionalNullable, defineMiddleware, defineMiddlewareFactory, defineRouter, isHttpMethod, registerRoutes, route };
+export { FileArraySchema, FileSchema, Nullable, OptionalFileSchema, OptionalNullable, defineMiddleware, defineMiddlewareFactory, defineRouter, formatFileSize, getFileOptions, isFileArraySchema, isFileSchema, isHttpMethod, registerRoutes, route };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map