@spfn/core 0.2.0-beta.1 → 0.2.0-beta.10

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 {
@@ -162,14 +162,46 @@ var RouteBuilder = class _RouteBuilder {
   /**
    * Define handler function
    *
+   * Response type is automatically inferred from the return value.
+   * Use helper methods like `c.created()`, `c.paginated()` for proper type inference.
+   *
    * @example
    * ```ts
+   * // Direct return - type inferred from data
    * route.get('/users/:id')
    *   .input({ params: Type.Object({ id: Type.String() }) })
    *   .handler(async (c) => {
    *     const { params } = await c.data();
-   *     const user = await getUser(params.id);
-   *     return user; // Type inferred!
+   *     return await getUser(params.id); // Type: User
+   *   })
+   *
+   * // Using c.created() - returns data with 201 status, type preserved
+   * route.post('/users')
+   *   .input({ body: Type.Object({ name: Type.String() }) })
+   *   .handler(async (c) => {
+   *     const { body } = await c.data();
+   *     return c.created(await createUser(body)); // Type: User
+   *   })
+   *
+   * // Using c.paginated() - returns PaginatedResult<T>
+   * route.get('/users')
+   *   .handler(async (c) => {
+   *     const users = await getUsers();
+   *     return c.paginated(users, 1, 20, 100); // Type: PaginatedResult<User>
+   *   })
+   *
+   * // Using c.noContent() - returns void
+   * route.delete('/users/:id')
+   *   .handler(async (c) => {
+   *     await deleteUser(params.id);
+   *     return c.noContent(); // Type: void
+   *   })
+   *
+   * // Using c.json() - returns Response (type inference lost)
+   * // Use only when you need custom status codes not covered by helpers
+   * route.get('/custom')
+   *   .handler(async (c) => {
+   *     return c.json({ data }, 418); // Type: Response
    *   })
    * ```
    */
@@ -228,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 {};
@@ -246,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 = {};
@@ -293,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) {
@@ -304,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
@@ -322,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;
@@ -333,15 +581,22 @@ function registerRoute(app, name, routeDef, namedMiddlewares) {
       method,
       path
     });
-    return;
+    return null;
   }
   const wrappedHandler = async (c) => {
-    const context = await createRouteBuilderContext(c, input || {});
+    const { context, responseMeta } = await createRouteBuilderContext(c, input || {});
     const result = await handler(context);
     if (result instanceof Response) {
       return result;
     }
-    return c.json(result);
+    if (responseMeta.isEmpty) {
+      return c.body(null, responseMeta.status);
+    }
+    const hasCustomHeaders = Object.keys(responseMeta.headers).length > 0;
+    if (hasCustomHeaders) {
+      return c.json(result, responseMeta.status, responseMeta.headers);
+    }
+    return c.json(result, responseMeta.status);
   };
   const allMiddlewares = [];
   const registeredNames = /* @__PURE__ */ new Set();
@@ -387,6 +642,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");
@@ -394,42 +650,58 @@ 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");
+    }
   }
-  return {
-    data: async () => ({
-      params,
-      query,
-      body,
-      headers,
-      cookies
-    }),
+  let cachedData = null;
+  const responseMeta = {
+    status: 200,
+    headers: {},
+    isEmpty: false
+  };
+  const context = {
+    data: async () => {
+      if (!cachedData) {
+        cachedData = { params, query, body, formData, headers, cookies };
+      }
+      return cachedData;
+    },
     json: (data, status, resHeaders) => {
       return c.json(data, status, resHeaders);
     },
     created: (data, location) => {
-      const resHeaders = {};
+      responseMeta.status = 201;
       if (location) {
-        resHeaders["Location"] = location;
+        responseMeta.headers["Location"] = location;
       }
-      return c.json(data, 201, resHeaders);
+      return data;
     },
     accepted: (data) => {
+      responseMeta.status = 202;
       if (data === void 0) {
-        return c.body(null, 202);
+        responseMeta.isEmpty = true;
+        return void 0;
       }
-      return c.json(data, 202);
+      return data;
     },
     noContent: () => {
-      return c.body(null, 204);
+      responseMeta.status = 204;
+      responseMeta.isEmpty = true;
     },
     notModified: () => {
-      return c.body(null, 304);
+      responseMeta.status = 304;
+      responseMeta.isEmpty = true;
     },
     paginated: (data, page, limit, total) => {
-      return c.json({
+      return {
         items: data,
         pagination: {
           page,
@@ -437,10 +709,14 @@ async function createRouteBuilderContext(c, input) {
           total,
           totalPages: Math.ceil(total / limit)
         }
-      }, 200);
+      };
+    },
+    redirect: (url, status) => {
+      return c.redirect(url, status);
     },
     raw: c
   };
+  return { context, responseMeta };
 }
 
 // src/route/define-middleware.ts
@@ -499,6 +775,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, RouteBuilder, 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