@gravito/mass 3.0.0 → 3.0.2

package/dist/index.js

@@ -1,15 +1,536 @@
 // @bun
 // src/index.ts
-import { tbValidator as tbValidator2 } from "@hono/typebox-validator";
+import { tbValidator as tbValidator3 } from "@hono/typebox-validator";
 import * as Schema from "@sinclair/typebox";
 
-// src/validator.ts
+// 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 tbValidator(source, schema, hook);
+  return tbValidator2(source, schema, hook);
 }
 export {
-  tbValidator2 as validator,
+  tbValidator3 as validator,
+  validateWithCoercion,
   validate,
-  Schema
+  unregisterFormat,
+  typeboxToOpenApi,
+  registerFormat,
+  registerAllFormats,
+  partial,
+  isFormatRegistered,
+  getFormatValidator,
+  formatErrors,
+  enhanceError,
+  createErrorFormatter,
+  createCrudResources,
+  createAstralResource,
+  coerceNumber,
+  coerceInteger,
+  coerceDate,
+  coerceData,
+  coerceBoolean,
+  Schema,
+  REGISTERED_FORMATS,
+  MassValidationError,
+  ERROR_MESSAGES_ZH_TW,
+  ERROR_MESSAGES_EN,
+  CoercibleNumber,
+  CoercibleInteger,
+  CoercibleBoolean
 };