@nestledjs/data-browser 1.0.15 → 1.0.16

package/lib/utils/graphql-utils.js

@@ -1,6 +1,6 @@
 import React from "react";
 import { Link } from "react-router";
-import { FormFieldClass } from "@nestledjs/forms";
+import { FormFieldClass } from "@nestledjs/forms-core";
 import { RelationFieldWrapper } from "../components/RelationFieldWrapper.js";
 import { getPluralName } from "./get-plural-names.js";
 import { normalizeModelNameForDocument } from "./string-utils.js";
@@ -15,16 +15,17 @@ function getEnumValues(sdk, enumType) {
     }
     const values = Object.values(enumObject).filter((value) => typeof value === "string");
     if (values.length === 0) {
-      const keys = Object.keys(enumObject).filter((key) => isNaN(Number(key)));
+      const keys = Object.keys(enumObject).filter((key) => Number.isNaN(Number(key)));
       return keys.length > 0 ? keys : null;
     }
-    return values;
+    return values.filter((v) => typeof v === "string");
   } catch (error) {
+    console.error("Unexpected error:", error);
     return null;
   }
 }
 function getAdminDocuments(sdk, model) {
-  if (!model || !model.name) {
+  if (!model?.name) {
     throw new Error("Invalid model provided to getAdminDocuments");
   }
   const normalizedModelName = normalizeModelNameForDocument(model.name);
@@ -34,14 +35,15 @@ function getAdminDocuments(sdk, model) {
   const updateDocumentName = `__AdminUpdate${normalizedModelName}`;
   const deleteDocumentName = `__AdminDelete${normalizedModelName}`;
   const createDocumentName = `__AdminCreate${normalizedModelName}`;
+  const sdkRecord = sdk;
   const documents = {
-    query: sdk[singleQueryDocumentName],
+    query: sdkRecord[singleQueryDocumentName],
     // For single item
-    listQuery: sdk[listQueryDocumentName],
+    listQuery: sdkRecord[listQueryDocumentName],
     // For lists
-    update: sdk[updateDocumentName],
-    delete: sdk[deleteDocumentName],
-    create: sdk[createDocumentName]
+    update: sdkRecord[updateDocumentName],
+    delete: sdkRecord[deleteDocumentName],
+    create: sdkRecord[createDocumentName]
   };
   const missingDocuments = [];
   if (!documents.query) missingDocuments.push(singleQueryDocumentName);
@@ -70,7 +72,7 @@ function getMutationName(model, operation) {
   }
 }
 function toKebabCase(str) {
-  return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+  return str.replaceAll(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
 }
 function toLowerCamelCase(str) {
   if (!str) return "";
@@ -87,6 +89,262 @@ function findForeignKeyFieldName(relatedModel, currentModelName, relationName) {
   });
   return foreignKeyField?.relationFromFields?.[0] || null;
 }
+function normalizeDateInitialValue(value, fieldType) {
+  if (!(value instanceof Date) && !(value && typeof value === "string")) return value;
+  try {
+    const dateValue = value instanceof Date ? value : new Date(String(value));
+    if (fieldType === "date") return dateValue.toISOString().split("T")[0];
+    return dateValue.toISOString().substring(0, 16);
+  } catch (e) {
+    console.error("Unexpected error:", e);
+    return "";
+  }
+}
+function getFieldInitialValue(field, currentItem, operation) {
+  let initialValue = currentItem && operation === "update" ? currentItem[field.name] : void 0;
+  const fieldTypeLower = field.type.toLowerCase();
+  if (fieldTypeLower === "datetime" || fieldTypeLower === "date") {
+    initialValue = normalizeDateInitialValue(initialValue, fieldTypeLower);
+  }
+  if (initialValue && typeof initialValue === "object" && !Array.isArray(initialValue) && field.relationName) {
+    const rel = initialValue;
+    initialValue = rel.id && typeof rel.id === "string" ? rel.id : "";
+  }
+  if (initialValue === null && fieldTypeLower !== "boolean") {
+    initialValue = "";
+  }
+  return initialValue;
+}
+function buildEnumSelectOptions(values) {
+  return values.map((value) => ({
+    value,
+    label: value.replaceAll("_", " ").toLowerCase().replace(/^./, (s) => s.toUpperCase())
+  }));
+}
+function mergeAndSortOptions(initialOptions, queryOptions) {
+  const merged = [...initialOptions];
+  for (const option of queryOptions) {
+    if (!merged.some((existing) => existing.value === option.value)) {
+      merged.push(option);
+    }
+  }
+  merged.sort((a, b) => a.label.localeCompare(b.label));
+  return merged;
+}
+function resolveRelationValue(field, currentItem, operation) {
+  if (!currentItem || operation !== "update") return void 0;
+  const relationFieldName = field.relationFromFields?.[0] || `${field.name}Id`;
+  let value = currentItem[relationFieldName];
+  if (value === void 0) {
+    const relObj = currentItem[field.name];
+    if (relObj && typeof relObj === "object" && relObj.id) value = relObj.id;
+  }
+  if (value && typeof value === "object" && value.id) {
+    value = value.id;
+  }
+  if (value === null) return "";
+  return value;
+}
+function buildInitialOptions(field, currentItem, operation, getDisplayLabel) {
+  if (!currentItem || operation !== "update") return [];
+  const currentRelationData = currentItem[field.name];
+  if (currentRelationData && typeof currentRelationData === "object" && currentRelationData.id) {
+    return [{ value: currentRelationData.id, label: getDisplayLabel(currentRelationData) }];
+  }
+  return [];
+}
+function buildRelationFormField(field, label, options, currentItem, operation, sdk, ctx) {
+  const { basePath, displayFieldConfig } = ctx;
+  const relationFieldName = field.relationFromFields?.[0] || `${field.name}Id`;
+  const relationValue = resolveRelationValue(field, currentItem, operation);
+  const properPluralName = getPluralName(field.type);
+  const adminDocumentName = `__Admin${properPluralName}`;
+  const regularDocumentName = `${properPluralName}`;
+  const relationDocument = sdk[adminDocumentName] || sdk[regularDocumentName];
+  if (!relationDocument) {
+    return FormFieldClass.text(relationFieldName, {
+      label: `${label} ID`,
+      required: options.required,
+      helpText: "Enter the ID of the related record",
+      ...relationValue !== void 0 && { value: relationValue }
+    });
+  }
+  const config = displayFieldConfig?.[field.type];
+  const displayFields = config?.display || ["name", "title"];
+  const searchFields = config?.search || displayFields;
+  const getDisplayLabel = (item) => {
+    const allValues = displayFields.map((f) => item[f]).filter((v) => v != null && v !== "");
+    return allValues.length > 0 ? allValues.join(" ") : item.id;
+  };
+  const initialOptions = buildInitialOptions(field, currentItem, operation, getDisplayLabel);
+  return FormFieldClass.searchSelectApollo(relationFieldName, {
+    label,
+    required: options.required,
+    dataType: properPluralName.charAt(0).toLowerCase() + properPluralName.slice(1),
+    document: relationDocument,
+    searchFields,
+    selectOptionsFunction: (items) => {
+      const queryOptions = items.map((item) => ({
+        value: item.id,
+        label: getDisplayLabel(item)
+      }));
+      return mergeAndSortOptions(initialOptions, queryOptions);
+    },
+    ...initialOptions.length > 0 && { initialOptions },
+    ...relationValue !== void 0 && { value: relationValue },
+    customWrapper: (fieldElement) => React.createElement(
+      RelationFieldWrapper,
+      {
+        relationType: field.type,
+        initialValue: relationValue,
+        fieldName: relationFieldName,
+        basePath
+      },
+      fieldElement
+    )
+  });
+}
+function fieldNameWords(name) {
+  return name.replaceAll(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[\s_-]+/).filter(Boolean);
+}
+function buildRegularFormField(field, sdk, currentItem, operation, basePath, displayFieldConfig) {
+  const label = field.name.replaceAll(/([a-z])([A-Z])/g, "$1 $2").replace(/^./, (str) => str.toUpperCase());
+  const initialValue = getFieldInitialValue(field, currentItem, operation);
+  const isArrayField = Boolean(field.isList);
+  const isRequired = isArrayField ? false : !field.isOptional;
+  const options = {
+    label,
+    required: isRequired,
+    ...initialValue !== void 0 && { value: initialValue }
+  };
+  switch (field.type.toLowerCase()) {
+    case "string": {
+      const words = fieldNameWords(field.name);
+      const last = words[words.length - 1];
+      const secondLast = words[words.length - 2];
+      const isEmailField = last === "email" || last === "emailaddress" || secondLast === "email" && last === "address";
+      if (isEmailField) return FormFieldClass.email(field.name, options);
+      if (last === "description" || last === "content" || last === "notes")
+        return FormFieldClass.textArea(field.name, options);
+      return FormFieldClass.text(field.name, options);
+    }
+    case "int":
+    case "bigint":
+    case "float":
+    case "decimal":
+      return FormFieldClass.text(field.name, options);
+    case "boolean": {
+      const booleanValue = currentItem && operation === "update" ? Boolean(currentItem[field.name]) : false;
+      return FormFieldClass.checkbox(field.name, {
+        ...options,
+        required: false,
+        ...operation === "update" && { value: booleanValue }
+      });
+    }
+    case "datetime":
+      return FormFieldClass.dateTimePicker(field.name, options);
+    case "date":
+      return FormFieldClass.datePicker(field.name, options);
+    default:
+      return buildDefaultFormField(field, options, initialValue, sdk, currentItem, operation, {
+        basePath,
+        displayFieldConfig
+      });
+  }
+}
+function buildDefaultFormField(field, options, initialValue, sdk, currentItem, operation, ctx) {
+  const label = options.label;
+  const { basePath, displayFieldConfig } = ctx;
+  const enumValues = getEnumValues(sdk, field.type);
+  if (enumValues) {
+    if (field.isList) {
+      let defaultValue = "";
+      if (Array.isArray(initialValue) && initialValue.length > 0)
+        defaultValue = initialValue.join(",");
+      const checkboxOptions = enumValues.map((value) => ({
+        key: value,
+        value,
+        label: value.replaceAll("_", " ").toLowerCase().replace(/^./, (s) => s.toUpperCase())
+      }));
+      return FormFieldClass.checkboxGroup(field.name, {
+        label: options.label,
+        required: options.required,
+        checkboxOptions,
+        checkboxDirection: "column",
+        ...operation !== "update" && defaultValue && { defaultValue }
+      });
+    }
+    const selectOptions = buildEnumSelectOptions(enumValues);
+    const enumOptions = operation === "update" ? { label: options.label, required: options.required, options: selectOptions } : { ...options, options: selectOptions };
+    return FormFieldClass.select(field.name, enumOptions);
+  }
+  if (field.relationName && !field.isList) {
+    return buildRelationFormField(field, label, options, currentItem, operation, sdk, {
+      basePath,
+      displayFieldConfig
+    });
+  }
+  if (field.kind === "enum" && field.enumValues) {
+    const selectOptions = field.enumValues.map((value) => ({
+      value,
+      label: value.replaceAll("_", " ").toLowerCase().replace(/^./, (s) => s.toUpperCase())
+    }));
+    return FormFieldClass.select(field.name, { ...options, options: selectOptions });
+  }
+  return FormFieldClass.text(field.name, options);
+}
+function buildListRelationFormField(field, model, currentItem, databaseModels, basePath) {
+  const label = field.name.replaceAll(/([a-z])([A-Z])/g, "$1 $2").replace(/^./, (str) => str.toUpperCase());
+  const pluralModelName = getPluralName(field.type);
+  const relatedModelKebab = toKebabCase(pluralModelName);
+  const displayName = field.type.replaceAll(/([a-z])([A-Z])/g, "$1 $2");
+  const pluralDisplayName = getPluralName(displayName);
+  const relatedModel = databaseModels?.find((m) => m.name === field.type);
+  const foreignKeyFieldName = findForeignKeyFieldName(relatedModel, model.name, field.relationName) || `${toLowerCamelCase(model.name)}Id`;
+  const filterUrl = `${basePath}/${relatedModelKebab}?${foreignKeyFieldName}=${currentItem.id}`;
+  const countData = currentItem._count?.[field.name];
+  const countText = countData === void 0 ? "" : ` (${countData})`;
+  return FormFieldClass.content(field.name, {
+    content: React.createElement("div", { className: "py-2" }, [
+      React.createElement(
+        "label",
+        {
+          key: "label",
+          className: "block text-sm font-medium text-gray-700 dark:text-gray-300 mb-1"
+        },
+        label
+      ),
+      React.createElement(
+        Link,
+        {
+          key: "link",
+          to: filterUrl,
+          className: "inline-flex items-center text-sm text-blue-600 hover:text-blue-800 dark:text-blue-400 dark:hover:text-blue-300 hover:underline"
+        },
+        [
+          React.createElement(
+            "svg",
+            {
+              key: "icon",
+              className: "h-4 w-4 mr-1",
+              fill: "none",
+              stroke: "currentColor",
+              viewBox: "0 0 24 24",
+              xmlns: "http://www.w3.org/2000/svg"
+            },
+            React.createElement("path", {
+              strokeLinecap: "round",
+              strokeLinejoin: "round",
+              strokeWidth: 2,
+              d: "M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2"
+            })
+          ),
+          `See Related ${pluralDisplayName}${countText}`
+        ]
+      )
+    ])
+  });
+}
 function buildFormFields(sdk, model, operation, options = {}) {
   const {
     currentItem,
@@ -117,272 +375,22 @@ function buildFormFields(sdk, model, operation, options = {}) {
     }
   }
   regularFields.forEach((field) => {
-    const label = field.name.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/^./, (str) => str.toUpperCase());
-    let initialValue = currentItem && operation === "update" ? currentItem[field.name] : void 0;
-    if (field.type.toLowerCase() === "datetime" || field.type.toLowerCase() === "date") {
-      if (initialValue instanceof Date || initialValue && typeof initialValue === "string") {
-        try {
-          const dateValue = initialValue instanceof Date ? initialValue : new Date(initialValue);
-          if (field.type.toLowerCase() === "date") {
-            initialValue = dateValue.toISOString().split("T")[0];
-          } else {
-            const isoString = dateValue.toISOString();
-            initialValue = isoString.substring(0, 16);
-          }
-        } catch (e) {
-          initialValue = "";
-        }
-      }
-    }
-    if (initialValue && typeof initialValue === "object" && !Array.isArray(initialValue) && field.relationName) {
-      const relationObj = initialValue;
-      if (relationObj.id && typeof relationObj.id === "string") {
-        initialValue = relationObj.id;
-      } else {
-        initialValue = "";
-      }
-    }
-    if (initialValue === null && field.type.toLowerCase() !== "boolean") {
-      initialValue = "";
-    }
-    const isArrayField = Boolean(field.isList);
-    const isRequired = isArrayField ? false : !field.isOptional;
-    const options2 = {
-      label,
-      required: isRequired,
-      ...initialValue !== void 0 && { value: initialValue }
-    };
-    let formField;
-    switch (field.type.toLowerCase()) {
-      case "string":
-        if (field.name.toLowerCase().includes("email")) {
-          formField = FormFieldClass.email(field.name, options2);
-        } else if (field.name.toLowerCase().includes("description") || field.name.toLowerCase().includes("content") || field.name.toLowerCase().includes("notes")) {
-          formField = FormFieldClass.textArea(field.name, options2);
-        } else {
-          formField = FormFieldClass.text(field.name, options2);
-        }
-        break;
-      case "int":
-      case "bigint":
-        formField = FormFieldClass.text(field.name, options2);
-        break;
-      case "float":
-      case "decimal":
-        formField = FormFieldClass.text(field.name, options2);
-        break;
-      case "boolean": {
-        const booleanValue = currentItem && operation === "update" ? Boolean(currentItem[field.name]) : false;
-        formField = FormFieldClass.checkbox(field.name, {
-          ...options2,
-          required: false,
-          ...operation === "update" && { value: booleanValue }
-        });
-        break;
-      }
-      case "datetime":
-        formField = FormFieldClass.dateTimePicker(field.name, options2);
-        break;
-      case "date":
-        formField = FormFieldClass.datePicker(field.name, options2);
-        break;
-      default: {
-        const enumValues = getEnumValues(sdk, field.type);
-        if (enumValues) {
-          if (field.isList) {
-            let defaultValue = "";
-            if (Array.isArray(initialValue) && initialValue.length > 0) {
-              defaultValue = initialValue.join(",");
-            }
-            const checkboxOptions = enumValues.map((value) => ({
-              key: value,
-              value,
-              label: value.replaceAll("_", " ").toLowerCase().replace(/^./, (str) => str.toUpperCase())
-            }));
-            formField = FormFieldClass.checkboxGroup(field.name, {
-              label: options2.label,
-              required: options2.required,
-              checkboxOptions,
-              checkboxDirection: "column",
-              // Don't set value in field options for update operations
-              ...operation !== "update" && defaultValue && { defaultValue }
-            });
-            break;
-          }
-          const selectOptions = enumValues.map((value) => ({
-            value,
-            label: value.replace(/_/g, " ").toLowerCase().replace(/^./, (str) => str.toUpperCase())
-          }));
-          const enumOptions = operation === "update" ? { label: options2.label, required: options2.required, options: selectOptions } : { ...options2, options: selectOptions };
-          formField = FormFieldClass.select(field.name, enumOptions);
-          break;
-        }
-        if (field.relationName && !field.isList) {
-          const relationFieldName = field.relationFromFields?.[0] || `${field.name}Id`;
-          let relationValue = currentItem && operation === "update" ? currentItem[relationFieldName] : void 0;
-          if (relationValue === void 0 && currentItem && operation === "update") {
-            const relationObject = currentItem[field.name];
-            if (relationObject && typeof relationObject === "object" && relationObject.id) {
-              relationValue = relationObject.id;
-            }
-          }
-          if (relationValue && typeof relationValue === "object" && relationValue.id) {
-            relationValue = relationValue.id;
-          }
-          if (relationValue === null) {
-            relationValue = "";
-          }
-          const properPluralName = getPluralName(field.type);
-          const adminDocumentName = `__Admin${properPluralName}`;
-          const regularDocumentName = `${properPluralName}`;
-          const relationDocument = sdk[adminDocumentName] || sdk[regularDocumentName];
-          if (relationDocument) {
-            const config = displayFieldConfig?.[field.type];
-            const displayFields = config?.display || ["name", "title"];
-            const searchFields = config?.search || displayFields;
-            const getDisplayLabel = (item) => {
-              const allValues = displayFields.map((field2) => item[field2]).filter((val) => val != null && val !== "");
-              if (allValues.length > 0) {
-                return allValues.join(" ");
-              }
-              return item.id;
-            };
-            let initialOptions = [];
-            if (currentItem && operation === "update") {
-              const currentRelationData = currentItem[field.name];
-              if (currentRelationData && typeof currentRelationData === "object" && currentRelationData.id) {
-                const displayLabel = getDisplayLabel(currentRelationData);
-                initialOptions = [
-                  {
-                    value: currentRelationData.id,
-                    label: displayLabel
-                  }
-                ];
-              }
-            }
-            formField = FormFieldClass.searchSelectApollo(relationFieldName, {
-              label,
-              // Remove "ID" suffix - just use the field name
-              required: options2.required,
-              dataType: properPluralName.charAt(0).toLowerCase() + properPluralName.slice(1),
-              // e.g., Course → courses (camelCase)
-              document: relationDocument,
-              searchFields,
-              // For searching
-              selectOptionsFunction: (items) => {
-                const queryOptions = items.map((item) => ({
-                  value: item.id,
-                  label: getDisplayLabel(item)
-                }));
-                const allOptions = [...initialOptions];
-                queryOptions.forEach((option) => {
-                  if (!allOptions.find((existing) => existing.value === option.value)) {
-                    allOptions.push(option);
-                  }
-                });
-                allOptions.sort((a, b) => a.label.localeCompare(b.label));
-                return allOptions;
-              },
-              ...initialOptions.length > 0 && { initialOptions },
-              // Provide initial options if available
-              ...relationValue !== void 0 && { value: relationValue },
-              // Add custom wrapper to show view record link
-              customWrapper: (fieldElement) => {
-                return React.createElement(
-                  RelationFieldWrapper,
-                  {
-                    relationType: field.type,
-                    initialValue: relationValue,
-                    fieldName: relationFieldName,
-                    basePath
-                  },
-                  fieldElement
-                );
-              }
-            });
-            break;
-          } else {
-            formField = FormFieldClass.text(relationFieldName, {
-              label: `${label} ID`,
-              required: options2.required,
-              helpText: "Enter the ID of the related record",
-              ...relationValue !== void 0 && { value: relationValue }
-            });
-            break;
-          }
-        }
-        if (field.kind === "enum" && field.enumValues) {
-          const selectOptions = field.enumValues.map((value) => ({
-            value,
-            label: value.replace(/_/g, " ").toLowerCase().replace(/^./, (str) => str.toUpperCase())
-          }));
-          formField = FormFieldClass.select(field.name, {
-            ...options2,
-            options: selectOptions
-          });
-          break;
-        }
-        formField = FormFieldClass.text(field.name, options2);
-        break;
-      }
-    }
-    formFields.push(formField);
-  });
-  listRelationFields.forEach((field) => {
-    const label = field.name.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/^./, (str) => str.toUpperCase());
-    if (operation === "update" && currentItem) {
-      const pluralModelName = getPluralName(field.type);
-      const relatedModelKebab = toKebabCase(pluralModelName);
-      const displayName = field.type.replace(/([a-z])([A-Z])/g, "$1 $2");
-      const pluralDisplayName = getPluralName(displayName);
-      const relatedModel = databaseModels?.find((m) => m.name === field.type);
-      const foreignKeyFieldName = findForeignKeyFieldName(relatedModel, model.name, field.relationName) || `${toLowerCamelCase(model.name)}Id`;
-      const filterUrl = `${basePath}/${relatedModelKebab}?${foreignKeyFieldName}=${currentItem.id}`;
-      const countData = currentItem._count?.[field.name];
-      const countText = countData !== void 0 ? ` (${countData})` : "";
-      const formField = FormFieldClass.content(field.name, {
-        content: React.createElement("div", { className: "py-2" }, [
-          React.createElement(
-            "label",
-            {
-              key: "label",
-              className: "block text-sm font-medium text-gray-700 dark:text-gray-300 mb-1"
-            },
-            label
-          ),
-          React.createElement(
-            Link,
-            {
-              key: "link",
-              to: filterUrl,
-              className: "inline-flex items-center text-sm text-blue-600 hover:text-blue-800 dark:text-blue-400 dark:hover:text-blue-300 hover:underline"
-            },
-            [
-              React.createElement(
-                "svg",
-                {
-                  key: "icon",
-                  className: "h-4 w-4 mr-1",
-                  fill: "none",
-                  stroke: "currentColor",
-                  viewBox: "0 0 24 24",
-                  xmlns: "http://www.w3.org/2000/svg"
-                },
-                React.createElement("path", {
-                  strokeLinecap: "round",
-                  strokeLinejoin: "round",
-                  strokeWidth: 2,
-                  d: "M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2"
-                })
-              ),
-              `See Related ${pluralDisplayName}${countText}`
-            ]
-          )
-        ])
-      });
-      formFields.push(formField);
-    }
+    formFields.push(
+      buildRegularFormField(field, sdk, currentItem, operation, basePath, displayFieldConfig)
+    );
   });
+  if (operation === "update" && currentItem) {
+    listRelationFields.forEach((field) => {
+      const formField = buildListRelationFormField(
+        field,
+        model,
+        currentItem,
+        databaseModels,
+        basePath
+      );
+      if (formField) formFields.push(formField);
+    });
+  }
   const loadingText = operation === "create" ? "Creating..." : "Updating...";
   const defaultText = operation === "create" ? "Create" : "Update";
   const buttonText = isSubmitting ? loadingText : defaultText;
@@ -413,6 +421,37 @@ const SYSTEM_FIELDS = /* @__PURE__ */ new Set([
 function shouldSkipValue(key, value) {
   return SYSTEM_FIELDS.has(key) || value === void 0;
 }
+function cleanEnumArrayValue(value) {
+  if (typeof value === "string") {
+    return value.split(",").filter((v) => v.trim() !== "");
+  }
+  if (Array.isArray(value)) return value;
+  return [];
+}
+function cleanObjectValue(obj, model) {
+  if (obj.value !== void 0 && obj.label !== void 0 && typeof obj.value === "string") {
+    return obj.value;
+  }
+  return processNestedObject(obj, model) ?? void 0;
+}
+function cleanInputEntry(key, value, booleanFields, enumArrayFields, requiredArrayFields, model) {
+  if (booleanFields.has(key) && value === void 0) return [key, false];
+  if (enumArrayFields.has(key)) return [key, cleanEnumArrayValue(value)];
+  if (requiredArrayFields.has(key) && (value === void 0 || value === null || value === "")) {
+    return [key, []];
+  }
+  if (shouldSkipValue(key, value)) return null;
+  if (typeof value === "string") {
+    const field = model?.fields?.find((f) => f.name === key);
+    return [key, convertStringValue(value, field)];
+  }
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    const cleaned = cleanObjectValue(value, model);
+    if (cleaned === void 0) return null;
+    return [key, cleaned];
+  }
+  return [key, value];
+}
 function convertStringValue(value, field) {
   if (value === "") {
     return null;
@@ -421,7 +460,7 @@ function convertStringValue(value, field) {
     try {
       const date = new Date(value);
       return date.toISOString();
-    } catch (e) {
+    } catch {
       return value;
     }
   }
@@ -433,7 +472,7 @@ function convertStringValue(value, field) {
     const numericPattern = /^-?\d+(\.\d+)?$/;
     if (numericPattern.test(value)) {
       const numericValue = Number(value);
-      if (!isNaN(numericValue)) {
+      if (!Number.isNaN(numericValue)) {
         return numericValue;
       }
     }
@@ -456,55 +495,33 @@ function cleanFormInput(input, model) {
     model?.fields?.filter((field) => field.isList && field.kind === "enum")?.map((field) => field.name) || []
   );
   for (const [key, value] of Object.entries(input)) {
-    if (booleanFields.has(key) && value === void 0) {
-      cleaned[key] = false;
-      continue;
-    }
-    if (enumArrayFields.has(key)) {
-      if (typeof value === "string") {
-        const arrayValue = value.split(",").filter((v) => v.trim() !== "");
-        cleaned[key] = arrayValue;
-        continue;
-      } else if (Array.isArray(value)) {
-        cleaned[key] = value;
-        continue;
-      } else if (value === void 0 || value === null || value === "") {
-        cleaned[key] = [];
-        continue;
-      }
-    }
-    if (requiredArrayFields.has(key) && (value === void 0 || value === null || value === "")) {
-      cleaned[key] = [];
-      continue;
-    }
-    if (shouldSkipValue(key, value)) {
-      continue;
-    }
-    if (typeof value === "string") {
-      const field = model?.fields?.find((f) => f.name === key);
-      const convertedValue = convertStringValue(value, field);
-      cleaned[key] = convertedValue;
-      continue;
-    }
-    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-      const obj = value;
-      if (obj.value !== void 0 && obj.label !== void 0 && typeof obj.value === "string") {
-        cleaned[key] = obj.value;
-        continue;
-      }
-      const processedNested = processNestedObject(obj, model);
-      if (processedNested !== null) {
-        cleaned[key] = processedNested;
-      }
-      continue;
+    const entry = cleanInputEntry(
+      key,
+      value,
+      booleanFields,
+      enumArrayFields,
+      requiredArrayFields,
+      model
+    );
+    if (entry !== null) {
+      cleaned[entry[0]] = entry[1];
     }
-    cleaned[key] = value;
   }
   return cleaned;
 }
+function toReadableText(text) {
+  return text.replaceAll(/([a-z])([A-Z])/g, "$1 $2").replace(/^./, (str) => str.toUpperCase());
+}
+function sanitizeInput(input) {
+  if (!input || typeof input !== "string") return "";
+  return input.replaceAll(/[<>"'%;()&+]/g, "").replaceAll(/javascript:/gi, "").replaceAll(/on\w+\s*=/gi, "").trim().substring(0, 100);
+}
 export {
   buildFormFields,
   cleanFormInput,
   getAdminDocuments,
-  getMutationName
+  getMutationName,
+  sanitizeInput,
+  toKebabCase,
+  toReadableText
 };