@gravito/mass 3.0.2 → 3.0.3

package/README.md

@@ -4,14 +4,31 @@
 
 `@gravito/mass` provides the "weight" of data integrity to your Gravito applications. Built on top of **TypeBox**, it offers ultra-fast runtime validation with full TypeScript type inference, designed to work seamlessly with the **Photon** HTTP engine.
 
-## 🌟 Key Features
-
-- **🚀 Performance-First**: Leverages TypeBox's build-time validator generation for near-zero runtime overhead.
-- **🛡️ Full Type Safety**: Automatic TypeScript type inference—no need to manually maintain interfaces and schemas separately.
-- **🔌 Photon Integration**: Native middleware for `@gravito/photon` to validate JSON, query, params, and form data.
-- **🛠️ Schema Utilities**: Advanced helpers like `partial()` for easy creation of PATCH schemas.
-- **🪝 Extensible Hooks**: Intercept validation results to provide custom error responses or logging.
-- **📦 Galaxy-Ready**: Follows Gravito's modular philosophy for lean, efficient dependency management.
+## ✨ Key Features
+
+- 🚀 **Performance-First**: Built on TypeBox, it generates ultra-fast validators that outperform standard libraries like Zod.
+- 🌌 **Galaxy-Ready**: The "Data Quality Layer" ensuring integrity across all Gravito Satellites and Orbits.
+- 🛡️ **Full Type Safety**: Zero-config type inference—your schemas are your TypeScript types.
+- 📡 **Beam Integration**: Share schemas between backend and frontend for end-to-end type-safe RPC.
+- 🔌 **Photon Integration**: Native middleware for `@gravito/photon` to validate JSON, query, params, and form data.
+- 📦 **Binary (CBOR) Support**: Optimized validation for binary protocols in high-performance microservices.
+
+## 🌌 Role in Galaxy Architecture
+
+In the **Gravito Galaxy Architecture**, Mass serves as the **Data Quality Layer (Immune System)**.
+
+- **Sensing Filter**: Acts as the first line of defense in the `Photon` Sensing Layer, filtering out malformed or malicious data before it reaches your business logic.
+- **Contract Definition**: Provides the shared language (Schemas) used by `Beam` to ensure that Satellites and clients communicate with perfect understanding.
+- **Type Propagation**: Injects strong types from the edge of the network into the deepest parts of your IoC container.
+
+```mermaid
+graph LR
+    Request([Request]) --> Mass{Mass Filter}
+    Mass -- "Valid" --> Satellite[Satellite Business Logic]
+    Mass -- "Invalid" --> Error[400 Bad Request]
+    Satellite -- "Beam RPC" --> Client([Typed Client])
+    Mass -.->|Schema| Client
+```
 
 ## 📦 Installation
 
@@ -129,6 +146,15 @@ The central builder for defining data structures. Re-exports all TypeBox builder
 ### `partial(schema)`
 Recursively makes all properties in an object schema optional.
 
+## 📚 Documentation
+
+Detailed guides and references for the Galaxy Architecture:
+
+- [🏗️ **Architecture Overview**](./README.md) — Data integrity and schema validation.
+- [📐 **Schema Design**](./doc/SCHEMA_DESIGN.md) — **NEW**: Best practices for domain-specific schemas and composition.
+- [🛡️ **Validation Strategy**](./doc/VALIDATION_STRATEGY.md) — **NEW**: Multi-source validation, hooks, and performance tuning.
+- [🔌 **Photon Integration**](#-photon-integration) — Native middleware for request validation.
+
 ## 🤝 Contributing
 
 We welcome contributions! Please see our [Contributing Guide](../../CONTRIBUTING.md) for details.

package/dist/coercion.d.ts

@@ -1,5 +1,5 @@
-import type { Context, Env, MiddlewareHandler } from '@gravito/photon';
-import type { Static, TBoolean, TInteger, TNumber, TSchema } from '@sinclair/typebox';
+import type { GravitoContext, GravitoMiddleware } from '@gravito/core';
+import type { TBoolean, TInteger, TNumber, TSchema } from '@sinclair/typebox';
 /**
  * String to Number Coercion Helper.
  *
@@ -164,14 +164,11 @@ export declare function coerceData<T extends TSchema>(data: unknown, schema: T):
  * are string-based.
  *
  * @template T - TypeBox schema type
- * @template S - Validation source type
- * @template E - Photon environment type
- * @template P - Route path type
  *
  * @param source - Validation source (recommend using 'query' or 'param')
  * @param schema - TypeBox schema definition
  * @param hook - Optional validation result hook
- * @returns Photon middleware handler
+ * @returns Gravito middleware handler
  *
  * @example Query Parameter Coercion
  * ```typescript
@@ -222,12 +219,4 @@ export declare function coerceData<T extends TSchema>(data: unknown, schema: T):
  * )
  * ```
  */
-export declare function validateWithCoercion<T extends TSchema, S extends 'json' | 'query' | 'param' | 'form', E extends Env = Env, P extends string = string>(source: S, schema: T, hook?: (result: unknown, c: Context<E>) => Response | Promise<Response> | undefined): MiddlewareHandler<E, P, {
-    in: {
-        [K in S]: Static<T>;
-    };
-    out: {
-        [K in S]: Static<T>;
-    };
-}>;
-//# sourceMappingURL=coercion.d.ts.map
+export declare function validateWithCoercion<T extends TSchema>(source: 'json' | 'query' | 'param' | 'form', schema: T, hook?: (result: unknown, c: GravitoContext) => Response | Promise<Response> | undefined): GravitoMiddleware;

package/dist/errors.d.ts

@@ -166,4 +166,3 @@ export declare function formatErrors(errors: Array<{
 }>): {
     fields: Record<string, string[]>;
 };
-//# sourceMappingURL=errors.d.ts.map

package/dist/formats.d.ts

@@ -95,4 +95,3 @@ export declare function getFormatValidator(name: string): ((value: string) => bo
  * ```
  */
 export declare function unregisterFormat(name: string): void;
-//# sourceMappingURL=formats.d.ts.map

package/dist/index.d.ts

@@ -68,7 +68,6 @@
  *
  * @packageDocumentation
  */
-export { tbValidator as validator } from '@hono/typebox-validator';
 export type { Static, TSchema } from '@sinclair/typebox';
 export * as Schema from '@sinclair/typebox';
 export { CoercibleBoolean, CoercibleInteger, CoercibleNumber, coerceBoolean, coerceData, coerceDate, coerceInteger, coerceNumber, validateWithCoercion, } from './coercion';
@@ -78,4 +77,3 @@ export { type AstralResource, createAstralResource, createCrudResources, type Op
 export type { ValidationError, ValidationHook, ValidationResult, } from './types';
 export { partial } from './utils';
 export { type ValidationSource, validate } from './validator';
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,511 +1,5 @@
 // @bun
-// src/index.ts
-import { tbValidator as tbValidator3 } from "@hono/typebox-validator";
-import * as Schema from "@sinclair/typebox";
-
-// src/coercion.ts
-import { tbValidator } from "@hono/typebox-validator";
-import { Type } from "@sinclair/typebox";
-function coerceNumber(value) {
-  const num = Number(value);
-  return Number.isNaN(num) ? NaN : num;
-}
-function coerceInteger(value) {
-  const num = Number.parseInt(value, 10);
-  return Number.isNaN(num) ? NaN : num;
-}
-function coerceBoolean(value) {
-  const lowerValue = value.toLowerCase().trim();
-  return ["true", "1", "yes", "on"].includes(lowerValue);
-}
-function coerceDate(value) {
-  return new Date(value);
-}
-function CoercibleNumber(options) {
-  return Type.Number({
-    ...options,
-    [Symbol.for("TypeBox.Transform")]: coerceNumber
-  });
-}
-function CoercibleInteger(options) {
-  return Type.Integer({
-    ...options,
-    [Symbol.for("TypeBox.Transform")]: coerceInteger
-  });
-}
-function CoercibleBoolean(options) {
-  return Type.Boolean({
-    ...options,
-    [Symbol.for("TypeBox.Transform")]: coerceBoolean
-  });
-}
-function coerceData(data, schema) {
-  if (typeof data !== "object" || data === null) {
-    return data;
-  }
-  const dataObj = data;
-  const result = {};
-  if (schema.type !== "object" || !schema.properties) {
-    return data;
-  }
-  for (const [key, value] of Object.entries(dataObj)) {
-    const propertySchema = schema.properties[key];
-    if (!propertySchema) {
-      result[key] = value;
-      continue;
-    }
-    if (typeof value === "string") {
-      if (propertySchema.type === "number" || propertySchema.type === "integer") {
-        result[key] = propertySchema.type === "integer" ? coerceInteger(value) : coerceNumber(value);
-      } else if (propertySchema.type === "boolean") {
-        result[key] = coerceBoolean(value);
-      } else {
-        result[key] = value;
-      }
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-function validateWithCoercion(source, schema, hook) {
-  return async (c, next) => {
-    let data;
-    switch (source) {
-      case "json":
-        data = await c.req.json();
-        break;
-      case "query":
-        data = c.req.query();
-        break;
-      case "param":
-        data = c.req.param();
-        break;
-      case "form":
-        data = await c.req.parseBody();
-        break;
-      default:
-        data = {};
-    }
-    if (source === "query" || source === "param") {
-      data = coerceData(data, schema);
-    }
-    const validator = tbValidator(source, schema, hook);
-    const originalQueryMethod = c.req.query;
-    const originalParamMethod = c.req.param;
-    if (source === "query") {
-      c.req.query = () => data;
-    } else if (source === "param") {
-      c.req.param = () => data;
-    }
-    await validator(c, next);
-    if (source === "query") {
-      c.req.query = originalQueryMethod;
-    } else if (source === "param") {
-      c.req.param = originalParamMethod;
-    }
-  };
-}
-// src/errors.ts
-var ERROR_MESSAGES_ZH_TW = {
-  REQUIRED: "\u6B64\u6B04\u4F4D\u70BA\u5FC5\u586B",
-  INVALID_TYPE: "\u8CC7\u6599\u578B\u5225\u4E0D\u6B63\u78BA",
-  INVALID_EMAIL: "\u96FB\u5B50\u90F5\u4EF6\u683C\u5F0F\u4E0D\u6B63\u78BA",
-  INVALID_URL: "\u7DB2\u5740\u683C\u5F0F\u4E0D\u6B63\u78BA",
-  INVALID_UUID: "UUID \u683C\u5F0F\u4E0D\u6B63\u78BA",
-  INVALID_DATE: "\u65E5\u671F\u683C\u5F0F\u4E0D\u6B63\u78BA",
-  TOO_SHORT: "\u9577\u5EA6\u904E\u77ED",
-  TOO_LONG: "\u9577\u5EA6\u904E\u9577",
-  TOO_SMALL: "\u6578\u503C\u904E\u5C0F",
-  TOO_LARGE: "\u6578\u503C\u904E\u5927",
-  INVALID_PATTERN: "\u683C\u5F0F\u4E0D\u7B26\u5408\u898F\u5247",
-  INVALID_FORMAT: "\u683C\u5F0F\u4E0D\u6B63\u78BA"
-};
-var ERROR_MESSAGES_EN = {
-  REQUIRED: "This field is required",
-  INVALID_TYPE: "Invalid data type",
-  INVALID_EMAIL: "Invalid email format",
-  INVALID_URL: "Invalid URL format",
-  INVALID_UUID: "Invalid UUID format",
-  INVALID_DATE: "Invalid date format",
-  TOO_SHORT: "Too short",
-  TOO_LONG: "Too long",
-  TOO_SMALL: "Value too small",
-  TOO_LARGE: "Value too large",
-  INVALID_PATTERN: "Does not match required pattern",
-  INVALID_FORMAT: "Invalid format"
-};
-
-class MassValidationError extends Error {
-  source;
-  errors;
-  constructor(source, errors) {
-    super(`Validation failed for ${source}`);
-    this.source = source;
-    this.errors = errors;
-    this.name = "MassValidationError";
-  }
-  toJSON() {
-    return {
-      error: "ValidationError",
-      source: this.source,
-      details: this.errors
-    };
-  }
-}
-function enhanceError(error, locale = "zh-TW") {
-  const messages = locale === "zh-TW" ? ERROR_MESSAGES_ZH_TW : ERROR_MESSAGES_EN;
-  const { path, message, schema, value } = error;
-  let enhancedMessage = message;
-  if (message.includes("required property")) {
-    enhancedMessage = messages.REQUIRED;
-  } else if (message.includes("email")) {
-    enhancedMessage = messages.INVALID_EMAIL;
-  } else if (message.includes("url")) {
-    enhancedMessage = messages.INVALID_URL;
-  } else if (message.includes("uuid")) {
-    enhancedMessage = messages.INVALID_UUID;
-  } else if (message.includes("date-time") || message.includes("date")) {
-    enhancedMessage = messages.INVALID_DATE;
-  } else if (message.includes("length greater or equal")) {
-    const minLength = schema.minLength;
-    enhancedMessage = locale === "zh-TW" ? `${messages.TOO_SHORT}\uFF08\u6700\u5C11 ${minLength} \u500B\u5B57\u5143\uFF09` : `${messages.TOO_SHORT} (minimum ${minLength} characters)`;
-  } else if (message.includes("length less or equal")) {
-    const maxLength = schema.maxLength;
-    enhancedMessage = locale === "zh-TW" ? `${messages.TOO_LONG}\uFF08\u6700\u591A ${maxLength} \u500B\u5B57\u5143\uFF09` : `${messages.TOO_LONG} (maximum ${maxLength} characters)`;
-  } else if (message.includes("greater or equal")) {
-    const minimum = schema.minimum;
-    enhancedMessage = locale === "zh-TW" ? `${messages.TOO_SMALL}\uFF08\u6700\u5C0F\u503C\uFF1A${minimum}\uFF09` : `${messages.TOO_SMALL} (minimum: ${minimum})`;
-  } else if (message.includes("less or equal")) {
-    const maximum = schema.maximum;
-    enhancedMessage = locale === "zh-TW" ? `${messages.TOO_LARGE}\uFF08\u6700\u5927\u503C\uFF1A${maximum}\uFF09` : `${messages.TOO_LARGE} (maximum: ${maximum})`;
-  } else if (message.includes("to match")) {
-    enhancedMessage = messages.INVALID_PATTERN;
-  } else if (message.includes("format")) {
-    enhancedMessage = messages.INVALID_FORMAT;
-  }
-  return {
-    path,
-    message: enhancedMessage,
-    expected: schema.type ? String(schema.type) : undefined,
-    received: typeof value
-  };
-}
-function createErrorFormatter(formatter) {
-  return (error) => {
-    const formatted = formatter(error);
-    return {
-      path: formatted.path,
-      message: formatted.message,
-      expected: formatted.expected,
-      received: formatted.received
-    };
-  };
-}
-function formatErrors(errors) {
-  const fields = {};
-  for (const err of errors) {
-    const fieldName = err.path.replace(/^\//, "").replace(/\//g, ".");
-    if (!fields[fieldName]) {
-      fields[fieldName] = [];
-    }
-    fields[fieldName].push(err.message);
-  }
-  return { fields };
-}
-// src/formats.ts
-import { FormatRegistry } from "@sinclair/typebox";
-var REGISTERED_FORMATS = [
-  "email",
-  "uri",
-  "uri-reference",
-  "uuid",
-  "date-time",
-  "date",
-  "time",
-  "ipv4",
-  "ipv6"
-];
-var EMAIL_REGEX = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
-var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-var URL_REGEX = /^https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_+.~#?&/=]*)$/;
-var URI_REFERENCE_REGEX = /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/\/)?[^\s]*$/i;
-var DATE_TIME_REGEX = /^\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}(?:\.\d{3})?(?:Z|[+-]\d{2}:\d{2})?$/;
-var DATE_REGEX = /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/;
-var TIME_REGEX = /^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)(?:\.\d{3})?$/;
-var IPV4_REGEX = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
-var IPV6_REGEX = /^(?:(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|(?:[0-9a-fA-F]{1,4}:){1,7}:|(?:[0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|(?:[0-9a-fA-F]{1,4}:){1,5}(?::[0-9a-fA-F]{1,4}){1,2}|(?:[0-9a-fA-F]{1,4}:){1,4}(?::[0-9a-fA-F]{1,4}){1,3}|(?:[0-9a-fA-F]{1,4}:){1,3}(?::[0-9a-fA-F]{1,4}){1,4}|(?:[0-9a-fA-F]{1,4}:){1,2}(?::[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:(?:(?::[0-9a-fA-F]{1,4}){1,6})|:(?:(?::[0-9a-fA-F]{1,4}){1,7}|:))$/;
-var FORMAT_VALIDATORS = {
-  email: (value) => EMAIL_REGEX.test(value),
-  uri: (value) => URL_REGEX.test(value),
-  "uri-reference": (value) => URI_REFERENCE_REGEX.test(value),
-  uuid: (value) => UUID_REGEX.test(value),
-  "date-time": (value) => DATE_TIME_REGEX.test(value),
-  date: (value) => DATE_REGEX.test(value),
-  time: (value) => TIME_REGEX.test(value),
-  ipv4: (value) => IPV4_REGEX.test(value),
-  ipv6: (value) => IPV6_REGEX.test(value)
-};
-function registerFormat(name, validator) {
-  FormatRegistry.Set(name, validator);
-}
-function registerAllFormats() {
-  for (const [name, validator] of Object.entries(FORMAT_VALIDATORS)) {
-    FormatRegistry.Set(name, validator);
-  }
-}
-function isFormatRegistered(name) {
-  return FormatRegistry.Has(name);
-}
-function getFormatValidator(name) {
-  return FormatRegistry.Has(name) ? FormatRegistry.Get(name) : undefined;
-}
-function unregisterFormat(name) {
-  FormatRegistry.Delete(name);
-}
-// src/openapi.ts
-import { Kind } from "@sinclair/typebox";
-function typeboxToOpenApi(schema) {
-  const result = {};
-  if (schema.description) {
-    result.description = schema.description;
-  }
-  if (schema.default !== undefined) {
-    result.default = schema.default;
-  }
-  if (schema.examples && Array.isArray(schema.examples) && schema.examples.length > 0) {
-    result.example = schema.examples[0];
-  }
-  switch (schema[Kind]) {
-    case "String": {
-      const stringSchema = schema;
-      result.type = "string";
-      if (stringSchema.format) {
-        result.format = stringSchema.format;
-      }
-      if (stringSchema.minLength !== undefined) {
-        result.minLength = stringSchema.minLength;
-      }
-      if (stringSchema.maxLength !== undefined) {
-        result.maxLength = stringSchema.maxLength;
-      }
-      if (stringSchema.pattern) {
-        result.pattern = stringSchema.pattern;
-      }
-      break;
-    }
-    case "Number":
-    case "Integer": {
-      const numberSchema = schema;
-      result.type = schema[Kind] === "Integer" ? "integer" : "number";
-      if (numberSchema.minimum !== undefined) {
-        result.minimum = numberSchema.minimum;
-      }
-      if (numberSchema.maximum !== undefined) {
-        result.maximum = numberSchema.maximum;
-      }
-      break;
-    }
-    case "Boolean": {
-      result.type = "boolean";
-      break;
-    }
-    case "Array": {
-      const arraySchema = schema;
-      result.type = "array";
-      if (arraySchema.items) {
-        result.items = typeboxToOpenApi(arraySchema.items);
-      }
-      if (arraySchema.minItems !== undefined) {
-        result.minItems = arraySchema.minItems;
-      }
-      if (arraySchema.maxItems !== undefined) {
-        result.maxItems = arraySchema.maxItems;
-      }
-      break;
-    }
-    case "Object": {
-      const objectSchema = schema;
-      result.type = "object";
-      if (objectSchema.properties) {
-        result.properties = {};
-        const required = [];
-        for (const [key, value] of Object.entries(objectSchema.properties)) {
-          const optionalSymbol = Symbol.for("TypeBox.Optional");
-          const isOptional = value[optionalSymbol] === "Optional";
-          if (isOptional) {
-            result.properties[key] = typeboxToOpenApi(value);
-          } else {
-            result.properties[key] = typeboxToOpenApi(value);
-            required.push(key);
-          }
-        }
-        if (required.length > 0) {
-          result.required = required;
-        }
-      }
-      if (objectSchema.additionalProperties !== undefined) {
-        if (typeof objectSchema.additionalProperties === "boolean") {
-          result.additionalProperties = objectSchema.additionalProperties;
-        } else {
-          result.additionalProperties = typeboxToOpenApi(objectSchema.additionalProperties);
-        }
-      }
-      break;
-    }
-    case "Union": {
-      if (schema.anyOf && Array.isArray(schema.anyOf)) {
-        result.anyOf = schema.anyOf.map((s) => typeboxToOpenApi(s));
-      }
-      break;
-    }
-    case "Intersect": {
-      if (schema.allOf && Array.isArray(schema.allOf)) {
-        result.allOf = schema.allOf.map((s) => typeboxToOpenApi(s));
-      }
-      break;
-    }
-    case "Literal": {
-      if (schema.const !== undefined) {
-        result.enum = [schema.const];
-        result.type = typeof schema.const;
-      }
-      break;
-    }
-    case "Enum": {
-      if (schema.anyOf && Array.isArray(schema.anyOf)) {
-        result.enum = schema.anyOf.map((s) => s.const);
-        if (result.enum.length > 0) {
-          result.type = typeof result.enum[0];
-        }
-      }
-      break;
-    }
-    case "Null": {
-      result.type = "null";
-      break;
-    }
-    case "Optional": {
-      if (schema[Kind] === "Optional" && schema.anyOf && Array.isArray(schema.anyOf)) {
-        const innerSchema = schema.anyOf[0];
-        return typeboxToOpenApi(innerSchema);
-      }
-      break;
-    }
-    default: {
-      if (schema.type) {
-        result.type = schema.type;
-      }
-    }
-  }
-  return result;
-}
-function createAstralResource(options) {
-  const {
-    path,
-    method,
-    summary,
-    description,
-    tags,
-    requestSchema,
-    requestDescription,
-    requestRequired = true,
-    responseSchema,
-    responseDescription = "Successful response",
-    responseStatusCode = 200
-  } = options;
-  const resource = {
-    path,
-    method: method.toUpperCase(),
-    responses: {
-      [responseStatusCode]: {
-        description: responseDescription,
-        content: {
-          "application/json": {
-            schema: typeboxToOpenApi(responseSchema)
-          }
-        }
-      }
-    }
-  };
-  if (summary) {
-    resource.summary = summary;
-  }
-  if (description) {
-    resource.description = description;
-  }
-  if (tags && tags.length > 0) {
-    resource.tags = tags;
-  }
-  if (requestSchema && ["POST", "PUT", "PATCH"].includes(method.toUpperCase())) {
-    resource.requestBody = {
-      description: requestDescription,
-      required: requestRequired,
-      content: {
-        "application/json": {
-          schema: typeboxToOpenApi(requestSchema)
-        }
-      }
-    };
-  }
-  return resource;
-}
-function createCrudResources(options) {
-  const { resourceName, basePath, tags = [resourceName], schemas } = options;
-  const capitalizedName = resourceName.charAt(0).toUpperCase() + resourceName.slice(1);
-  return {
-    list: createAstralResource({
-      path: basePath,
-      method: "GET",
-      summary: `Get ${capitalizedName} List`,
-      tags,
-      responseSchema: schemas.list || schemas.item
-    }),
-    get: createAstralResource({
-      path: `${basePath}/:id`,
-      method: "GET",
-      summary: `Get Single ${capitalizedName}`,
-      tags,
-      responseSchema: schemas.item
-    }),
-    create: createAstralResource({
-      path: basePath,
-      method: "POST",
-      summary: `Create ${capitalizedName}`,
-      tags,
-      requestSchema: schemas.create,
-      responseSchema: schemas.item,
-      responseStatusCode: 201
-    }),
-    update: createAstralResource({
-      path: `${basePath}/:id`,
-      method: "PATCH",
-      summary: `Update ${capitalizedName}`,
-      tags,
-      requestSchema: schemas.update,
-      responseSchema: schemas.item
-    }),
-    delete: createAstralResource({
-      path: `${basePath}/:id`,
-      method: "DELETE",
-      summary: `Delete ${capitalizedName}`,
-      tags,
-      responseSchema: schemas.item
-    })
-  };
-}
-// src/utils.ts
-import { Type as Type2 } from "@sinclair/typebox";
-function partial(schema) {
-  return Type2.Partial(schema);
-}
-// src/validator.ts
-import { tbValidator as tbValidator2 } from "@hono/typebox-validator";
-function validate(source, schema, hook) {
-  return tbValidator2(source, schema, hook);
-}
 export {
-  tbValidator3 as validator,
   validateWithCoercion,
   validate,
   unregisterFormat,

package/dist/openapi.d.ts

@@ -212,4 +212,3 @@ export declare function createCrudResources(options: {
     update: AstralResource;
     delete: AstralResource;
 };
-//# sourceMappingURL=openapi.d.ts.map

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { Context, Env } from '@gravito/photon';
+import type { GravitoContext } from '@gravito/photon';
 import type { Static, TSchema } from '@sinclair/typebox';
 /**
  * Supported data sources for validation.
@@ -43,11 +43,8 @@ export interface ValidationResult<T extends TSchema> {
  * after validation but before the main route handler.
  *
  * @template T - The TypeBox schema type
- * @template E - The Photon environment type
- *
  * @param result - The outcome of the validation
  * @param context - The Photon request context
  * @returns A Response object to short-circuit the request, or undefined to proceed
  */
-export type ValidationHook<T extends TSchema, E extends Env = Env> = (result: ValidationResult<T>, context: Context<E>) => Response | Promise<Response> | undefined;
-//# sourceMappingURL=types.d.ts.map
+export type ValidationHook<T extends TSchema> = (result: ValidationResult<T>, context: GravitoContext) => Response | Promise<Response> | undefined;

package/dist/utils.d.ts

@@ -20,4 +20,3 @@ import type { TObject, TPartial } from '@sinclair/typebox';
  * ```
  */
 export declare function partial<T extends TObject>(schema: T): TPartial<T>;
-//# sourceMappingURL=utils.d.ts.map

package/dist/validator.d.ts

@@ -1,47 +1,40 @@
-import type { Context, Env, MiddlewareHandler } from '@gravito/photon';
-import type { Static, TSchema } from '@sinclair/typebox';
-export type { ValidationError, ValidationHook, ValidationResult, ValidationSource, } from './types';
+import type { GravitoContext, GravitoMiddleware } from '@gravito/core';
+import type { TSchema } from '@sinclair/typebox';
+export type { ValidationError, ValidationHook, ValidationResult, } from './types';
 /**
- * Creates a validation middleware using TypeBox schemas.
+ * Validation source types.
+ */
+export type ValidationSource = 'json' | 'form' | 'query' | 'param' | 'header' | 'cookie';
+/**
+ * Validates request data using TypeBox schema.
  *
- * This middleware validates incoming request data against the provided schema.
- * It integrates seamlessly with Photon's type system, providing full type safety
- * for validated data in the request context.
+ * This middleware provides high-performance validation with full TypeScript
+ * support. It leverages @hono/typebox-validator for runtime validation.
  *
  * @param source - The request data source to validate (json, query, param, form)
  * @param schema - The TypeBox schema defining the expected data structure
  * @param hook - Optional callback to handle validation results manually
- * @returns A Photon middleware handler that enforces the schema
+ * @returns A Gravito middleware handler that enforces the schema
  *
  * @example Validating a JSON body
  * ```typescript
- * app.post('/users',
- *   validate('json', Schema.Object({
- *     name: Schema.String(),
- *     age: Schema.Number()
- *   })),
- *   (c) => {
- *     const user = c.req.valid('json')
- *     return c.json({ created: user.name })
- *   }
- * )
- * ```
+ * import { Type } from '@sinclair/typebox'
+ * import { validate } from '@gravito/mass'
  *
- * @example Custom error handling with hook
- * ```typescript
- * validate('query', schema, (result, c) => {
- *   if (!result.success) {
- *     return c.json({ error: 'Invalid query params' }, 400)
- *   }
+ * const schema = Type.Object({
+ *   name: Type.String()
+ * })
+ *
+ * app.post('/users', validate('json', schema), (c) => {
+ *   const data = c.req.valid('json')
+ *   return c.json(data)
  * })
  * ```
+ *
+ * @param source - The data source to validate (json, query, param, etc.)
+ * @param schema - TypeBox schema
+ * @param hook - Optional validation hook for custom error handling
+ * @returns Photon middleware handler
+ * @public
  */
-export declare function validate<T extends TSchema, S extends 'json' | 'query' | 'param' | 'form', E extends Env = Env, P extends string = string>(source: S, schema: T, hook?: (result: unknown, c: Context<E>) => Response | Promise<Response> | undefined): MiddlewareHandler<E, P, {
-    in: {
-        [K in S]: Static<T>;
-    };
-    out: {
-        [K in S]: Static<T>;
-    };
-}>;
-//# sourceMappingURL=validator.d.ts.map
+export declare function validate<T extends TSchema>(source: 'json' | 'query' | 'param' | 'form', schema: T, hook?: (result: unknown, c: GravitoContext) => Response | Promise<Response> | undefined): GravitoMiddleware;

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@gravito/mass",
-  "version": "3.0.2",
+  "sideEffects": false,
+  "version": "3.0.3",
   "description": "TypeBox-based validation for Gravito - High-performance schema validation with full TypeScript support",
   "type": "module",
   "main": "./dist/index.js",
@@ -16,6 +17,7 @@
   ],
   "scripts": {
     "build": "bun run build.ts",
+    "build:dts": "bun run build.ts --dts-only",
     "typecheck": "bun tsc -p tsconfig.json --noEmit --skipLibCheck",
     "test": "bun test --timeout=10000",
     "prepublishOnly": "bun run build",
@@ -28,15 +30,15 @@
     "access": "public"
   },
   "dependencies": {
-    "@hono/typebox-validator": "^1.1.0",
     "@sinclair/typebox": "^0.34.0"
   },
   "peerDependencies": {
-    "@gravito/core": "^1.6.1"
+    "@gravito/core": "^2.0.0"
   },
   "devDependencies": {
+    "@gravito/core": "workspace:*",
     "bun-types": "^1.1.0",
-    "@gravito/photon": "^1.0.1",
+    "@gravito/photon": "workspace:*",
     "typescript": "^5.9.3"
   },
   "author": "Carl Lee <carllee0520@gmail.com>",

package/dist/coercion.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"coercion.d.ts","sourceRoot":"","sources":["../src/coercion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAEtE,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAGrF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGlD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGnD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAGpD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAE9C;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,eAAe,CAC7B,OAAO,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,GAAG;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAC9D,OAAO,CAMT;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,GAAG;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAC/D,QAAQ,CAKV;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,GAAG;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GAChE,QAAQ,CAKV;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,GAAG,OAAO,CAoC/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AACH,wBAAgB,oBAAoB,CAClC,CAAC,SAAS,OAAO,EACjB,CAAC,SAAS,MAAM,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,EAC7C,CAAC,SAAS,GAAG,GAAG,GAAG,EACnB,CAAC,SAAS,MAAM,GAAG,MAAM,EAEzB,MAAM,EAAE,CAAC,EACT,MAAM,EAAE,CAAC,EACT,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,GAAG,SAAS,GAClF,iBAAiB,CAClB,CAAC,EACD,CAAC,EACD;IACE,EAAE,EAAE;SAAG,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;KAAE,CAAA;IAC3B,GAAG,EAAE;SAAG,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;KAAE,CAAA;CAC7B,CACF,CAoDA"}

package/dist/errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAC1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAE/C;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;CAavB,CAAA;AAEV;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;CAapB,CAAA;AAEV;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK;IAClD,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;aAQ1B,MAAM,EAAE,gBAAgB;aACxB,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IARlE;;;;;OAKG;gBAEe,MAAM,EAAE,gBAAgB,EACxB,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAMlE;;;;OAIG;IACH,MAAM;;;;kBAXkC,MAAM;qBAAW,MAAM;;;CAkBhE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,UAAU,EACjB,MAAM,GAAE,OAAO,GAAG,IAAc,GAC/B;IACD,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAsDA;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK;IAChC,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CACvB,GACA,cAAc,CAUhB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG;IAC9E,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;CACjC,CAYA"}

package/dist/formats.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"formats.d.ts","sourceRoot":"","sources":["../src/formats.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,iGAUrB,CAAA;AAEV,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAA;AAmFlE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,GAAG,IAAI,CAExF;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAIzC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,SAAS,CAEzF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAEnD"}

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AAGH,OAAO,EAAE,WAAW,IAAI,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAGlE,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAExD,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAE3C,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,EACf,aAAa,EACb,UAAU,EACV,UAAU,EACV,aAAa,EACb,YAAY,EACZ,oBAAoB,GACrB,MAAM,YAAY,CAAA;AAEnB,OAAO,EACL,oBAAoB,EACpB,iBAAiB,EACjB,oBAAoB,EACpB,KAAK,cAAc,EACnB,YAAY,EACZ,YAAY,EACZ,mBAAmB,GACpB,MAAM,UAAU,CAAA;AAEjB,OAAO,EACL,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,KAAK,gBAAgB,EACrB,kBAAkB,EAClB,cAAc,EACd,gBAAgB,GACjB,MAAM,WAAW,CAAA;AAElB,OAAO,EACL,KAAK,cAAc,EACnB,oBAAoB,EACpB,mBAAmB,EACnB,KAAK,aAAa,EAClB,gBAAgB,GACjB,MAAM,WAAW,CAAA;AAElB,YAAY,EACV,eAAe,EACf,cAAc,EACd,gBAAgB,GACjB,MAAM,SAAS,CAAA;AAEhB,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAEjC,OAAO,EAAE,KAAK,gBAAgB,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA"}

package/dist/openapi.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"openapi.d.ts","sourceRoot":"","sources":["../src/openapi.ts"],"names":[],"mappings":"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"}

package/dist/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAA;AACnD,OAAO,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAExD;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,CAAA;AAElE;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,yDAAyD;IACzD,IAAI,EAAE,MAAM,CAAA;IACZ,gDAAgD;IAChD,OAAO,EAAE,MAAM,CAAA;IACf,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,mDAAmD;IACnD,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC,SAAS,OAAO;IACjD,sDAAsD;IACtD,OAAO,EAAE,OAAO,CAAA;IAChB,qEAAqE;IACrE,IAAI,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAA;IAChB,qEAAqE;IACrE,MAAM,CAAC,EAAE,eAAe,EAAE,CAAA;CAC3B;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,SAAS,GAAG,GAAG,GAAG,IAAI,CACnE,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAC3B,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,KAChB,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAA"}

package/dist/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAG1D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,OAAO,EAAE,MAAM,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAEjE"}

package/dist/validator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../src/validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAEtE,OAAO,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAExD,YAAY,EACV,eAAe,EACf,cAAc,EACd,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,SAAS,CAAA;AAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,QAAQ,CACtB,CAAC,SAAS,OAAO,EACjB,CAAC,SAAS,MAAM,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,EAC7C,CAAC,SAAS,GAAG,GAAG,GAAG,EACnB,CAAC,SAAS,MAAM,GAAG,MAAM,EAEzB,MAAM,EAAE,CAAC,EACT,MAAM,EAAE,CAAC,EACT,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,GAAG,SAAS,GAClF,iBAAiB,CAClB,CAAC,EACD,CAAC,EACD;IACE,EAAE,EAAE;SAAG,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;KAAE,CAAA;IAC3B,GAAG,EAAE;SAAG,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;KAAE,CAAA;CAC7B,CACF,CAEA"}