gorsee 0.2.3 → 0.2.5

package/dist-pkg/runtime/suspense.js

@@ -0,0 +1,16 @@
+import { createSignal } from "../reactive/signal.js";
+export function Suspense(props) {
+  const children = props.children;
+  if (typeof children === "function") {
+    const asyncFn = children, [resolved, setResolved] = createSignal(null), [pending, setPending] = createSignal(!0);
+    asyncFn().then((result) => {
+      setResolved(result);
+      setPending(!1);
+    }).catch((err) => {
+      setResolved(err instanceof Error ? err.message : String(err));
+      setPending(!1);
+    });
+    return () => pending() ? props.fallback : resolved();
+  }
+  return children;
+}

package/dist-pkg/runtime/typed-routes.d.ts

@@ -0,0 +1,24 @@
+export type TypedRouteParams = Record<string, string | undefined>;
+export type TypedRouteSearchValue = string | number | boolean | null | undefined | Array<string | number | boolean>;
+export interface TypedRouteOptions {
+    params?: TypedRouteParams;
+    search?: Record<string, TypedRouteSearchValue>;
+    hash?: string;
+}
+export interface TypedRouteDefinition {
+    path: string;
+    params(): string[];
+    build(options?: TypedRouteParams | TypedRouteOptions): string;
+    buildStrict(options: TypedRouteOptions): string;
+    navigate(options?: TypedRouteParams | TypedRouteOptions): Promise<void>;
+    prefetch(options?: TypedRouteParams | TypedRouteOptions): Promise<void>;
+}
+export type TypedRouteTarget = string | TypedRouteDefinition;
+export declare function extractRouteParamKeys(path: string): string[];
+export declare function buildSearchParams(search?: Record<string, TypedRouteSearchValue>): string;
+export declare function buildTypedPath(path: string, params?: TypedRouteParams, strict?: boolean): string;
+export declare function typedLink(target: TypedRouteTarget, paramsOrOptions?: TypedRouteParams | TypedRouteOptions): string;
+export declare function resolveTypedRouteTarget(target: TypedRouteTarget, paramsOrOptions?: TypedRouteParams | TypedRouteOptions): string;
+export declare function createTypedRoute(path: string): TypedRouteDefinition;
+export declare function typedNavigate(target: TypedRouteTarget, paramsOrOptions?: TypedRouteParams | TypedRouteOptions): Promise<void>;
+export declare function typedPrefetch(target: TypedRouteTarget, paramsOrOptions?: TypedRouteParams | TypedRouteOptions): Promise<void>;

package/dist-pkg/runtime/typed-routes.js

@@ -0,0 +1,77 @@
+function isTypedRouteOptions(value) {
+  return "params" in value || "search" in value || "hash" in value;
+}
+function isTypedRouteDefinition(value) {
+  return typeof value !== "string" && typeof value.build === "function" && typeof value.path === "string";
+}
+export function extractRouteParamKeys(path) {
+  return [...path.matchAll(/\[\.\.\.(\w+)\]|\[(\w+)\]/g)].map((match) => match[1] ?? match[2]).filter(Boolean);
+}
+export function buildSearchParams(search = {}) {
+  const params = new URLSearchParams;
+  for (const [key, value] of Object.entries(search)) {
+    if (value === void 0 || value === null)
+      continue;
+    if (Array.isArray(value)) {
+      for (const item of value)
+        params.append(key, String(item));
+      continue;
+    }
+    params.set(key, String(value));
+  }
+  const query = params.toString();
+  return query ? `?${query}` : "";
+}
+export function buildTypedPath(path, params = {}, strict = !1) {
+  return path.replace(/\[\.\.\.(\w+)\]/g, (_, key) => {
+    const value = params[key];
+    if (strict && !value)
+      throw Error(`Missing route param: ${key}`);
+    return value ?? "";
+  }).replace(/\[(\w+)\]/g, (_, key) => {
+    const value = params[key];
+    if (strict && !value)
+      throw Error(`Missing route param: ${key}`);
+    return encodeURIComponent(value ?? "");
+  });
+}
+export function typedLink(target, paramsOrOptions = {}) {
+  if (isTypedRouteDefinition(target))
+    return target.build(paramsOrOptions);
+  const options = isTypedRouteOptions(paramsOrOptions) ? paramsOrOptions : { params: paramsOrOptions }, pathname = buildTypedPath(target, options.params ?? {}), search = buildSearchParams(options.search), hash = options.hash ? `#${options.hash.replace(/^#/, "")}` : "";
+  return `${pathname}${search}${hash}`;
+}
+export function resolveTypedRouteTarget(target, paramsOrOptions = {}) {
+  return typedLink(target, paramsOrOptions);
+}
+export function createTypedRoute(path) {
+  return {
+    path,
+    params() {
+      return extractRouteParamKeys(path);
+    },
+    build(options = {}) {
+      return typedLink(path, options);
+    },
+    buildStrict(options) {
+      const pathname = buildTypedPath(path, options.params ?? {}, !0), search = buildSearchParams(options.search), hash = options.hash ? `#${options.hash.replace(/^#/, "")}` : "";
+      return `${pathname}${search}${hash}`;
+    },
+    navigate(options = {}) {
+      return typedNavigate(path, options);
+    },
+    prefetch(options = {}) {
+      return typedPrefetch(path, options);
+    }
+  };
+}
+export function typedNavigate(target, paramsOrOptions = {}) {
+  const url = typedLink(target, paramsOrOptions);
+  return import("./router.js").then((m) => m.navigate(url));
+}
+export function typedPrefetch(target, paramsOrOptions = {}) {
+  const url = typedLink(target, paramsOrOptions);
+  return import("./router.js").then((m) => {
+    m.prefetch(url);
+  });
+}

package/dist-pkg/runtime/validated-form.d.ts

@@ -0,0 +1,40 @@
+export type FormFieldKind = "string" | "number" | "boolean" | "json";
+export interface FieldRule<T = unknown> {
+    required?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: RegExp;
+    min?: number;
+    max?: number;
+    custom?: (value: T, data: Record<string, unknown>) => string | null;
+}
+export interface FormField<TName extends string = string, TValue = string> {
+    name: TName;
+    rules: FieldRule<TValue>;
+    label?: string;
+    kind?: FormFieldKind;
+    coerce?: (value: string | undefined) => TValue;
+}
+export interface FormSchema<TData extends Record<string, unknown> = Record<string, unknown>> {
+    fields: FormField[];
+    formRules?: Array<(data: Partial<TData>) => ValidationError | null>;
+}
+export interface ValidationError {
+    field: string;
+    message: string;
+}
+export interface ValidationResult<T> {
+    valid: boolean;
+    data: T | null;
+    errors: ValidationError[];
+    fieldErrors: Record<string, string[]>;
+    formErrors: string[];
+}
+export interface ActionValidationResult<T> extends ValidationResult<T> {
+    values: Record<string, string>;
+}
+export declare function defineForm<TData extends Record<string, unknown> = Record<string, unknown>>(fields: FormField[], options?: Pick<FormSchema<TData>, "formRules">): FormSchema<TData>;
+export declare function toFieldErrors(errors: ValidationError[]): Record<string, string[]>;
+export declare function validateForm<T extends Record<string, unknown>>(data: Record<string, string>, schema: FormSchema<T>): ValidationResult<T>;
+export declare function validateAction<T extends Record<string, unknown>>(request: Request, schema: FormSchema<T>): Promise<ActionValidationResult<T>>;
+export declare function fieldAttrs(field: FormField): Record<string, unknown>;

package/dist-pkg/runtime/validated-form.js

@@ -0,0 +1,120 @@
+export function defineForm(fields, options = {}) {
+  return { fields, formRules: options.formRules ?? [] };
+}
+function coerceFieldValue(field, value) {
+  if (field.coerce)
+    return field.coerce(value);
+  const raw = value ?? "";
+  switch (field.kind ?? (field.rules.min !== void 0 || field.rules.max !== void 0 ? "number" : void 0)) {
+    case "number":
+      return raw === "" ? void 0 : Number(raw);
+    case "boolean":
+      return raw === "true" || raw === "on" || raw === "1";
+    case "json":
+      return raw === "" ? void 0 : JSON.parse(raw);
+    default:
+      return raw;
+  }
+}
+function validateField(rawValue, field, data) {
+  const { rules, label } = field, name = label ?? field.name, raw = rawValue ?? "";
+  if (rules.required && !raw.trim())
+    return { field: field.name, message: `${name} is required` };
+  if (!raw && !rules.required)
+    return null;
+  if (rules.minLength !== void 0 && raw.length < rules.minLength)
+    return { field: field.name, message: `${name} must be at least ${rules.minLength} characters` };
+  if (rules.maxLength !== void 0 && raw.length > rules.maxLength)
+    return { field: field.name, message: `${name} must be at most ${rules.maxLength} characters` };
+  if (rules.pattern && !rules.pattern.test(raw))
+    return { field: field.name, message: `${name} format is invalid` };
+  const coerced = coerceFieldValue(field, rawValue);
+  if (rules.min !== void 0 && typeof coerced === "number" && coerced < rules.min)
+    return { field: field.name, message: `${name} must be at least ${rules.min}` };
+  if (rules.max !== void 0 && typeof coerced === "number" && coerced > rules.max)
+    return { field: field.name, message: `${name} must be at most ${rules.max}` };
+  if (rules.custom) {
+    const message = rules.custom(coerced, data);
+    if (message)
+      return { field: field.name, message };
+  }
+  return null;
+}
+export function toFieldErrors(errors) {
+  const grouped = {};
+  for (const error of errors) {
+    const key = error.field || "$form";
+    grouped[key] ??= [];
+    grouped[key].push(error.message);
+  }
+  return grouped;
+}
+export function validateForm(data, schema) {
+  const errors = [], coercedData = {};
+  for (const field of schema.fields) {
+    const raw = data[field.name], error = validateField(raw, field, coercedData);
+    if (error) {
+      errors.push(error);
+      continue;
+    }
+    const coerced = coerceFieldValue(field, raw);
+    if (coerced !== void 0)
+      coercedData[field.name] = coerced;
+    else if (raw !== void 0 && field.kind === void 0 && field.rules.min === void 0 && field.rules.max === void 0)
+      coercedData[field.name] = raw;
+  }
+  if (errors.length === 0)
+    for (const rule of schema.formRules ?? []) {
+      const error = rule(coercedData);
+      if (error)
+        errors.push(error);
+    }
+  const fieldErrors = toFieldErrors(errors.filter((error) => error.field !== "$form")), formErrors = errors.filter((error) => error.field === "$form").map((error) => error.message);
+  return {
+    valid: errors.length === 0,
+    data: errors.length === 0 ? coercedData : null,
+    errors,
+    fieldErrors,
+    formErrors
+  };
+}
+function normalizeInput(input) {
+  if (input instanceof FormData) {
+    const data = {};
+    input.forEach((value, key) => {
+      data[key] = String(value);
+    });
+    return data;
+  }
+  return input;
+}
+export async function validateAction(request, schema) {
+  const contentType = request.headers.get("content-type") ?? "";
+  let data;
+  if (contentType.includes("application/json")) {
+    const json = await request.json();
+    data = Object.fromEntries(Object.entries(json).map(([key, value]) => [key, String(value ?? "")]));
+  } else
+    data = normalizeInput(await request.formData());
+  return { ...validateForm(data, schema), values: data };
+}
+export function fieldAttrs(field) {
+  const attrs = { name: field.name };
+  if (field.rules.required)
+    attrs.required = !0;
+  if (field.rules.minLength !== void 0)
+    attrs.minlength = field.rules.minLength;
+  if (field.rules.maxLength !== void 0)
+    attrs.maxlength = field.rules.maxLength;
+  if (field.rules.pattern)
+    attrs.pattern = field.rules.pattern.source;
+  if (field.rules.min !== void 0)
+    attrs.min = field.rules.min;
+  if (field.rules.max !== void 0)
+    attrs.max = field.rules.max;
+  if (field.kind === "number" || field.rules.min !== void 0 || field.rules.max !== void 0)
+    attrs.inputmode = "numeric";
+  if (field.kind === "boolean")
+    attrs.value = "true";
+  return attrs;
+}

package/dist-pkg/security/cors.d.ts

@@ -0,0 +1,10 @@
+import type { MiddlewareFn } from "../server/middleware.js";
+export interface CORSOptions {
+    origin?: string | string[] | ((origin: string) => boolean);
+    methods?: string[];
+    allowHeaders?: string[];
+    exposeHeaders?: string[];
+    credentials?: boolean;
+    maxAge?: number;
+}
+export declare function cors(options?: CORSOptions): MiddlewareFn;

package/dist-pkg/security/cors.js

@@ -0,0 +1,56 @@
+const DEFAULT_METHODS = ["GET", "HEAD", "PUT", "PATCH", "POST", "DELETE"], DEFAULT_HEADERS = ["Content-Type", "Authorization", "X-Requested-With"];
+function isOriginAllowed(origin, allowed) {
+  if (!allowed)
+    return !1;
+  if (allowed === "*")
+    return !0;
+  if (typeof allowed === "string")
+    return origin === allowed;
+  if (Array.isArray(allowed))
+    return allowed.includes(origin);
+  if (typeof allowed === "function")
+    return allowed(origin);
+  return !1;
+}
+export function cors(options = {}) {
+  const {
+    origin = "*",
+    methods = DEFAULT_METHODS,
+    allowHeaders = DEFAULT_HEADERS,
+    exposeHeaders = [],
+    credentials = !1,
+    maxAge = 86400
+  } = options;
+  return async (ctx, next) => {
+    const requestOrigin = ctx.request.headers.get("origin") ?? "";
+    if (ctx.request.method === "OPTIONS") {
+      const headers = new Headers;
+      if (origin === "*" && !credentials)
+        headers.set("Access-Control-Allow-Origin", "*");
+      else if (isOriginAllowed(requestOrigin, origin)) {
+        headers.set("Access-Control-Allow-Origin", requestOrigin);
+        headers.set("Vary", "Origin");
+      }
+      headers.set("Access-Control-Allow-Methods", methods.join(", "));
+      headers.set("Access-Control-Allow-Headers", allowHeaders.join(", "));
+      if (exposeHeaders.length > 0)
+        headers.set("Access-Control-Expose-Headers", exposeHeaders.join(", "));
+      if (credentials)
+        headers.set("Access-Control-Allow-Credentials", "true");
+      headers.set("Access-Control-Max-Age", String(maxAge));
+      return new Response(null, { status: 204, headers });
+    }
+    const response = await next();
+    if (origin === "*" && !credentials)
+      response.headers.set("Access-Control-Allow-Origin", "*");
+    else if (isOriginAllowed(requestOrigin, origin)) {
+      response.headers.set("Access-Control-Allow-Origin", requestOrigin);
+      response.headers.append("Vary", "Origin");
+    }
+    if (credentials)
+      response.headers.set("Access-Control-Allow-Credentials", "true");
+    if (exposeHeaders.length > 0)
+      response.headers.set("Access-Control-Expose-Headers", exposeHeaders.join(", "));
+    return response;
+  };
+}

package/dist-pkg/security/csrf.d.ts

@@ -0,0 +1,9 @@
+import type { MiddlewareFn } from "../server/middleware.js";
+export declare function generateCSRFToken(): string;
+export declare function validateCSRFToken(request: Request, secret: string): Promise<boolean>;
+export declare function csrfProtection(secret: string): Promise<{
+    token: string;
+    cookie: string;
+    headerName: string;
+}>;
+export declare function createCSRFMiddleware(secret: string): MiddlewareFn;

package/dist-pkg/security/csrf.js

@@ -0,0 +1,53 @@
+import { timingSafeEqual } from "node:crypto";
+const CSRF_COOKIE = "__gorsee_csrf", CSRF_HEADER = "x-gorsee-csrf", TOKEN_LENGTH = 32;
+function randomBytes(length) {
+  const bytes = new Uint8Array(length);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function hmacSign(token, secret) {
+  const key = await crypto.subtle.importKey("raw", new TextEncoder().encode(secret), { name: "HMAC", hash: "SHA-256" }, !1, ["sign"]), sig = await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(token));
+  return Array.from(new Uint8Array(sig), (b) => b.toString(16).padStart(2, "0")).join("");
+}
+export function generateCSRFToken() {
+  return randomBytes(TOKEN_LENGTH);
+}
+export async function validateCSRFToken(request, secret) {
+  if (["GET", "HEAD", "OPTIONS"].includes(request.method))
+    return !0;
+  const cookieHeader = request.headers.get("cookie") ?? "", headerToken = request.headers.get(CSRF_HEADER) ?? "";
+  let cookieToken = "";
+  for (const pair of cookieHeader.split(";")) {
+    const [key, ...rest] = pair.trim().split("=");
+    if (key === CSRF_COOKIE) {
+      cookieToken = rest.join("=");
+      break;
+    }
+  }
+  if (!cookieToken || !headerToken)
+    return !1;
+  const [token, signature] = cookieToken.split(".");
+  if (!token || !signature)
+    return !1;
+  if (headerToken !== token)
+    return !1;
+  const expectedSig = await hmacSign(token, secret);
+  if (signature.length !== expectedSig.length)
+    return !1;
+  return timingSafeEqual(Buffer.from(signature), Buffer.from(expectedSig));
+}
+export async function csrfProtection(secret) {
+  const token = generateCSRFToken(), signature = await hmacSign(token, secret), cookieValue = `${token}.${signature}`;
+  return {
+    token,
+    cookie: `${CSRF_COOKIE}=${cookieValue}; Path=/; SameSite=Lax; Secure`,
+    headerName: CSRF_HEADER
+  };
+}
+export function createCSRFMiddleware(secret) {
+  return async (ctx, next) => {
+    if (!await validateCSRFToken(ctx.request, secret))
+      return new Response("Invalid CSRF token", { status: 403 });
+    return next();
+  };
+}

package/dist-pkg/security/headers.d.ts

@@ -0,0 +1,11 @@
+export interface SecurityConfig {
+    csp: boolean;
+    hsts: boolean;
+    csrf: boolean;
+    rateLimit: {
+        requests: number;
+        window: string;
+    } | false;
+    nonce?: string;
+}
+export declare function securityHeaders(config?: Partial<SecurityConfig>, nonce?: string): Record<string, string>;

package/dist-pkg/security/headers.js

@@ -0,0 +1,31 @@
+const DEFAULT_CONFIG = {
+  csp: !0,
+  hsts: !0,
+  csrf: !0,
+  rateLimit: { requests: 100, window: "1m" }
+};
+export function securityHeaders(config = {}, nonce) {
+  const cfg = { ...DEFAULT_CONFIG, ...config }, headers = {};
+  if (cfg.csp) {
+    const scriptSrc = nonce ? `'nonce-${nonce}'` : "'self'";
+    headers["Content-Security-Policy"] = [
+      "default-src 'self'",
+      `script-src ${scriptSrc}`,
+      "style-src 'self' 'unsafe-inline'",
+      "img-src 'self' data: https:",
+      "font-src 'self'",
+      "connect-src 'self' ws: wss:",
+      "frame-ancestors 'none'",
+      "base-uri 'self'",
+      "form-action 'self'"
+    ].join("; ");
+  }
+  if (cfg.hsts)
+    headers["Strict-Transport-Security"] = "max-age=31536000; includeSubDomains; preload";
+  headers["X-Content-Type-Options"] = "nosniff";
+  headers["X-Frame-Options"] = "DENY";
+  headers["Referrer-Policy"] = "strict-origin-when-cross-origin";
+  headers["X-XSS-Protection"] = "0";
+  headers["Permissions-Policy"] = "camera=(), microphone=(), geolocation=()";
+  return headers;
+}

package/dist-pkg/security/index.d.ts

@@ -0,0 +1,5 @@
+export { securityHeaders, type SecurityConfig } from "./headers.js";
+export { csrfProtection, createCSRFMiddleware, generateCSRFToken, validateCSRFToken } from "./csrf.js";
+export { createRateLimiter, parseRateLimitWindow, type RateLimiter } from "./rate-limit.js";
+export { createRedisRateLimiter, type AsyncRateLimiter, type AsyncRateLimitResult } from "./redis-rate-limit.js";
+export { cors, type CORSOptions } from "./cors.js";

package/dist-pkg/security/index.js

@@ -0,0 +1,5 @@
+export { securityHeaders } from "./headers.js";
+export { csrfProtection, createCSRFMiddleware, generateCSRFToken, validateCSRFToken } from "./csrf.js";
+export { createRateLimiter, parseRateLimitWindow } from "./rate-limit.js";
+export { createRedisRateLimiter } from "./redis-rate-limit.js";
+export { cors } from "./cors.js";

package/dist-pkg/security/rate-limit.d.ts

@@ -0,0 +1,10 @@
+export interface RateLimiter {
+    check(key: string): {
+        allowed: boolean;
+        remaining: number;
+        resetAt: number;
+    };
+    reset(key: string): void;
+}
+export declare function parseRateLimitWindow(window: string): number;
+export declare function createRateLimiter(maxRequests: number, window: string): RateLimiter;

package/dist-pkg/security/rate-limit.js

@@ -0,0 +1,49 @@
+export function parseRateLimitWindow(window) {
+  const match = window.match(/^(\d+)(s|m|h)$/);
+  if (!match)
+    throw Error(`Invalid rate limit window: "${window}"`);
+  const value = Number(match[1]);
+  switch (match[2]) {
+    case "s":
+      return value * 1000;
+    case "m":
+      return value * 60000;
+    case "h":
+      return value * 3600000;
+    default:
+      throw Error(`Invalid unit: ${match[2]}`);
+  }
+}
+export function createRateLimiter(maxRequests, window) {
+  const windowMs = parseRateLimitWindow(window), buckets = new Map, CLEANUP_INTERVAL = Math.max(windowMs * 2, 60000), cleanup = setInterval(() => {
+    const now = Date.now();
+    for (const [key, bucket] of buckets)
+      if (now - bucket.lastRefill > windowMs * 2)
+        buckets.delete(key);
+  }, CLEANUP_INTERVAL);
+  if (typeof cleanup === "object" && "unref" in cleanup)
+    cleanup.unref();
+  return {
+    check(key) {
+      const now = Date.now();
+      let bucket = buckets.get(key);
+      if (!bucket) {
+        bucket = { tokens: maxRequests, lastRefill: now };
+        buckets.set(key, bucket);
+      }
+      if (now - bucket.lastRefill >= windowMs) {
+        bucket.tokens = maxRequests;
+        bucket.lastRefill = now;
+      }
+      const resetAt = bucket.lastRefill + windowMs;
+      if (bucket.tokens > 0) {
+        bucket.tokens--;
+        return { allowed: !0, remaining: bucket.tokens, resetAt };
+      }
+      return { allowed: !1, remaining: 0, resetAt };
+    },
+    reset(key) {
+      buckets.delete(key);
+    }
+  };
+}

package/dist-pkg/security/redis-rate-limit.d.ts

@@ -0,0 +1,14 @@
+import { type RedisLikeClient } from "../server/redis-client.js";
+export interface AsyncRateLimitResult {
+    allowed: boolean;
+    remaining: number;
+    resetAt: number;
+}
+export interface AsyncRateLimiter {
+    check(key: string): Promise<AsyncRateLimitResult>;
+    reset(key: string): Promise<void>;
+}
+export interface RedisRateLimiterOptions {
+    prefix?: string;
+}
+export declare function createRedisRateLimiter(client: RedisLikeClient, maxRequests: number, window: string, options?: RedisRateLimiterOptions): AsyncRateLimiter;

package/dist-pkg/security/redis-rate-limit.js

@@ -0,0 +1,23 @@
+import { buildRedisKey } from "../server/redis-client.js";
+import { parseRateLimitWindow } from "./rate-limit.js";
+export function createRedisRateLimiter(client, maxRequests, window, options = {}) {
+  if (!client.incr || !client.expire)
+    throw Error("Redis rate limiter requires incr() and expire() support on the Redis client.");
+  const prefix = options.prefix ?? "gorsee:rate-limit", windowMs = parseRateLimitWindow(window);
+  return {
+    async check(key) {
+      const redisKey = buildRedisKey(prefix, key), now = Date.now(), count = await client.incr(redisKey);
+      if (count === 1)
+        await client.expire(redisKey, Math.max(1, Math.ceil(windowMs / 1000)));
+      const ttlMs = client.pttl ? Math.max(0, await client.pttl(redisKey)) : windowMs;
+      return {
+        allowed: count <= maxRequests,
+        remaining: Math.max(0, maxRequests - count),
+        resetAt: now + ttlMs
+      };
+    },
+    async reset(key) {
+      await client.del(buildRedisKey(prefix, key));
+    }
+  };
+}

package/dist-pkg/server/action.d.ts

@@ -0,0 +1,21 @@
+import type { Context } from "./middleware.js";
+export interface ActionResult<T = unknown> {
+    ok: boolean;
+    status: number;
+    data?: T;
+    error?: string;
+    fieldErrors?: Record<string, string[]>;
+    formErrors?: string[];
+    values?: Record<string, string>;
+}
+export type ActionReturn<T = unknown> = T | Response | ActionResult<T>;
+export type ActionFn<T = unknown> = (ctx: Context) => Promise<ActionReturn<T>>;
+export declare function actionSuccess<T>(data?: T, init?: Omit<Partial<ActionResult<T>>, "ok" | "data"> & {
+    status?: number;
+}): ActionResult<T>;
+export declare function actionFailure<T = never>(error: string, init?: Omit<Partial<ActionResult<T>>, "ok" | "error"> & {
+    status?: number;
+}): ActionResult<T>;
+export declare function defineAction<T = unknown>(fn: ActionFn<T>): ActionFn<T>;
+export declare function handleAction<T>(actionFn: ActionFn<T>, ctx: Context): Promise<ActionResult<T>>;
+export declare function parseFormData(request: Request): Promise<Record<string, string>>;

package/dist-pkg/server/action.js

@@ -0,0 +1,64 @@
+function isActionResult(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return !1;
+  if ("status" in value || "error" in value || "fieldErrors" in value || "formErrors" in value || "values" in value)
+    return !0;
+  return "ok" in value && value.ok === !1;
+}
+export function actionSuccess(data, init = {}) {
+  return {
+    ok: !0,
+    status: init.status ?? 200,
+    data,
+    error: init.error,
+    fieldErrors: init.fieldErrors,
+    formErrors: init.formErrors,
+    values: init.values
+  };
+}
+export function actionFailure(error, init = {}) {
+  return {
+    ok: !1,
+    status: init.status ?? 400,
+    data: init.data,
+    error,
+    fieldErrors: init.fieldErrors,
+    formErrors: init.formErrors,
+    values: init.values
+  };
+}
+function normalizeActionResult(result) {
+  const status = result.status ?? (result.ok === !1 || result.error ? 400 : 200);
+  return {
+    ok: result.ok ?? (status < 400 && !result.error),
+    status,
+    data: result.data,
+    error: result.error,
+    fieldErrors: result.fieldErrors,
+    formErrors: result.formErrors,
+    values: result.values
+  };
+}
+export function defineAction(fn) {
+  return fn;
+}
+export async function handleAction(actionFn, ctx) {
+  try {
+    const result = await actionFn(ctx);
+    if (result instanceof Response)
+      return { ok: result.ok, status: result.status };
+    if (isActionResult(result))
+      return normalizeActionResult(result);
+    return actionSuccess(result);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return actionFailure(message, { status: 500 });
+  }
+}
+export async function parseFormData(request) {
+  const formData = await request.formData(), result = {};
+  for (const [key, value] of formData.entries())
+    if (typeof value === "string")
+      result[key] = value;
+  return result;
+}

package/dist-pkg/server/cache-utils.d.ts

@@ -0,0 +1,2 @@
+import type { CacheStore } from "./cache.js";
+export declare function createNamespacedCacheStore(store: CacheStore, namespace: string): CacheStore;