@kuratchi/js 0.0.19 → 0.0.21

package/dist/runtime/schema.d.ts

@@ -0,0 +1,49 @@
+export declare class SchemaValidationError extends Error {
+    readonly isSchemaValidationError = true;
+    readonly status = 400;
+    constructor(message: string);
+}
+export interface SchemaType<T> {
+    parse(input: unknown, path?: string): T;
+}
+export type InferSchema<T extends SchemaType<any>> = T extends SchemaType<infer U> ? U : never;
+declare class BaseSchema<T> implements SchemaType<T> {
+    protected readonly parser: (input: unknown, path: string) => T;
+    constructor(parser: (input: unknown, path: string) => T);
+    parse(input: unknown, path?: string): T;
+    optional(defaultValue?: T): SchemaType<T | undefined>;
+    list(): SchemaType<T[]>;
+}
+declare class StringSchema extends BaseSchema<string> {
+    constructor();
+    min(length: number): SchemaType<string>;
+}
+declare class NumberSchema extends BaseSchema<number> {
+    constructor();
+    min(value: number): SchemaType<number>;
+}
+declare class BooleanSchema extends BaseSchema<boolean> {
+    constructor();
+}
+declare class FileSchema extends BaseSchema<File> {
+    constructor();
+}
+type ShapeRecord = Record<string, SchemaType<any>>;
+type InferShape<TShape extends ShapeRecord> = {
+    [K in keyof TShape]: InferSchema<TShape[K]>;
+};
+declare class ObjectSchema<TShape extends ShapeRecord> extends BaseSchema<InferShape<TShape>> {
+    readonly shape: TShape;
+    constructor(shape: TShape);
+}
+type SchemaBuilder = {
+    <TShape extends ShapeRecord>(shape: TShape): ObjectSchema<TShape>;
+    string(): StringSchema;
+    number(): NumberSchema;
+    boolean(): BooleanSchema;
+    file(): FileSchema;
+};
+export declare const schema: SchemaBuilder;
+export declare function validateSchemaInput<T>(schemaDef: SchemaType<T> | undefined, args: unknown[]): unknown[];
+export declare function parseRpcArgsPayload(payload: string | null): any[];
+export {};

package/dist/runtime/schema.js

@@ -0,0 +1,148 @@
+export class SchemaValidationError extends Error {
+    isSchemaValidationError = true;
+    status = 400;
+    constructor(message) {
+        super(message);
+        this.name = 'SchemaValidationError';
+    }
+}
+function formatPath(path) {
+    return path || 'value';
+}
+function describe(value) {
+    if (value === null)
+        return 'null';
+    if (typeof File !== 'undefined' && value instanceof File)
+        return 'file';
+    if (Array.isArray(value))
+        return 'array';
+    return typeof value;
+}
+function fail(path, message) {
+    throw new SchemaValidationError(`${formatPath(path)} ${message}`);
+}
+function isPlainObject(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value) && !(typeof File !== 'undefined' && value instanceof File);
+}
+class BaseSchema {
+    parser;
+    constructor(parser) {
+        this.parser = parser;
+    }
+    parse(input, path = 'value') {
+        return this.parser(input, path);
+    }
+    optional(defaultValue) {
+        return new BaseSchema((input, path) => {
+            if (typeof input === 'undefined')
+                return defaultValue;
+            return this.parse(input, path);
+        });
+    }
+    list() {
+        return new BaseSchema((input, path) => {
+            if (!Array.isArray(input))
+                fail(path, `must be an array, got ${describe(input)}`);
+            return input.map((item, index) => this.parse(item, `${path}[${index}]`));
+        });
+    }
+}
+class StringSchema extends BaseSchema {
+    constructor() {
+        super((input, path) => {
+            if (typeof input !== 'string')
+                fail(path, `must be a string, got ${describe(input)}`);
+            return input;
+        });
+    }
+    min(length) {
+        return new BaseSchema((input, path) => {
+            const value = this.parse(input, path);
+            if (value.length < length)
+                fail(path, `must be at least ${length} character(s)`);
+            return value;
+        });
+    }
+}
+class NumberSchema extends BaseSchema {
+    constructor() {
+        super((input, path) => {
+            if (typeof input !== 'number' || Number.isNaN(input))
+                fail(path, `must be a number, got ${describe(input)}`);
+            return input;
+        });
+    }
+    min(value) {
+        return new BaseSchema((input, path) => {
+            const parsed = this.parse(input, path);
+            if (parsed < value)
+                fail(path, `must be at least ${value}`);
+            return parsed;
+        });
+    }
+}
+class BooleanSchema extends BaseSchema {
+    constructor() {
+        super((input, path) => {
+            if (typeof input !== 'boolean')
+                fail(path, `must be a boolean, got ${describe(input)}`);
+            return input;
+        });
+    }
+}
+class FileSchema extends BaseSchema {
+    constructor() {
+        super((input, path) => {
+            if (typeof File === 'undefined' || !(input instanceof File))
+                fail(path, `must be a file, got ${describe(input)}`);
+            return input;
+        });
+    }
+}
+class ObjectSchema extends BaseSchema {
+    shape;
+    constructor(shape) {
+        super((input, path) => {
+            if (!isPlainObject(input))
+                fail(path, `must be an object, got ${describe(input)}`);
+            const out = {};
+            for (const key of Object.keys(shape)) {
+                out[key] = shape[key].parse(input[key], `${path}.${key}`);
+            }
+            return out;
+        });
+        this.shape = shape;
+    }
+}
+function createSchema(shape) {
+    return new ObjectSchema(shape);
+}
+export const schema = Object.assign(createSchema, {
+    string: () => new StringSchema(),
+    number: () => new NumberSchema(),
+    boolean: () => new BooleanSchema(),
+    file: () => new FileSchema(),
+});
+export function validateSchemaInput(schemaDef, args) {
+    if (!schemaDef)
+        return args;
+    if (args.length !== 1) {
+        throw new SchemaValidationError(`validated RPCs must receive exactly one argument object, got ${args.length}`);
+    }
+    return [schemaDef.parse(args[0], 'data')];
+}
+export function parseRpcArgsPayload(payload) {
+    if (!payload)
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(payload);
+    }
+    catch {
+        throw new SchemaValidationError('args must be valid JSON');
+    }
+    if (!Array.isArray(parsed)) {
+        throw new SchemaValidationError('args must be a JSON array');
+    }
+    return parsed;
+}

package/dist/runtime/types.d.ts

@@ -34,6 +34,8 @@ export interface RouteModule {
     actions?: Record<string, (formData: FormData, env: Env, ctx: RouteContext) => Promise<any>>;
     /** RPC functions â€" callable from client via fetch */
     rpc?: Record<string, (args: any[], env: Env, ctx: RouteContext) => Promise<any>>;
+    /** Optional schemas for RPC inputs, keyed by function name */
+    rpcSchemas?: Record<string, any>;
     /** Render function â€" returns route HTML and optional head content from data */
     render: (data: Record<string, any>) => PageRenderOutput;
     /** Layout name (default: 'default') */

package/dist/runtime/validation.d.ts

@@ -0,0 +1,26 @@
+export declare class RpcValidationError extends Error {
+    readonly isRpcValidationError = true;
+    readonly status = 400;
+    constructor(message: string);
+}
+export interface Validator<T> {
+    parse(input: unknown, path?: string): T;
+}
+export type InferValidator<T extends Validator<any>> = T extends Validator<infer U> ? U : never;
+export declare const v: {
+    string(): Validator<string>;
+    number(): Validator<number>;
+    boolean(): Validator<boolean>;
+    literal<const T extends string | number | boolean | null>(expected: T): Validator<T>;
+    optional<T>(inner: Validator<T>): Validator<T | undefined>;
+    nullable<T>(inner: Validator<T>): Validator<T | null>;
+    array<T>(inner: Validator<T>): Validator<T[]>;
+    object<TShape extends Record<string, Validator<any>>>(shape: TShape): Validator<{ [K in keyof TShape]: InferValidator<TShape[K]>; }>;
+    tuple<TItems extends readonly Validator<any>[]>(items: TItems): Validator<{ [K in keyof TItems]: InferValidator<TItems[K]>; }>;
+    union<TItems extends readonly Validator<any>[]>(items: TItems): Validator<InferValidator<TItems[number]>>;
+};
+export declare function rpc<TArgs extends any[], TResult>(validator: Validator<TArgs>, handler: (...args: TArgs) => Promise<TResult> | TResult): ((...args: TArgs) => Promise<TResult> | TResult) & {
+    __kuratchiRpcValidator: Validator<TArgs>;
+};
+export declare function validateRpcArgs(fn: (...args: any[]) => Promise<unknown> | unknown, args: unknown[]): any[];
+export declare function parseRpcArgsPayload(payload: string | null): any[];

package/dist/runtime/validation.js

@@ -0,0 +1,147 @@
+export class RpcValidationError extends Error {
+    isRpcValidationError = true;
+    status = 400;
+    constructor(message) {
+        super(message);
+        this.name = 'RpcValidationError';
+    }
+}
+function formatPath(path) {
+    return path || 'value';
+}
+function describe(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    return typeof value;
+}
+function fail(path, message) {
+    throw new RpcValidationError(`${formatPath(path)} ${message}`);
+}
+function createValidator(parse) {
+    return {
+        parse(input, path = 'value') {
+            return parse(input, path);
+        },
+    };
+}
+function isPlainObject(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+export const v = {
+    string() {
+        return createValidator((input, path) => {
+            if (typeof input !== 'string')
+                fail(path, `must be a string, got ${describe(input)}`);
+            return input;
+        });
+    },
+    number() {
+        return createValidator((input, path) => {
+            if (typeof input !== 'number' || Number.isNaN(input))
+                fail(path, `must be a number, got ${describe(input)}`);
+            return input;
+        });
+    },
+    boolean() {
+        return createValidator((input, path) => {
+            if (typeof input !== 'boolean')
+                fail(path, `must be a boolean, got ${describe(input)}`);
+            return input;
+        });
+    },
+    literal(expected) {
+        return createValidator((input, path) => {
+            if (input !== expected)
+                fail(path, `must be ${JSON.stringify(expected)}`);
+            return expected;
+        });
+    },
+    optional(inner) {
+        return createValidator((input, path) => {
+            if (typeof input === 'undefined')
+                return undefined;
+            return inner.parse(input, path);
+        });
+    },
+    nullable(inner) {
+        return createValidator((input, path) => {
+            if (input === null)
+                return null;
+            return inner.parse(input, path);
+        });
+    },
+    array(inner) {
+        return createValidator((input, path) => {
+            if (!Array.isArray(input))
+                fail(path, `must be an array, got ${describe(input)}`);
+            return input.map((value, index) => inner.parse(value, `${path}[${index}]`));
+        });
+    },
+    object(shape) {
+        return createValidator((input, path) => {
+            if (!isPlainObject(input))
+                fail(path, `must be an object, got ${describe(input)}`);
+            const out = {};
+            for (const key of Object.keys(shape)) {
+                out[key] = shape[key].parse(input[key], `${path}.${key}`);
+            }
+            return out;
+        });
+    },
+    tuple(items) {
+        return createValidator((input, path) => {
+            if (!Array.isArray(input))
+                fail(path, `must be an array, got ${describe(input)}`);
+            if (input.length !== items.length)
+                fail(path, `must contain ${items.length} item(s), got ${input.length}`);
+            const out = [];
+            for (let index = 0; index < items.length; index++) {
+                out.push(items[index].parse(input[index], `${path}[${index}]`));
+            }
+            return out;
+        });
+    },
+    union(items) {
+        return createValidator((input, path) => {
+            const messages = [];
+            for (const item of items) {
+                try {
+                    return item.parse(input, path);
+                }
+                catch (error) {
+                    if (error instanceof RpcValidationError)
+                        messages.push(error.message);
+                }
+            }
+            fail(path, messages.length > 0 ? `did not match any allowed shape: ${messages.join('; ')}` : 'did not match any allowed shape');
+        });
+    },
+};
+export function rpc(validator, handler) {
+    const rpcHandler = handler;
+    rpcHandler.__kuratchiRpcValidator = validator;
+    return rpcHandler;
+}
+export function validateRpcArgs(fn, args) {
+    const validator = fn.__kuratchiRpcValidator;
+    if (!validator)
+        return args;
+    return validator.parse(args, 'args');
+}
+export function parseRpcArgsPayload(payload) {
+    if (!payload)
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(payload);
+    }
+    catch {
+        throw new RpcValidationError('args must be valid JSON');
+    }
+    if (!Array.isArray(parsed)) {
+        throw new RpcValidationError('args must be a JSON array');
+    }
+    return parsed;
+}

package/package.json

@@ -1,68 +1,76 @@
-{
-    "name": "@kuratchi/js",
-    "version": "0.0.19",
-    "description": "A thin, Cloudflare Workers-native web framework with Svelte-inspired syntax",
-    "license": "MIT",
-    "type": "module",
-    "main": "./dist/index.js",
-    "types": "./dist/index.d.ts",
-    "bin": {
-        "kuratchi": "dist/cli.js"
-    },
-    "files": [
-        "dist",
-        "README.md",
-        "LICENSE"
-    ],
-    "scripts": {
-        "build": "tsc -p tsconfig.build.json",
-        "check": "tsc -p tsconfig.build.json --noEmit",
-        "test": "bun test",
-        "test:watch": "bun test --watch",
-        "prepublishOnly": "npm run build"
-    },
-    "exports": {
-        ".": {
-            "types": "./dist/index.d.ts",
-            "import": "./dist/index.js"
-        },
-        "./runtime/context.js": {
-            "types": "./dist/runtime/context.d.ts",
-            "import": "./dist/runtime/context.js"
-        },
-        "./request": {
-            "types": "./dist/runtime/request.d.ts",
-            "import": "./dist/runtime/request.js"
-        },
-        "./runtime/do.js": {
-            "types": "./dist/runtime/do.d.ts",
-            "import": "./dist/runtime/do.js"
-        },
-        "./runtime/generated-worker.js": {
-            "types": "./dist/runtime/generated-worker.d.ts",
-            "import": "./dist/runtime/generated-worker.js"
-        },
-        "./compiler": {
-            "types": "./dist/compiler/index.d.ts",
-            "import": "./dist/compiler/index.js"
-        },
-        "./environment": {
-            "types": "./dist/index.d.ts",
-            "import": "./dist/index.js"
-        },
-        "./package.json": "./package.json"
-    },
-    "engines": {
-        "node": ">=18"
-    },
-    "publishConfig": {
-        "access": "public"
-    },
-    "dependencies": {
-        "typescript": "^5.8.0"
-    },
-    "devDependencies": {
-        "@cloudflare/workers-types": "^4.20260223.0",
-        "@types/node": "^24.4.0"
-    }
-}
+{
+    "name": "@kuratchi/js",
+    "version": "0.0.21",
+    "description": "A thin, Cloudflare Workers-native web framework with Svelte-inspired syntax",
+    "license": "MIT",
+    "type": "module",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "bin": {
+        "kuratchi": "dist/cli.js"
+    },
+    "files": [
+        "dist",
+        "README.md",
+        "LICENSE"
+    ],
+    "scripts": {
+        "build": "tsc -p tsconfig.build.json",
+        "check": "tsc -p tsconfig.build.json --noEmit",
+        "test": "bun test",
+        "test:watch": "bun test --watch",
+        "prepublishOnly": "npm run build"
+    },
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        },
+        "./runtime/context.js": {
+            "types": "./dist/runtime/context.d.ts",
+            "import": "./dist/runtime/context.js"
+        },
+        "./request": {
+            "types": "./dist/runtime/request.d.ts",
+            "import": "./dist/runtime/request.js"
+        },
+        "./navigation": {
+            "types": "./dist/runtime/navigation.d.ts",
+            "import": "./dist/runtime/navigation.js"
+        },
+        "./runtime/do.js": {
+            "types": "./dist/runtime/do.d.ts",
+            "import": "./dist/runtime/do.js"
+        },
+        "./runtime/schema.js": {
+            "types": "./dist/runtime/schema.d.ts",
+            "import": "./dist/runtime/schema.js"
+        },
+        "./runtime/generated-worker.js": {
+            "types": "./dist/runtime/generated-worker.d.ts",
+            "import": "./dist/runtime/generated-worker.js"
+        },
+        "./compiler": {
+            "types": "./dist/compiler/index.d.ts",
+            "import": "./dist/compiler/index.js"
+        },
+        "./environment": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        },
+        "./package.json": "./package.json"
+    },
+    "engines": {
+        "node": ">=18"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "dependencies": {
+        "typescript": "^5.8.0"
+    },
+    "devDependencies": {
+        "@cloudflare/workers-types": "^4.20260223.0",
+        "@types/node": "^24.4.0"
+    }
+}