rankrunners-cms 0.0.32 → 0.0.34

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "rankrunners-cms",
   "type": "module",
-  "version": "0.0.32",
+  "version": "0.0.34",
   "peerDependencies": {
     "@puckeditor/core": "^0.21.1",
-    "@tanstack/react-router": "^1.166.6",
-    "@tanstack/router-core": "^1.166.6",
+    "@tanstack/react-router": "^1.166.7",
+    "@tanstack/router-core": "^1.166.7",
     "lucide-react": "^0.577.0",
     "next": "^16.1.6",
     "react": "^19.2.4",
@@ -35,7 +35,6 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "classnames": "^2.5.1",
-    "valibot-serialize": "^1.5.0"
+    "classnames": "^2.5.1"
   }
 }

package/src/api/client/form-fills.ts

@@ -0,0 +1,79 @@
+import {
+  safeParse,
+  type BaseIssue,
+  type BaseSchema,
+  type InferInput,
+} from "valibot";
+import { CMS_BASE_URL, SITE_ID } from "../constants";
+import type { FormFillSubmissionDTO } from "../types/form-fills";
+import { SendFormFillResult } from "../types/form-fills";
+
+export type SendFormFillArgs<
+  A,
+  B,
+  C extends BaseIssue<unknown>,
+  T extends BaseSchema<A, B, C>,
+> = {
+  type: string;
+  schema: T;
+  fieldNames: Record<string, string>;
+  data: InferInput<T>;
+  captchaToken: string;
+  test?: boolean;
+};
+
+export const sendFormFill = async <
+  A,
+  B,
+  C extends BaseIssue<unknown>,
+  T extends BaseSchema<A, B, C>,
+>(
+  args: SendFormFillArgs<A, B, C, T>,
+): Promise<SendFormFillResult> => {
+  const formToSend = safeParse(args.schema, args.data);
+
+  if (!formToSend.success) {
+    console.error("Form fill validation failed:", formToSend.issues);
+    return SendFormFillResult.ValidationError;
+  }
+
+  const data: FormFillSubmissionDTO = {
+    siteId: SITE_ID,
+    type: args.type,
+    data: args.data as Record<string, string>,
+    schema: {
+      schema: JSON.stringify(args.schema),
+      fields: args.fieldNames,
+    },
+    captchaToken: args.captchaToken,
+    test: args.test,
+  };
+
+  try {
+    const response = await fetch(`${CMS_BASE_URL}/form-fills/public`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(data),
+    });
+
+    if (response.ok) {
+      return SendFormFillResult.Success;
+    }
+
+    console.error("Form fill submission failed with status:", response.status);
+    return SendFormFillResult.UnknownError;
+  } catch (error) {
+    console.error("Error sending form fill:", error);
+    if (error instanceof Error) {
+      if (error.message.includes("validation")) {
+        return SendFormFillResult.ValidationError;
+      }
+      if (error.message.includes("captcha")) {
+        return SendFormFillResult.CaptchaError;
+      }
+    }
+    return SendFormFillResult.UnknownError;
+  }
+};

package/src/api/client/index.ts

@@ -1,3 +1,6 @@
+export * from "./captcha";
+export * from "./form-fills";
+export * from "./pages";
 export * from "./posts";
 export * from "./public";
 export * from "./sitemap";

package/src/api/types/form-fills.ts

@@ -0,0 +1,71 @@
+import {
+  object,
+  record,
+  string,
+  pipe,
+  nonEmpty,
+  boolean,
+  optional,
+  type InferOutput,
+  type InferInput,
+} from "valibot";
+import { IdSchema } from "./common";
+
+// Schema field definition - describes a single field in the form
+export const FormFillSchemaDataSchema = object({
+  schema: string(), // Serialized validation rule (fromValibot / toValibot - rankrunners-cms/src/lib/valibot)
+  fields: record(
+    string(), // Field key
+    pipe(string(), nonEmpty("Field label is required")), // Field label
+  ),
+});
+
+export type FormFillSchemaDataDTO = InferOutput<
+  typeof FormFillSchemaDataSchema
+>;
+
+// Form Fill Data Structure - simple key-value record
+export const FormFillDataSchema = record(
+  string(), // Field key
+  pipe(string(), nonEmpty("Field value is required")), // Field value
+);
+
+export type FormFillDataDTO = InferOutput<typeof FormFillDataSchema>;
+
+// API Schemas
+
+// 1. Submission (Public API)
+export const FormFillSubmissionSchema = object({
+  siteId: IdSchema, // Site ID must be passed in the body for public submission
+  type: pipe(string(), nonEmpty("Form type is required")),
+  data: FormFillDataSchema,
+  schema: FormFillSchemaDataSchema,
+  captchaToken: pipe(string(), nonEmpty("Captcha token is required")),
+  test: optional(boolean()),
+});
+
+export type FormFillSubmissionDTO = InferInput<typeof FormFillSubmissionSchema>;
+
+export enum SendFormFillResult {
+  Success = "success",
+  ValidationError = "validation_error",
+  CaptchaError = "captcha_error",
+  InvalidResponse = "invalid_response",
+  UnknownError = "unknown_error",
+}
+
+export const formFillResultToMessage = (result: SendFormFillResult): string => {
+  switch (result) {
+    case SendFormFillResult.Success:
+      return "Form submitted successfully!";
+    case SendFormFillResult.ValidationError:
+      return "There was a validation error with your submission. Please check your input and try again.";
+    case SendFormFillResult.CaptchaError:
+      return "Captcha verification failed. Please complete the captcha and try again.";
+    case SendFormFillResult.InvalidResponse:
+      return "An internal error occurred while submitting the form. Please call us instead!";
+    case SendFormFillResult.UnknownError:
+    default:
+      return "An unknown error occurred while submitting the form. Please try again later, or try calling us!";
+  }
+};

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);
+};