@kuratchi/js 0.0.18 → 0.0.20

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,6 +1,6 @@
 {
     "name": "@kuratchi/js",
-    "version": "0.0.18",
+    "version": "0.0.20",
     "description": "A thin, Cloudflare Workers-native web framework with Svelte-inspired syntax",
     "license": "MIT",
     "type": "module",
@@ -38,6 +38,10 @@
             "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"