@float.js/core 2.0.1

package/dist/api/index.js

@@ -0,0 +1,643 @@
+// src/api/index.ts
+function createStringSchema() {
+  const validators = [];
+  const transforms = [];
+  const schema = {
+    _type: "string",
+    _output: "",
+    min(length, message) {
+      validators.push(
+        (val) => val.length >= length ? null : message || `Must be at least ${length} characters`
+      );
+      return schema;
+    },
+    max(length, message) {
+      validators.push(
+        (val) => val.length <= length ? null : message || `Must be at most ${length} characters`
+      );
+      return schema;
+    },
+    email(message) {
+      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+      validators.push(
+        (val) => emailRegex.test(val) ? null : message || "Invalid email address"
+      );
+      return schema;
+    },
+    url(message) {
+      validators.push((val) => {
+        try {
+          new URL(val);
+          return null;
+        } catch {
+          return message || "Invalid URL";
+        }
+      });
+      return schema;
+    },
+    uuid(message) {
+      const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+      validators.push(
+        (val) => uuidRegex.test(val) ? null : message || "Invalid UUID"
+      );
+      return schema;
+    },
+    regex(pattern, message) {
+      validators.push(
+        (val) => pattern.test(val) ? null : message || `Must match pattern ${pattern}`
+      );
+      return schema;
+    },
+    trim() {
+      transforms.push((val) => val.trim());
+      return schema;
+    },
+    toLowerCase() {
+      transforms.push((val) => val.toLowerCase());
+      return schema;
+    },
+    toUpperCase() {
+      transforms.push((val) => val.toUpperCase());
+      return schema;
+    },
+    optional() {
+      return createOptionalSchema(schema);
+    },
+    parse(value) {
+      const result = schema.safeParse(value);
+      if (!result.success) {
+        throw new FloatValidationError([result.error]);
+      }
+      return result.data;
+    },
+    safeParse(value) {
+      if (typeof value !== "string") {
+        return {
+          success: false,
+          error: {
+            path: [],
+            message: "Expected string",
+            received: value,
+            expected: "string"
+          }
+        };
+      }
+      let transformed = value;
+      for (const transform of transforms) {
+        transformed = transform(transformed);
+      }
+      for (const validator of validators) {
+        const error2 = validator(transformed);
+        if (error2) {
+          return {
+            success: false,
+            error: {
+              path: [],
+              message: error2,
+              received: value,
+              expected: "string"
+            }
+          };
+        }
+      }
+      return { success: true, data: transformed };
+    }
+  };
+  return schema;
+}
+function createNumberSchema() {
+  const validators = [];
+  const schema = {
+    _type: "number",
+    _output: 0,
+    min(value, message) {
+      validators.push(
+        (val) => val >= value ? null : message || `Must be at least ${value}`
+      );
+      return schema;
+    },
+    max(value, message) {
+      validators.push(
+        (val) => val <= value ? null : message || `Must be at most ${value}`
+      );
+      return schema;
+    },
+    int(message) {
+      validators.push(
+        (val) => Number.isInteger(val) ? null : message || "Must be an integer"
+      );
+      return schema;
+    },
+    positive(message) {
+      validators.push(
+        (val) => val > 0 ? null : message || "Must be positive"
+      );
+      return schema;
+    },
+    negative(message) {
+      validators.push(
+        (val) => val < 0 ? null : message || "Must be negative"
+      );
+      return schema;
+    },
+    finite(message) {
+      validators.push(
+        (val) => Number.isFinite(val) ? null : message || "Must be finite"
+      );
+      return schema;
+    },
+    optional() {
+      return createOptionalSchema(schema);
+    },
+    parse(value) {
+      const result = schema.safeParse(value);
+      if (!result.success) {
+        throw new FloatValidationError([result.error]);
+      }
+      return result.data;
+    },
+    safeParse(value) {
+      const num = typeof value === "string" ? parseFloat(value) : value;
+      if (typeof num !== "number" || isNaN(num)) {
+        return {
+          success: false,
+          error: {
+            path: [],
+            message: "Expected number",
+            received: value,
+            expected: "number"
+          }
+        };
+      }
+      for (const validator of validators) {
+        const error2 = validator(num);
+        if (error2) {
+          return {
+            success: false,
+            error: {
+              path: [],
+              message: error2,
+              received: value,
+              expected: "number"
+            }
+          };
+        }
+      }
+      return { success: true, data: num };
+    }
+  };
+  return schema;
+}
+function createBooleanSchema() {
+  const schema = {
+    _type: "boolean",
+    _output: false,
+    optional() {
+      return createOptionalSchema(schema);
+    },
+    parse(value) {
+      const result = schema.safeParse(value);
+      if (!result.success) {
+        throw new FloatValidationError([result.error]);
+      }
+      return result.data;
+    },
+    safeParse(value) {
+      if (value === "true") return { success: true, data: true };
+      if (value === "false") return { success: true, data: false };
+      if (typeof value !== "boolean") {
+        return {
+          success: false,
+          error: {
+            path: [],
+            message: "Expected boolean",
+            received: value,
+            expected: "boolean"
+          }
+        };
+      }
+      return { success: true, data: value };
+    }
+  };
+  return schema;
+}
+function createArraySchema(itemSchema) {
+  const validators = [];
+  const schema = {
+    _type: "array",
+    _output: [],
+    min(length, message) {
+      validators.push(
+        (val) => val.length >= length ? null : message || `Must have at least ${length} items`
+      );
+      return schema;
+    },
+    max(length, message) {
+      validators.push(
+        (val) => val.length <= length ? null : message || `Must have at most ${length} items`
+      );
+      return schema;
+    },
+    nonempty(message) {
+      validators.push(
+        (val) => val.length > 0 ? null : message || "Array must not be empty"
+      );
+      return schema;
+    },
+    optional() {
+      return createOptionalSchema(schema);
+    },
+    parse(value) {
+      const result = schema.safeParse(value);
+      if (!result.success) {
+        throw new FloatValidationError([result.error]);
+      }
+      return result.data;
+    },
+    safeParse(value) {
+      if (!Array.isArray(value)) {
+        return {
+          success: false,
+          error: {
+            path: [],
+            message: "Expected array",
+            received: value,
+            expected: "array"
+          }
+        };
+      }
+      for (const validator of validators) {
+        const error2 = validator(value);
+        if (error2) {
+          return {
+            success: false,
+            error: {
+              path: [],
+              message: error2,
+              received: value,
+              expected: "array"
+            }
+          };
+        }
+      }
+      const result = [];
+      for (let i = 0; i < value.length; i++) {
+        const itemResult = itemSchema.safeParse(value[i]);
+        if (!itemResult.success) {
+          return {
+            success: false,
+            error: {
+              ...itemResult.error,
+              path: [String(i), ...itemResult.error.path]
+            }
+          };
+        }
+        result.push(itemResult.data);
+      }
+      return { success: true, data: result };
+    }
+  };
+  return schema;
+}
+function createObjectSchema(shape) {
+  let passthroughMode = false;
+  let strictMode = false;
+  const schema = {
+    _type: "object",
+    _output: {},
+    _shape: shape,
+    partial() {
+      const partialShape = {};
+      for (const key in shape) {
+        partialShape[key] = shape[key].optional();
+      }
+      return createObjectSchema(partialShape);
+    },
+    pick(...keys) {
+      const pickedShape = {};
+      for (const key of keys) {
+        pickedShape[key] = shape[key];
+      }
+      return createObjectSchema(pickedShape);
+    },
+    omit(...keys) {
+      const omittedShape = { ...shape };
+      for (const key of keys) {
+        delete omittedShape[key];
+      }
+      return createObjectSchema(omittedShape);
+    },
+    extend(extension) {
+      return createObjectSchema({ ...shape, ...extension });
+    },
+    merge(other) {
+      return createObjectSchema({ ...shape, ...other._shape });
+    },
+    passthrough() {
+      passthroughMode = true;
+      return schema;
+    },
+    strict() {
+      strictMode = true;
+      return schema;
+    },
+    optional() {
+      return createOptionalSchema(schema);
+    },
+    parse(value) {
+      const result = schema.safeParse(value);
+      if (!result.success) {
+        throw new FloatValidationError([result.error]);
+      }
+      return result.data;
+    },
+    safeParse(value) {
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return {
+          success: false,
+          error: {
+            path: [],
+            message: "Expected object",
+            received: value,
+            expected: "object"
+          }
+        };
+      }
+      const obj = value;
+      const result = {};
+      if (strictMode) {
+        for (const key in obj) {
+          if (!(key in shape)) {
+            return {
+              success: false,
+              error: {
+                path: [key],
+                message: `Unknown key '${key}'`,
+                received: obj[key],
+                expected: "undefined"
+              }
+            };
+          }
+        }
+      }
+      for (const key in shape) {
+        const fieldSchema = shape[key];
+        const fieldResult = fieldSchema.safeParse(obj[key]);
+        if (!fieldResult.success) {
+          return {
+            success: false,
+            error: {
+              ...fieldResult.error,
+              path: [key, ...fieldResult.error.path]
+            }
+          };
+        }
+        result[key] = fieldResult.data;
+      }
+      if (passthroughMode) {
+        for (const key in obj) {
+          if (!(key in shape)) {
+            result[key] = obj[key];
+          }
+        }
+      }
+      return { success: true, data: result };
+    }
+  };
+  return schema;
+}
+function createOptionalSchema(innerSchema) {
+  const schema = {
+    _type: "optional",
+    _output: void 0,
+    _innerType: innerSchema,
+    default(defaultValue) {
+      return {
+        _type: "optional",
+        _output: defaultValue,
+        optional: () => schema,
+        parse(value) {
+          if (value === void 0 || value === null) {
+            return defaultValue;
+          }
+          return innerSchema.parse(value);
+        },
+        safeParse(value) {
+          if (value === void 0 || value === null) {
+            return { success: true, data: defaultValue };
+          }
+          return innerSchema.safeParse(value);
+        }
+      };
+    },
+    optional() {
+      return schema;
+    },
+    parse(value) {
+      const result = schema.safeParse(value);
+      if (!result.success) {
+        throw new FloatValidationError([result.error]);
+      }
+      return result.data;
+    },
+    safeParse(value) {
+      if (value === void 0 || value === null) {
+        return { success: true, data: void 0 };
+      }
+      return innerSchema.safeParse(value);
+    }
+  };
+  return schema;
+}
+function createEnumSchema(values) {
+  const schema = {
+    _type: "enum",
+    _output: values[0],
+    options: values,
+    optional() {
+      return createOptionalSchema(schema);
+    },
+    parse(value) {
+      const result = schema.safeParse(value);
+      if (!result.success) {
+        throw new FloatValidationError([result.error]);
+      }
+      return result.data;
+    },
+    safeParse(value) {
+      if (typeof value !== "string" || !values.includes(value)) {
+        return {
+          success: false,
+          error: {
+            path: [],
+            message: `Expected one of: ${values.join(", ")}`,
+            received: value,
+            expected: values.join(" | ")
+          }
+        };
+      }
+      return { success: true, data: value };
+    }
+  };
+  return schema;
+}
+function createUnionSchema(schemas) {
+  const schema = {
+    _type: "union",
+    _output: void 0,
+    optional() {
+      return createOptionalSchema(schema);
+    },
+    parse(value) {
+      const result = schema.safeParse(value);
+      if (!result.success) {
+        throw new FloatValidationError([result.error]);
+      }
+      return result.data;
+    },
+    safeParse(value) {
+      const errors = [];
+      for (const s of schemas) {
+        const result = s.safeParse(value);
+        if (result.success) {
+          return result;
+        }
+        errors.push(result.error);
+      }
+      return {
+        success: false,
+        error: {
+          path: [],
+          message: `Value did not match any schema in union`,
+          received: value,
+          expected: schemas.map((s) => s._type).join(" | ")
+        }
+      };
+    }
+  };
+  return schema;
+}
+var FloatValidationError = class extends Error {
+  errors;
+  status = 400;
+  constructor(errors) {
+    super("Validation failed");
+    this.name = "FloatValidationError";
+    this.errors = errors;
+  }
+  toJSON() {
+    return {
+      error: "Validation Error",
+      details: this.errors.map((e) => ({
+        path: e.path.join(".") || "root",
+        message: e.message,
+        received: typeof e.received
+      }))
+    };
+  }
+  toResponse() {
+    return new Response(JSON.stringify(this.toJSON()), {
+      status: 400,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+};
+var f = {
+  string: createStringSchema,
+  number: createNumberSchema,
+  boolean: createBooleanSchema,
+  array: createArraySchema,
+  object: createObjectSchema,
+  enum: createEnumSchema,
+  union: createUnionSchema
+};
+function typedRoute(options, handler) {
+  return async (request) => {
+    try {
+      const validated = { body: void 0, query: void 0, params: void 0 };
+      if (options.body) {
+        try {
+          const body = await request.json();
+          const bodySchema = options.body;
+          const result = bodySchema.safeParse(body);
+          if (!result.success) {
+            return new FloatValidationError([result.error]).toResponse();
+          }
+          validated.body = result.data;
+        } catch {
+          return new Response(
+            JSON.stringify({ error: "Invalid JSON body" }),
+            { status: 400, headers: { "Content-Type": "application/json" } }
+          );
+        }
+      }
+      if (options.query) {
+        const url = new URL(request.url);
+        const queryObj = {};
+        url.searchParams.forEach((value, key) => {
+          queryObj[key] = value;
+        });
+        const querySchema = options.query;
+        const result = querySchema.safeParse(queryObj);
+        if (!result.success) {
+          return new FloatValidationError([result.error]).toResponse();
+        }
+        validated.query = result.data;
+      }
+      if (options.params) {
+        const params = request.params || {};
+        const paramsSchema = options.params;
+        const result = paramsSchema.safeParse(params);
+        if (!result.success) {
+          return new FloatValidationError([result.error]).toResponse();
+        }
+        validated.params = result.data;
+      }
+      const typedRequest = request;
+      typedRequest.validated = validated;
+      return await handler(typedRequest);
+    } catch (error2) {
+      if (error2 instanceof FloatValidationError) {
+        return error2.toResponse();
+      }
+      console.error("Route error:", error2);
+      return new Response(
+        JSON.stringify({ error: "Internal server error" }),
+        { status: 500, headers: { "Content-Type": "application/json" } }
+      );
+    }
+  };
+}
+function json(data, options = {}) {
+  return new Response(JSON.stringify(data), {
+    status: options.status || 200,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+}
+function error(message, status = 500) {
+  return new Response(
+    JSON.stringify({ error: message }),
+    {
+      status,
+      headers: { "Content-Type": "application/json" }
+    }
+  );
+}
+function redirect(url, status = 302) {
+  return new Response(null, {
+    status,
+    headers: { Location: url }
+  });
+}
+export {
+  FloatValidationError,
+  error,
+  f,
+  json,
+  redirect,
+  typedRoute
+};
+//# sourceMappingURL=index.js.map