rankrunners-cms 0.0.31 → 0.0.33

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rankrunners-cms",
   "type": "module",
-  "version": "0.0.31",
+  "version": "0.0.33",
   "peerDependencies": {
     "@puckeditor/core": "^0.21.1",
     "@tanstack/react-router": "^1.166.6",

package/src/hono/captcha.ts

@@ -3,6 +3,12 @@ import { getConnInfo } from "hono/bun";
 import { verifyToken as verifyTokenClient } from "../api/client/captcha";
 
 export const getIpAddress = (c: Context): string => {
+  const cfConnectingIp = c.req.header("cf-connecting-ip")?.trim();
+
+  if (cfConnectingIp && cfConnectingIp.length > 0) {
+    return cfConnectingIp;
+  }
+
   const forwardedFor = c.req.header("x-forwarded-for");
 
   if (forwardedFor) {
@@ -14,6 +20,12 @@ export const getIpAddress = (c: Context): string => {
     }
   }
 
+  // Common fallback headers set by some proxies/CDNs
+  const realIp = c.req.header("x-real-ip")?.trim();
+  if (realIp && realIp.length > 0) {
+    return realIp;
+  }
+
   // Fallback to the connection info if x-forwarded-for is not present
   const info = getConnInfo(c);
   return info.remote.address || "";

package/src/libs/valibot-serialize/converters/from_valibot.ts

@@ -0,0 +1,61 @@
+import type { BaseIssue, BaseSchema } from "valibot";
+import {
+  FORMAT_VERSION,
+  type SchemaNode,
+  type SerializedSchema,
+} from "../types.ts";
+import * as codecs from "../types/index.ts";
+
+type AnySchema = BaseSchema<unknown, unknown, BaseIssue<unknown>>;
+
+// Cache schema encodings to support recursive builders like v.lazy.
+const encodeCache = new WeakMap<AnySchema, SchemaNode>();
+
+/**
+ * Convert a Valibot schema into a portable JSON-friendly representation.
+ *
+ * The returned value contains a stable envelope plus an AST `node` that
+ * captures the schema structure and constraints without functions.
+ *
+ * @typeParam T - Any Valibot `BaseSchema`.
+ * @param schema - The Valibot schema to convert.
+ * @returns A `SerializedSchema` envelope with the encoded AST.
+ */
+export function fromValibot<T extends AnySchema>(schema: T): SerializedSchema {
+  const node = encodeNode(schema);
+  return {
+    kind: "schema",
+    vendor: "valibot",
+    version: 1,
+    format: FORMAT_VERSION,
+    node,
+  };
+}
+
+function encodeNode(schema: AnySchema): SchemaNode {
+  const cached = encodeCache.get(schema);
+  if (cached) return cached;
+
+  const placeholder = {} as SchemaNode;
+  encodeCache.set(schema, placeholder);
+
+  // Read type directly to avoid JSON.stringify BigInt errors
+  const any = schema as unknown as { type?: string } & Record<string, unknown>;
+  const type = any.type;
+  // Dispatch to codecs that can detect from Valibot schema
+  try {
+    for (const c of Object.values(codecs)) {
+      if (c.matches(schema as never)) {
+        const node = c.encode(any as never, { encodeNode });
+        return Object.assign(placeholder, node);
+      }
+    }
+  } catch (error) {
+    encodeCache.delete(schema);
+    throw error;
+  }
+  encodeCache.delete(schema);
+  throw new Error(
+    `Unsupported schema type for serialization: ${String(type)}`,
+  );
+}

package/src/libs/valibot-serialize/converters/index.ts

@@ -0,0 +1,2 @@
+export { fromValibot } from "./from_valibot.ts";
+export { toValibot } from "./to_valibot.ts";

package/src/libs/valibot-serialize/converters/to_valibot.ts

@@ -0,0 +1,36 @@
+// import removed; decoders are delegated to codecs now
+import type { BaseIssue, BaseSchema } from "valibot";
+import type { SchemaNode, SerializedSchema } from "../types.ts";
+import { isSerializedSchema } from "../util/guard.ts";
+import * as codecs from "../types/index.ts";
+
+type AnySchema = BaseSchema<unknown, unknown, BaseIssue<unknown>>;
+
+/**
+ * Convert a serialized schema back to a Valibot schema.
+ *
+ * Validates the envelope shape and converts the contained AST into
+ * Valibot builder objects.
+ *
+ * @param data - A `SerializedSchema` envelope produced by {@link fromValibot}.
+ * @returns A Valibot schema equivalent to the original.
+ * @throws If the input is not a valid serialized schema.
+ */
+export function toValibot(data: SerializedSchema): AnySchema {
+  if (!isSerializedSchema(data)) {
+    throw new Error("Invalid serialized schema format");
+  }
+  return decodeNode(data.node);
+}
+
+function decodeNode(node: SchemaNode): AnySchema {
+  for (const c of Object.values(codecs)) {
+    if (c.typeName === node.type) {
+      return c.decode(node as never, { decodeNode });
+    }
+  }
+
+  throw new Error(
+    `Unsupported node type: ${(node as { type: string }).type}`,
+  );
+}

package/src/libs/valibot-serialize/index.ts

@@ -0,0 +1,2 @@
+export { fromValibot } from "./converters/from_valibot.ts";
+export { toValibot } from "./converters/to_valibot.ts";

package/src/libs/valibot-serialize/types/any.ts

@@ -0,0 +1,36 @@
+import * as v from "valibot";
+import type { BaseNode, IsSchemaNode } from "./lib/type_interfaces.ts";
+import type {
+  AnySchema,
+  Decoder,
+  Encoder,
+  Matches,
+} from "./lib/type_interfaces.ts";
+
+export const typeName = "any" as const;
+
+// Serialized node shape for "any"
+export interface AnyNode extends BaseNode<typeof typeName> {}
+
+export const isSchemaNode: IsSchemaNode<AnyNode> = (
+  node: unknown,
+  _ctx,
+): node is AnyNode => {
+  return Boolean(
+    node &&
+    typeof node === "object" &&
+    (node as { type?: unknown }).type === typeName,
+  );
+};
+
+export const matches: Matches = (any: AnySchema): boolean => {
+  return any?.type === typeName;
+};
+
+export const encode: Encoder<AnyNode> = function encodeAny(): AnyNode {
+  return { type: typeName };
+};
+
+export const decode: Decoder<AnyNode> = function decodeAny(): AnySchema {
+  return v.any();
+};

package/src/libs/valibot-serialize/types/array.ts

@@ -0,0 +1,115 @@
+import * as v from "valibot";
+import type { AnyNode, BaseNode, IsSchemaNode } from "./lib/type_interfaces.ts";
+import type {
+  AnySchema,
+  Decoder,
+  Encoder,
+  Matches,
+} from "./lib/type_interfaces.ts";
+
+export const typeName = "array" as const;
+
+// Serialized node shape for "array"
+export interface ArrayNode extends BaseNode<typeof typeName> {
+  item: AnyNode;
+  minLength?: number;
+  maxLength?: number;
+  length?: number;
+}
+
+export const isSchemaNode: IsSchemaNode<ArrayNode> = (
+  node: unknown,
+  ctx,
+): node is ArrayNode => {
+  if (!node || typeof node !== "object") return false;
+  if ((node as { type?: unknown }).type !== typeName) return false;
+  const n = node as Record<string, unknown>;
+  if (!ctx.isSchemaNode(n.item)) return false;
+  if (n.minLength !== undefined && typeof n.minLength !== "number") {
+    return false;
+  }
+  if (n.maxLength !== undefined && typeof n.maxLength !== "number") {
+    return false;
+  }
+  if (n.length !== undefined && typeof n.length !== "number") return false;
+  return true;
+};
+
+export const matches: Matches = (any: AnySchema): boolean => {
+  return any?.type === typeName;
+};
+
+export const encode: Encoder<ArrayNode> = function encodeArray(
+  any,
+  ctx,
+): ArrayNode {
+  const child = (any as { item?: unknown }).item as AnySchema | undefined;
+  if (!child) throw new Error("Unsupported array schema: missing item schema");
+  const node: ArrayNode = {
+    type: typeName,
+    item: ctx.encodeNode(child),
+  };
+  const pipe = (any as { pipe?: unknown[] }).pipe as
+    | Array<Record<string, unknown>>
+    | undefined;
+  if (Array.isArray(pipe)) {
+    for (const step of pipe) {
+      if (!step || typeof step !== "object") continue;
+      if (step.kind !== "validation") continue;
+      switch (step.type) {
+        case "min_length": {
+          const req = step.requirement as number | undefined;
+          if (typeof req === "number") node.minLength = req;
+          break;
+        }
+        case "max_length": {
+          const req = step.requirement as number | undefined;
+          if (typeof req === "number") node.maxLength = req;
+          break;
+        }
+        case "length": {
+          const req = step.requirement as number | undefined;
+          if (typeof req === "number") node.length = req;
+          break;
+        }
+        case "non_empty": {
+          node.minLength = Math.max(1, node.minLength ?? 0);
+          break;
+        }
+      }
+    }
+  }
+  return node;
+};
+
+export const decode: Decoder<ArrayNode> = function decodeArray(
+  node,
+  ctx,
+): AnySchema {
+  const base = v.array(ctx.decodeNode(node.item));
+  const validators: unknown[] = [];
+  if (node.minLength !== undefined) {
+    validators.push(v.minLength(node.minLength));
+  }
+  if (node.maxLength !== undefined) {
+    validators.push(v.maxLength(node.maxLength));
+  }
+  if (node.length !== undefined) validators.push(v.length(node.length));
+  switch (validators.length) {
+    case 0:
+      return base;
+    case 1:
+      return v.pipe(base, validators[0] as never);
+    case 2:
+      return v.pipe(base, validators[0] as never, validators[1] as never);
+    case 3:
+      return v.pipe(
+        base,
+        validators[0] as never,
+        validators[1] as never,
+        validators[2] as never,
+      );
+    default:
+      return v.pipe(base, ...(validators as never[]));
+  }
+};

package/src/libs/valibot-serialize/types/bigint.ts

@@ -0,0 +1,40 @@
+import * as v from "valibot";
+import type { BaseNode, IsSchemaNode } from "./lib/type_interfaces.ts";
+import type {
+  AnySchema,
+  Decoder,
+  Encoder,
+  Matches,
+} from "./lib/type_interfaces.ts";
+
+export const typeName = "bigint" as const;
+
+// Serialized node shape for "bigint"
+export interface BigIntNode extends BaseNode<typeof typeName> {}
+
+export const isSchemaNode: IsSchemaNode<BigIntNode> = (
+  node: unknown,
+  _ctx,
+): node is BigIntNode => {
+  return Boolean(
+    node &&
+    typeof node === "object" &&
+    (node as { type?: unknown }).type === typeName,
+  );
+};
+
+export const matches: Matches = (any: AnySchema): boolean => {
+  return any?.type === typeName;
+};
+
+export const encode: Encoder<BigIntNode> = function encodeBigInt(
+  _any,
+): BigIntNode {
+  return { type: typeName };
+};
+
+export const decode: Decoder<BigIntNode> = function decodeBigInt(
+  _node,
+): AnySchema {
+  return v.bigint();
+};

package/src/libs/valibot-serialize/types/blob.ts

@@ -0,0 +1,67 @@
+import * as v from "valibot";
+import type { BaseNode } from "./lib/type_interfaces.ts";
+import type {
+  AnySchema,
+  Decoder,
+  Encoder,
+  Matches,
+} from "./lib/type_interfaces.ts";
+
+export const typeName = "blob" as const;
+
+// Serialized node shape for "blob"
+export interface BlobNode extends BaseNode<typeof typeName> {
+  minSize?: number;
+  maxSize?: number;
+  mimeTypes?: string[];
+}
+
+export const matches: Matches = (any: AnySchema): boolean => {
+  return any?.type === typeName;
+};
+
+export const encode: Encoder<BlobNode> = function encodeBlob(any): BlobNode {
+  const node: BlobNode = { type: typeName };
+  const pipe = (any as { pipe?: unknown[] }).pipe as
+    | Array<Record<string, unknown>>
+    | undefined;
+  if (Array.isArray(pipe)) {
+    for (const step of pipe) {
+      if (!step || typeof step !== "object") continue;
+      if (step.kind !== "validation") continue;
+      switch (step.type) {
+        case "min_size": {
+          const req = step.requirement as number | undefined;
+          if (typeof req === "number") node.minSize = req;
+          break;
+        }
+        case "max_size": {
+          const req = step.requirement as number | undefined;
+          if (typeof req === "number") node.maxSize = req;
+          break;
+        }
+        case "mime_type": {
+          const req = step.requirement as string[] | undefined;
+          if (Array.isArray(req)) node.mimeTypes = req;
+          break;
+        }
+      }
+    }
+  }
+  return node;
+};
+
+export const decode: Decoder<BlobNode> = function decodeBlob(node): AnySchema {
+  let b = v.blob();
+  const items: unknown[] = [];
+  if (node.minSize !== undefined) items.push(v.minSize(node.minSize));
+  if (node.maxSize !== undefined) items.push(v.maxSize(node.maxSize));
+  if (node.mimeTypes && node.mimeTypes.length > 0) {
+    const mimeType = (
+      v as unknown as { mimeType: (req: string[] | string) => unknown }
+    ).mimeType;
+    items.push(mimeType(node.mimeTypes));
+  }
+  if (items.length > 0) b = v.pipe(b, ...(items as never[]));
+  return b;
+};

package/src/libs/valibot-serialize/types/boolean.ts

@@ -0,0 +1,40 @@
+import * as v from "valibot";
+import type { BaseNode, IsSchemaNode } from "./lib/type_interfaces.ts";
+import type {
+  AnySchema,
+  Decoder,
+  Encoder,
+  Matches,
+} from "./lib/type_interfaces.ts";
+
+export const typeName = "boolean" as const;
+
+// Serialized node shape for "boolean"
+export interface BooleanNode extends BaseNode<typeof typeName> {}
+
+export const isSchemaNode: IsSchemaNode<BooleanNode> = (
+  node: unknown,
+  _ctx,
+): node is BooleanNode => {
+  return Boolean(
+    node &&
+    typeof node === "object" &&
+    (node as { type?: unknown }).type === typeName,
+  );
+};
+
+export const matches: Matches = (any: AnySchema): boolean => {
+  return any?.type === typeName;
+};
+
+export const encode: Encoder<BooleanNode> = function encodeBoolean(
+  _any,
+): BooleanNode {
+  return { type: typeName };
+};
+
+export const decode: Decoder<BooleanNode> = function decodeBoolean(
+  _node,
+): AnySchema {
+  return v.boolean();
+};

package/src/libs/valibot-serialize/types/date.ts

@@ -0,0 +1,36 @@
+import * as v from "valibot";
+import type { BaseNode, IsSchemaNode } from "./lib/type_interfaces.ts";
+import type {
+  AnySchema,
+  Decoder,
+  Encoder,
+  Matches,
+} from "./lib/type_interfaces.ts";
+
+export const typeName = "date" as const;
+
+// Serialized node shape for "date"
+export interface DateNode extends BaseNode<typeof typeName> {}
+
+export const isSchemaNode: IsSchemaNode<DateNode> = (
+  node: unknown,
+  _ctx,
+): node is DateNode => {
+  return Boolean(
+    node &&
+    typeof node === "object" &&
+    (node as { type?: unknown }).type === typeName,
+  );
+};
+
+export const matches: Matches = (any: AnySchema): boolean => {
+  return any?.type === typeName;
+};
+
+export const encode: Encoder<DateNode> = function encodeDate(_any): DateNode {
+  return { type: typeName };
+};
+
+export const decode: Decoder<DateNode> = function decodeDate(_node): AnySchema {
+  return v.date();
+};

package/src/libs/valibot-serialize/types/enum.ts

@@ -0,0 +1,67 @@
+import * as v from "valibot";
+import type { BaseNode, IsSchemaNode } from "./lib/type_interfaces.ts";
+import type {
+  AnySchema,
+  Decoder,
+  Encoder,
+  Matches,
+} from "./lib/type_interfaces.ts";
+
+export const typeName = "enum" as const;
+
+// Serialized node shape for "enum"
+export interface EnumNode extends BaseNode<typeof typeName> {
+  values: Array<string | number | boolean | null>;
+}
+
+export const isSchemaNode: IsSchemaNode<EnumNode> = (
+  node: unknown,
+  _ctx,
+): node is EnumNode => {
+  if (!node || typeof node !== "object") return false;
+  if ((node as { type?: unknown }).type !== typeName) return false;
+  const values = (node as { values?: unknown }).values as unknown;
+  if (!Array.isArray(values)) return false;
+  for (const v of values) {
+    const t = typeof v;
+    if (!(t === "string" || t === "number" || t === "boolean") && v !== null) {
+      return false;
+    }
+  }
+  return true;
+};
+
+export const matches: Matches = (any: AnySchema): boolean => {
+  const type = (any as { type?: string }).type;
+  return type === "enum";
+};
+
+export const encode: Encoder<EnumNode> = function encodeEnum(any): EnumNode {
+  const values = ((any as { options?: unknown[] }).options ??
+    (any as { enum?: unknown[] }).enum) as unknown[] | undefined;
+  if (!Array.isArray(values)) {
+    throw new Error("Unsupported enum schema: missing options");
+  }
+  const out: Array<string | number | boolean | null> = [];
+  for (const val of values) {
+    const t = typeof val;
+    if (t === "string" || t === "number" || t === "boolean" || val === null) {
+      out.push(val as never);
+    } else throw new Error("Unsupported enum value type");
+  }
+  return { type: typeName, values: out };
+};
+
+export const decode: Decoder<EnumNode> = function decodeEnum(node): AnySchema {
+  const allStrings = node.values.every((val) => typeof val === "string");
+  if (allStrings) {
+    const mapping = Object.fromEntries(
+      (node.values as string[]).map((s) => [s, s] as const),
+    );
+    // deno-lint-ignore no-explicit-any
+    return (v as any).enum(mapping);
+  }
+  // Fallback: union of literals
+  const literals = node.values.map((val) => v.literal(val as never));
+  return v.union(literals as never);
+};

package/src/libs/valibot-serialize/types/exact_optional.ts

@@ -0,0 +1,58 @@
+import * as v from "valibot";
+import type { AnyNode, BaseNode, IsSchemaNode } from "./lib/type_interfaces.ts";
+import type {
+  AnySchema,
+  Decoder,
+  Encoder,
+  Matches,
+} from "./lib/type_interfaces.ts";
+import { cloneSerializable } from "./lib/default_utils.ts";
+
+export const typeName = "exact_optional" as const;
+
+export const supportedTypes = [typeName];
+
+export interface ExactOptionalNode extends BaseNode<typeof typeName> {
+  base: AnyNode;
+  default?: unknown;
+  hasDefault?: boolean;
+}
+
+export const isSchemaNode: IsSchemaNode<ExactOptionalNode> = (
+  node,
+  ctx,
+): node is ExactOptionalNode => {
+  if (!node || typeof node !== "object") return false;
+  if ((node as { type?: unknown }).type !== typeName) return false;
+  if (!ctx.isSchemaNode((node as { base?: unknown }).base)) return false;
+  return true;
+};
+
+export const matches: Matches = (schema: AnySchema): boolean => {
+  return schema?.type === typeName;
+};
+
+export const encode: Encoder<ExactOptionalNode> = (schema, ctx) => {
+  const wrapped = (schema as { wrapped?: AnySchema }).wrapped;
+  if (!wrapped) {
+    throw new Error("Unsupported exactOptional schema: missing wrapped schema");
+  }
+  const node: ExactOptionalNode = {
+    type: typeName,
+    base: ctx.encodeNode(wrapped),
+  };
+  if (Object.prototype.hasOwnProperty.call(schema, "default")) {
+    const def = (schema as { default?: unknown }).default;
+    node.default = cloneSerializable(def);
+    node.hasDefault = true;
+  }
+  return node;
+};
+
+export const decode: Decoder<ExactOptionalNode> = (node, ctx) => {
+  const base = ctx.decodeNode(node.base);
+  if (node.hasDefault) {
+    return v.exactOptional(base, cloneSerializable(node.default));
+  }
+  return v.exactOptional(base, undefined);
+};

package/src/libs/valibot-serialize/types/file.ts

@@ -0,0 +1,86 @@
+import * as v from "valibot";
+import type { BaseNode, IsSchemaNode } from "./lib/type_interfaces.ts";
+import type {
+  AnySchema,
+  Decoder,
+  Encoder,
+  Matches,
+} from "./lib/type_interfaces.ts";
+
+export const typeName = "file" as const;
+
+// Serialized node shape for "file"
+export interface FileNode extends BaseNode<typeof typeName> {
+  minSize?: number;
+  maxSize?: number;
+  mimeTypes?: string[];
+}
+
+export const isSchemaNode: IsSchemaNode<FileNode> = (
+  node: unknown,
+  _ctx,
+): node is FileNode => {
+  if (!node || typeof node !== "object") return false;
+  if ((node as { type?: unknown }).type !== typeName) return false;
+  const n = node as Record<string, unknown>;
+  if (n.minSize !== undefined && typeof n.minSize !== "number") return false;
+  if (n.maxSize !== undefined && typeof n.maxSize !== "number") return false;
+  if (n.mimeTypes !== undefined) {
+    if (
+      !Array.isArray(n.mimeTypes) ||
+      (n.mimeTypes as unknown[]).some((x) => typeof x !== "string")
+    )
+      return false;
+  }
+  return true;
+};
+
+export const matches: Matches = (any: AnySchema): boolean => {
+  return any?.type === typeName;
+};
+
+export const encode: Encoder<FileNode> = function encodeFile(any): FileNode {
+  const node: FileNode = { type: typeName };
+  const pipe = (any as { pipe?: unknown[] }).pipe as
+    | Array<Record<string, unknown>>
+    | undefined;
+  if (Array.isArray(pipe)) {
+    for (const step of pipe) {
+      if (!step || typeof step !== "object") continue;
+      if (step.kind !== "validation") continue;
+      switch (step.type) {
+        case "min_size": {
+          const req = step.requirement as number | undefined;
+          if (typeof req === "number") node.minSize = req;
+          break;
+        }
+        case "max_size": {
+          const req = step.requirement as number | undefined;
+          if (typeof req === "number") node.maxSize = req;
+          break;
+        }
+        case "mime_type": {
+          const req = step.requirement as string[] | undefined;
+          if (Array.isArray(req)) node.mimeTypes = req;
+          break;
+        }
+      }
+    }
+  }
+  return node;
+};
+
+export const decode: Decoder<FileNode> = function decodeFile(node): AnySchema {
+  let f = v.file();
+  const actions: unknown[] = [];
+  if (node.minSize !== undefined) actions.push(v.minSize(node.minSize));
+  if (node.maxSize !== undefined) actions.push(v.maxSize(node.maxSize));
+  if (node.mimeTypes && node.mimeTypes.length > 0) {
+    const mimeType = (
+      v as unknown as { mimeType: (req: string[] | string) => unknown }
+    ).mimeType;
+    actions.push(mimeType(node.mimeTypes));
+  }
+  if (actions.length > 0) f = v.pipe(f, ...(actions as never[]));
+  return f;
+};