@vesk/runtime 0.0.1

package/dist/request.js

@@ -0,0 +1,624 @@
+function getRequest() {
+    return globalThis.__vesk_request || null;
+}
+function getHooks() {
+    if (!globalThis.__vesk_hooks)
+        globalThis.__vesk_hooks = {};
+    return globalThis.__vesk_hooks;
+}
+export function defineHook(name, fn) {
+    const hooks = getHooks();
+    if (!hooks[name])
+        hooks[name] = [];
+    hooks[name].push(fn);
+}
+export function removeHook(name, fn) {
+    const hooks = getHooks();
+    if (!hooks[name])
+        return;
+    hooks[name] = hooks[name].filter(h => h !== fn);
+}
+export async function runHooks(name, ...args) {
+    const hooks = getHooks()[name] || [];
+    for (const fn of hooks) {
+        const result = await fn(...args);
+        if (result instanceof Response)
+            return result;
+    }
+}
+export function useParams() {
+    const ctx = getRequest();
+    return ctx?.params || {};
+}
+export function useRequest() {
+    return getRequest();
+}
+export async function useBody() {
+    const ctx = getRequest();
+    if (!ctx)
+        throw new Error('useBody() called outside request context');
+    if (ctx._parsedBody !== undefined)
+        return ctx._parsedBody;
+    const req = ctx._request;
+    if (!req)
+        return null;
+    const ct = (req.headers.get && req.headers.get('content-type')) || '';
+    try {
+        if (ct.includes('json')) {
+            ctx._parsedBody = await req.json();
+        }
+        else if (ct.includes('x-www-form-urlencoded')) {
+            const text = await req.text();
+            const obj = {};
+            for (const pair of text.split('&')) {
+                const [k, v] = pair.split('=').map(s => decodeURIComponent(s || ''));
+                if (k)
+                    obj[k] = v;
+            }
+            ctx._parsedBody = obj;
+        }
+        else {
+            ctx._parsedBody = await req.text();
+        }
+    }
+    catch {
+        ctx._parsedBody = null;
+    }
+    return ctx._parsedBody;
+}
+export function cors(options = {}) {
+    const { origin = '*', methods = 'GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS', allowedHeaders = 'Content-Type, Authorization', credentials = true, maxAge = 86400, exposeHeaders, } = options;
+    const corsHeaders = {
+        'Access-Control-Allow-Origin': origin,
+        'Access-Control-Allow-Methods': methods,
+        'Access-Control-Allow-Headers': allowedHeaders,
+        'Access-Control-Max-Age': String(maxAge),
+    };
+    if (credentials)
+        corsHeaders['Access-Control-Allow-Credentials'] = 'true';
+    if (exposeHeaders?.length)
+        corsHeaders['Access-Control-Expose-Headers'] = exposeHeaders.join(', ');
+    function applyCors(response) {
+        const headers = new Headers(response.headers);
+        for (const [k, v] of Object.entries(corsHeaders)) {
+            headers.set(k, v);
+        }
+        return new Response(response.body, {
+            status: response.status,
+            statusText: response.statusText,
+            headers,
+        });
+    }
+    const middleware = function (request) {
+        if (request.method === 'OPTIONS') {
+            return new Response(null, {
+                status: 204,
+                headers: corsHeaders,
+            });
+        }
+        middleware._pending = corsHeaders;
+    };
+    middleware.applyCors = applyCors;
+    middleware._corsHeaders = corsHeaders;
+    return middleware;
+}
+export function webhook(options) {
+    const { secret, handler, headerName = 'x-webhook-signature', signaturePrefix = 'sha256=', } = options;
+    if (!secret)
+        throw new Error('webhook() requires a secret');
+    if (!handler)
+        throw new Error('webhook() requires a handler function');
+    async function computeSignature(body) {
+        const key = typeof secret === 'string' ? new TextEncoder().encode(secret) : secret;
+        const data = typeof body === 'string' ? new TextEncoder().encode(body) : body;
+        const crypto = globalThis.crypto;
+        if (!crypto?.subtle) {
+            throw new Error('Web Crypto API not available (required for webhook signature verification)');
+        }
+        return crypto.subtle.importKey('raw', key, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign'])
+            .then(k => crypto.subtle.sign('HMAC', k, data))
+            .then(sig => {
+            const hex = Array.from(new Uint8Array(sig))
+                .map(b => b.toString(16).padStart(2, '0'))
+                .join('');
+            return hex;
+        });
+    }
+    async function webhookHandler(request) {
+        const signature = request.headers.get(headerName);
+        if (!signature) {
+            return new Response(JSON.stringify({ error: 'Missing signature header' }), {
+                status: 401,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        const body = await request.text();
+        const expectedSig = await computeSignature(body);
+        const prefixLen = signaturePrefix.length;
+        const providedSig = signature.startsWith(signaturePrefix)
+            ? signature.slice(prefixLen)
+            : signature;
+        if (providedSig.length !== expectedSig.length) {
+            return new Response(JSON.stringify({ error: 'Invalid signature' }), {
+                status: 401,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        let match = true;
+        for (let i = 0; i < expectedSig.length; i++) {
+            if (providedSig[i] !== expectedSig[i])
+                match = false;
+        }
+        if (!match) {
+            return new Response(JSON.stringify({ error: 'Invalid signature' }), {
+                status: 401,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        let event;
+        try {
+            event = JSON.parse(body);
+        }
+        catch {
+            event = body;
+        }
+        return handler(event, request);
+    }
+    return webhookHandler;
+}
+export function cookies() {
+    const req = getRequest();
+    let jar = {};
+    if (req && req.cookies) {
+        jar = { ...req.cookies };
+    }
+    else if (typeof document !== 'undefined') {
+        for (const pair of document.cookie.split(';')) {
+            const eq = pair.indexOf('=');
+            if (eq === -1)
+                continue;
+            const k = pair.slice(0, eq).trim();
+            const v = pair.slice(eq + 1).trim();
+            if (k)
+                jar[k] = decodeURIComponent(v);
+        }
+    }
+    return new Proxy(jar, {
+        get(target, prop) {
+            if (prop === 'get')
+                return (name) => target[name] || undefined;
+            if (prop === 'getAll')
+                return () => Object.entries(target).map(([name, value]) => ({ name, value }));
+            if (prop === 'toString')
+                return () => Object.entries(target).map(([k, v]) => `${k}=${v}`).join('; ');
+            if (prop in target)
+                return target[prop];
+            return undefined;
+        },
+    });
+}
+export function locals() {
+    const req = getRequest();
+    if (req && req.locals)
+        return req.locals;
+    return {};
+}
+export function headers() {
+    const req = getRequest();
+    const map = new Map();
+    if (req && req.headers) {
+        for (const [k, v] of Object.entries(req.headers)) {
+            map.set(k.toLowerCase(), Array.isArray(v) ? v.join(', ') : String(v));
+        }
+    }
+    return new Proxy({}, {
+        get(_target, prop) {
+            if (prop === 'get')
+                return (name) => map.get(name.toLowerCase()) || null;
+            if (prop === 'has')
+                return (name) => map.has(name.toLowerCase());
+            if (prop === 'entries')
+                return () => map.entries();
+            if (typeof prop === 'string')
+                return map.get(prop.toLowerCase()) ?? undefined;
+            return undefined;
+        },
+        ownKeys() {
+            return [...map.keys()];
+        },
+        getOwnPropertyDescriptor() {
+            return { enumerable: true, configurable: true };
+        },
+    });
+}
+export class ServerRequest extends Request {
+    _cookies;
+    _params;
+    _locals;
+    constructor(input, init) {
+        super(input, init);
+        this._cookies = {};
+        this._params = {};
+        this._locals = {};
+    }
+    get cookies() {
+        const target = this._cookies;
+        return new Proxy(target, {
+            get(t, prop) {
+                if (prop === 'get')
+                    return (name) => t[name] || undefined;
+                if (prop === 'getAll')
+                    return () => Object.entries(t).map(([name, value]) => ({ name, value }));
+                if (prop === 'toString')
+                    return () => Object.entries(t).map(([k, v]) => `${k}=${v}`).join('; ');
+                if (prop in t)
+                    return t[prop];
+                return undefined;
+            },
+        });
+    }
+    set cookies(v) { this._cookies = v; }
+    get params() { return this._params; }
+    set params(v) { this._params = v; }
+    get locals() { return this._locals; }
+    set locals(v) { this._locals = v; }
+}
+export class ServerResponse extends Response {
+    static json(body, init) {
+        return new ServerResponse(JSON.stringify(body), {
+            ...init,
+            headers: { 'Content-Type': 'application/json', ...init?.headers },
+        });
+    }
+    static redirect(url, status = 307) {
+        return new ServerResponse(null, {
+            status,
+            headers: { Location: url },
+        });
+    }
+    static rewrite(url) {
+        return new ServerResponse(null, {
+            status: 200,
+            headers: { 'x-vesk-rewrite': url },
+        });
+    }
+    static next() {
+        return new ServerResponse(null, {
+            status: 200,
+            headers: { 'x-vesk-next': '1' },
+        });
+    }
+}
+export class VeskRequest extends ServerRequest {
+    _query;
+    _ip;
+    _protocol;
+    _hostname;
+    _body;
+    _bodyPromise;
+    _parsedUrl;
+    __security;
+    constructor(input, init) {
+        super(input, init);
+        this._query = null;
+        this._ip = null;
+        this._protocol = null;
+        this._hostname = null;
+        this._body = null;
+        this._bodyPromise = null;
+        this._parsedUrl = null;
+        Object.defineProperty(this, 'body', {
+            get: () => {
+                if (!this._bodyPromise) {
+                    this._bodyPromise = this._parseBody();
+                }
+                return this._bodyPromise;
+            },
+            configurable: true,
+            enumerable: true,
+        });
+    }
+    get parsedUrl() {
+        if (!this._parsedUrl) {
+            this._parsedUrl = new URL(this.url);
+        }
+        return this._parsedUrl;
+    }
+    get query() {
+        if (!this._query) {
+            const params = {};
+            for (const [k, v] of this.parsedUrl.searchParams) {
+                params[k] = v;
+            }
+            this._query = params;
+        }
+        return this._query;
+    }
+    set query(v) { this._query = v; }
+    get ip() {
+        if (!this._ip) {
+            const fwd = this.headers?.get('x-forwarded-for');
+            if (fwd)
+                this._ip = fwd.split(',')[0].trim();
+            else
+                this._ip = 'unknown';
+        }
+        return this._ip;
+    }
+    set ip(v) { this._ip = v; }
+    get protocol() {
+        if (!this._protocol) {
+            const proto = this.headers?.get('x-forwarded-proto');
+            this._protocol = proto ? proto.split(',')[0].trim() : 'http';
+        }
+        return this._protocol;
+    }
+    set protocol(v) { this._protocol = v; }
+    get hostname() {
+        if (!this._hostname) {
+            this._hostname = this.headers?.get('host')?.split(':')[0] || 'localhost';
+        }
+        return this._hostname;
+    }
+    set hostname(v) { this._hostname = v; }
+    async _parseBody() {
+        const ct = this.headers?.get('content-type') || '';
+        if (ct.includes('json')) {
+            return await this.json();
+        }
+        else if (ct.includes('form')) {
+            const fd = await this.formData();
+            return Object.fromEntries(fd.entries());
+        }
+        else {
+            const text = await this.text();
+            try {
+                return JSON.parse(text);
+            }
+            catch {
+                return text;
+            }
+        }
+    }
+    get _security() {
+        if (!this.__security)
+            this.__security = {};
+        return this.__security;
+    }
+    setCsp(policy) {
+        this._security.contentSecurityPolicy = policy;
+    }
+    setRateLimit(options) {
+        this._security.rateLimit = options;
+    }
+    setCsrf(enable) {
+        this._security.csrf = enable;
+    }
+    setSecurityHeader(name, value) {
+        if (!this._security.customHeaders)
+            this._security.customHeaders = {};
+        this._security.customHeaders[name] = value;
+    }
+    setTrustProxy(enable) {
+        this._security.trustProxy = enable;
+    }
+    getSecurityOverrides() {
+        return this._security;
+    }
+}
+class _VeskResponse extends ServerResponse {
+    _cookieHeaders;
+    _secHeaders;
+    _finalStatus;
+    constructor(body, init) {
+        super(body, init);
+        this._cookieHeaders = [];
+        this._secHeaders = {};
+        this._finalStatus = null;
+    }
+    setStatus(code) {
+        this._finalStatus = code;
+        return this;
+    }
+    get status() {
+        return this._finalStatus !== null ? this._finalStatus : super.status;
+    }
+    build() {
+        this._flushSecurityHeaders();
+        return this;
+    }
+    async text() {
+        this._flushSecurityHeaders();
+        return super.text();
+    }
+    async json() {
+        this._flushSecurityHeaders();
+        return super.json();
+    }
+    setCookie(name, value, opts = {}) {
+        const parts = [`${name}=${encodeURIComponent(value)}`];
+        if (opts.httpOnly !== false)
+            parts.push('HttpOnly');
+        if (opts.secure !== false)
+            parts.push('Secure');
+        parts.push('SameSite=' + (opts.sameSite || 'Lax'));
+        parts.push('Path=' + (opts.path || '/'));
+        if (opts.maxAge !== undefined)
+            parts.push('Max-Age=' + opts.maxAge);
+        if (opts.domain)
+            parts.push('Domain=' + opts.domain);
+        this._cookieHeaders.push(parts.join('; '));
+        return this;
+    }
+    clearCookie(name, opts = {}) {
+        return this.setCookie(name, '', { ...opts, maxAge: 0 });
+    }
+    setCsp(policy) {
+        this._secHeaders['Content-Security-Policy'] = policy === false ? null : policy;
+        return this;
+    }
+    setSecurityHeader(name, value) {
+        this._secHeaders[name] = value === false ? null : value;
+        return this;
+    }
+    cache(ttlSeconds) {
+        this.headers?.set('Cache-Control', `public, max-age=${ttlSeconds}, s-maxage=${ttlSeconds}`);
+        return this;
+    }
+    noCache() {
+        this.headers?.set('Cache-Control', 'no-store, no-cache, must-revalidate, proxy-revalidate');
+        this.headers?.set('Pragma', 'no-cache');
+        this.headers?.set('Expires', '0');
+        return this;
+    }
+    cors(opts = {}) {
+        this.headers?.set('Access-Control-Allow-Origin', opts.origin || '*');
+        if (opts.methods)
+            this.headers?.set('Access-Control-Allow-Methods', opts.methods);
+        if (opts.headers)
+            this.headers?.set('Access-Control-Allow-Headers', opts.headers);
+        if (opts.credentials !== false)
+            this.headers?.set('Access-Control-Allow-Credentials', 'true');
+        return this;
+    }
+    _flushSecurityHeaders() {
+        for (const [name, value] of Object.entries(this._secHeaders)) {
+            if (value === null)
+                continue;
+            const existing = this.headers?.get(name);
+            if (!existing)
+                this.headers?.set(name, value);
+        }
+        this._secHeaders = {};
+        if (this._cookieHeaders.length > 0) {
+            const existing = this.headers?.get('Set-Cookie');
+            if (existing) {
+                this.headers?.set('Set-Cookie', existing + ', ' + this._cookieHeaders.join(', '));
+            }
+            else {
+                this.headers?.set('Set-Cookie', this._cookieHeaders.join(', '));
+            }
+        }
+        this._cookieHeaders = [];
+    }
+    static json(body, init) {
+        return new _VeskResponse(JSON.stringify(body), {
+            ...init,
+            headers: { 'Content-Type': 'application/json', ...init?.headers },
+        });
+    }
+    static redirect(url, status = 307) {
+        return new _VeskResponse(null, { status, headers: { Location: url } });
+    }
+    static rewrite(url) {
+        return new _VeskResponse(null, { status: 200, headers: { 'x-vesk-rewrite': url } });
+    }
+    static next() {
+        return new _VeskResponse(null, { status: 200, headers: { 'x-vesk-next': '1' } });
+    }
+    static html(html, init) {
+        return new _VeskResponse(html, {
+            ...init,
+            headers: { 'Content-Type': 'text/html; charset=utf-8', ...init?.headers },
+        });
+    }
+}
+export const VeskResponse = new Proxy(_VeskResponse, {
+    apply(target, _thisArg, args) {
+        return new target(...args);
+    }
+});
+export function applyRequestSecurity(request, response) {
+    if (!request || !response)
+        return;
+    const overrides = request.getSecurityOverrides?.() || {};
+    if (overrides.contentSecurityPolicy !== undefined) {
+        response.setCsp(overrides.contentSecurityPolicy);
+    }
+    if (overrides.customHeaders) {
+        for (const [name, value] of Object.entries(overrides.customHeaders)) {
+            response.setSecurityHeader(name, value);
+        }
+    }
+    response._flushSecurityHeaders();
+}
+export async function withValidation(request, schema, opts = {}) {
+    let data;
+    const contentType = request.headers.get('content-type') || '';
+    try {
+        if (contentType.includes('json')) {
+            data = await request.json();
+        }
+        else if (!opts.jsonOnly) {
+            const formData = await request.formData();
+            if (formData && typeof formData === 'object') {
+                data = Object.fromEntries([...formData.entries()].map(([k, v]) => [k, v]));
+            }
+            else {
+                data = await request.text().then(t => t ? JSON.parse(t) : {});
+            }
+        }
+        else {
+            data = await request.json();
+        }
+        const result = schema.safeParse(data);
+        if (!result.success) {
+            return ServerResponse.json({
+                error: 'Validation failed',
+                issues: result.error.issues.map(i => ({
+                    path: i.path.join('.'),
+                    message: i.message,
+                })),
+            }, { status: 400 });
+        }
+        return result.data;
+    }
+    catch (e) {
+        return ServerResponse.json({
+            error: 'Invalid request body',
+            details: e.message,
+        }, { status: 400 });
+    }
+}
+let _signImpl = null;
+async function _getImpl() {
+    if (_signImpl)
+        return _signImpl;
+    try {
+        _signImpl = await import('@vesk/compiler/src/server-utils');
+    }
+    catch {
+        try {
+            const mod = await import('@vesk/compiler');
+            _signImpl = mod;
+        }
+        catch {
+            _signImpl = { signCookie: null, unsignCookie: null, setSignedCookie: null, readSignedCookie: null };
+        }
+    }
+    return _signImpl;
+}
+export async function signCookie(name, value, host) {
+    const impl = await _getImpl();
+    if (impl.signCookie)
+        return impl.signCookie(name, value, host);
+    throw new Error('signCookie: @vesk/compiler not available');
+}
+export async function unsignCookie(name, signedValue, host) {
+    const impl = await _getImpl();
+    if (impl.unsignCookie)
+        return impl.unsignCookie(name, signedValue, host);
+    throw new Error('unsignCookie: @vesk/compiler not available');
+}
+export async function setSignedCookie(name, value, options = {}, host) {
+    const impl = await _getImpl();
+    if (impl.setSignedCookie)
+        return impl.setSignedCookie(name, value, options, host);
+    throw new Error('setSignedCookie: @vesk/compiler not available');
+}
+export async function readSignedCookie(name, cookieString, host) {
+    const impl = await _getImpl();
+    if (impl.readSignedCookie)
+        return impl.readSignedCookie(name, cookieString, host);
+    throw new Error('readSignedCookie: @vesk/compiler not available');
+}

package/dist/resource.d.ts

@@ -0,0 +1,47 @@
+import type { Tracked } from '@vesk/runtime/src/ripple-runtime';
+export interface Resource<T> extends PromiseLike<T> {
+    loading: boolean;
+    error: unknown;
+    data: T | undefined;
+    _state?: Tracked;
+    refresh: () => void;
+    abort: () => void;
+}
+export interface UseFetchOptions<T> extends Omit<RequestInit, 'body'> {
+    key?: string;
+    into?: Tracked;
+    body?: unknown;
+    staleTime?: number;
+    keepPreviousData?: boolean;
+    retry?: number;
+    retryDelay?: number;
+    timeout?: number;
+    enabled?: boolean;
+    dedupe?: boolean;
+}
+export declare class HttpError extends Error {
+    status: number;
+    constructor(status: number, statusText: string);
+}
+export declare class TimeoutError extends Error {
+    constructor(timeout: number);
+}
+export interface SsrDataSink {
+    set(key: string, value: unknown): void;
+    get(key: string): unknown | undefined;
+    snapshot(): Record<string, unknown>;
+    clear(): void;
+}
+export declare function setSsrSink(sink: SsrDataSink | null): void;
+export declare function setSsrData(key: string, value: unknown): void;
+export declare function clearSsrData(): void;
+export declare function mutate(key: string, data?: unknown): void;
+export declare function createResource<T>(fn: () => Promise<T>, key?: string, into?: Tracked, options?: UseFetchOptions<T>): Resource<T>;
+export declare function useFetch<T = unknown>(urlOrFn: string | (() => Promise<T>), options?: UseFetchOptions<T>): Resource<T>;
+export declare namespace useFetch {
+    var text: <T = string>(url: string, options?: Omit<UseFetchOptions<T>, "body">) => Resource<T>;
+    var json: <T = unknown>(url: string, options?: Omit<UseFetchOptions<T>, "body">) => Resource<T>;
+    var arrayBuffer: <T = ArrayBuffer>(url: string, options?: Omit<UseFetchOptions<T>, "body">) => Resource<T>;
+}
+export declare function resolveSsrResources(): Promise<Record<string, unknown>>;
+//# sourceMappingURL=resource.d.ts.map

package/dist/resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../src/resource.ts"],"names":[],"mappings":"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"}