rankrunners-cms 0.0.33 → 0.0.35

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "rankrunners-cms",
   "type": "module",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "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",

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/api/types/index.ts

@@ -1,2 +1,3 @@
 export * from "./common";
 export * from "./public";
+export * from "./form-fills";

package/test/test.ts

@@ -0,0 +1,25 @@
+import { serializeSigned } from "hono/utils/cookie";
+import * as v from "valibot";
+import { fromValibot, toValibot } from "rankrunners-cms/src/libs/valibot-serialize";
+
+export const TestSchema = v.object({
+  username: v.string(),
+  fullname: v.string(),
+});
+
+const serializedSchema = fromValibot(TestSchema);
+const deserializedValidator = toValibot(serializedSchema);
+
+let data: string;
+
+try {
+    data = JSON.stringify(v.parse(deserializedValidator, {
+        username: "testuser",
+        fullname: "Test User"
+    }));
+} catch (error) {
+    console.error("Validation failed:", error);
+    data = "Validation failed";
+}
+
+console.log("Deserialized and validated data:", data);