@float.js/core 2.0.1

package/dist/api/index.d.ts

@@ -0,0 +1,172 @@
+/**
+ * Float.js Type-Safe API Module
+ * Automatic validation and type inference for API routes
+ *
+ * This is a MAJOR differentiator from Next.js - zero boilerplate API validation!
+ */
+type SchemaType = 'string' | 'number' | 'boolean' | 'array' | 'object' | 'enum' | 'union' | 'optional';
+interface BaseSchema<T = unknown> {
+    _type: SchemaType;
+    _output: T;
+    optional(): OptionalSchema<T>;
+    parse(value: unknown): T;
+    safeParse(value: unknown): {
+        success: true;
+        data: T;
+    } | {
+        success: false;
+        error: ValidationError;
+    };
+}
+interface ValidationError {
+    path: string[];
+    message: string;
+    received: unknown;
+    expected: string;
+}
+interface StringSchema extends BaseSchema<string> {
+    _type: 'string';
+    min(length: number, message?: string): StringSchema;
+    max(length: number, message?: string): StringSchema;
+    email(message?: string): StringSchema;
+    url(message?: string): StringSchema;
+    uuid(message?: string): StringSchema;
+    regex(pattern: RegExp, message?: string): StringSchema;
+    trim(): StringSchema;
+    toLowerCase(): StringSchema;
+    toUpperCase(): StringSchema;
+}
+declare function createStringSchema(): StringSchema;
+interface NumberSchema extends BaseSchema<number> {
+    _type: 'number';
+    min(value: number, message?: string): NumberSchema;
+    max(value: number, message?: string): NumberSchema;
+    int(message?: string): NumberSchema;
+    positive(message?: string): NumberSchema;
+    negative(message?: string): NumberSchema;
+    finite(message?: string): NumberSchema;
+}
+declare function createNumberSchema(): NumberSchema;
+interface BooleanSchema extends BaseSchema<boolean> {
+    _type: 'boolean';
+}
+declare function createBooleanSchema(): BooleanSchema;
+interface ArraySchema<T> extends BaseSchema<T[]> {
+    _type: 'array';
+    min(length: number, message?: string): ArraySchema<T>;
+    max(length: number, message?: string): ArraySchema<T>;
+    nonempty(message?: string): ArraySchema<T>;
+}
+declare function createArraySchema<S extends BaseSchema>(itemSchema: S): ArraySchema<S['_output']>;
+type ObjectShape = Record<string, BaseSchema>;
+type InferObject<T extends ObjectShape> = {
+    [K in keyof T]: T[K]['_output'];
+};
+interface ObjectSchema<T extends ObjectShape> extends BaseSchema<InferObject<T>> {
+    _type: 'object';
+    _shape: T;
+    partial(): ObjectSchema<{
+        [K in keyof T]: OptionalSchema<T[K]['_output']>;
+    }>;
+    pick<K extends keyof T>(...keys: K[]): ObjectSchema<Pick<T, K>>;
+    omit<K extends keyof T>(...keys: K[]): ObjectSchema<Omit<T, K>>;
+    extend<E extends ObjectShape>(extension: E): ObjectSchema<T & E>;
+    merge<E extends ObjectShape>(other: ObjectSchema<E>): ObjectSchema<T & E>;
+    passthrough(): ObjectSchema<T>;
+    strict(): ObjectSchema<T>;
+}
+declare function createObjectSchema<T extends ObjectShape>(shape: T): ObjectSchema<T>;
+interface OptionalSchema<T> extends BaseSchema<T | undefined> {
+    _type: 'optional';
+    _innerType: BaseSchema<T>;
+    default(value: T): BaseSchema<T>;
+}
+interface EnumSchema<T extends readonly string[]> extends BaseSchema<T[number]> {
+    _type: 'enum';
+    options: T;
+}
+declare function createEnumSchema<T extends readonly string[]>(values: T): EnumSchema<T>;
+interface UnionSchema<T extends BaseSchema[]> extends BaseSchema<T[number]['_output']> {
+    _type: 'union';
+}
+declare function createUnionSchema<T extends BaseSchema[]>(schemas: T): UnionSchema<T>;
+declare class FloatValidationError extends Error {
+    readonly errors: ValidationError[];
+    readonly status = 400;
+    constructor(errors: ValidationError[]);
+    toJSON(): {
+        error: string;
+        details: {
+            path: string;
+            message: string;
+            received: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+        }[];
+    };
+    toResponse(): Response;
+}
+declare const f: {
+    string: typeof createStringSchema;
+    number: typeof createNumberSchema;
+    boolean: typeof createBooleanSchema;
+    array: typeof createArraySchema;
+    object: typeof createObjectSchema;
+    enum: typeof createEnumSchema;
+    union: typeof createUnionSchema;
+};
+type Infer<T extends BaseSchema> = T['_output'];
+interface TypedRouteOptions {
+    body?: ObjectSchema<any>;
+    query?: ObjectSchema<any>;
+    params?: ObjectSchema<any>;
+}
+interface ValidatedData {
+    body: any;
+    query: any;
+    params: any;
+}
+interface TypedRequest extends Request {
+    validated: ValidatedData;
+}
+type RouteHandler = (request: TypedRequest) => Promise<Response> | Response;
+/**
+ * Create a type-safe API route with automatic validation
+ *
+ * @example
+ * ```typescript
+ * import { typedRoute, f } from '@float/core';
+ *
+ * export const POST = typedRoute({
+ *   body: f.object({
+ *     name: f.string().min(2),
+ *     email: f.string().email(),
+ *     age: f.number().min(18).optional(),
+ *   }),
+ * }, async (req) => {
+ *   // req.validated.body is fully typed!
+ *   const { name, email, age } = req.validated.body;
+ *
+ *   return new Response(JSON.stringify({
+ *     message: `Hello ${name}!`
+ *   }));
+ * });
+ * ```
+ */
+declare function typedRoute(options: TypedRouteOptions, handler: RouteHandler): (request: Request) => Promise<Response>;
+interface JsonResponseOptions {
+    status?: number;
+    headers?: Record<string, string>;
+}
+/**
+ * Create a JSON response with automatic serialization
+ */
+declare function json<T>(data: T, options?: JsonResponseOptions): Response;
+/**
+ * Create an error response
+ */
+declare function error(message: string, status?: number): Response;
+/**
+ * Create a redirect response
+ */
+declare function redirect(url: string, status?: 301 | 302 | 307 | 308): Response;
+
+export { FloatValidationError, type Infer, error, f, json, redirect, typedRoute };