@evanschleret/formforgeclient 1.0.0

package/dist/runtime/utils/schema.js

@@ -0,0 +1,309 @@
+import { getFormForgeStringArray, isFormForgeJsonObject, pickFormForgeDataEnvelope } from "./object.js";
+import { normalizeFormForgeCategory } from "./category.js";
+const FIELD_TYPES = [
+  "text",
+  "textarea",
+  "email",
+  "number",
+  "select",
+  "select_menu",
+  "radio",
+  "checkbox",
+  "checkbox_group",
+  "switch",
+  "date",
+  "time",
+  "datetime",
+  "date_range",
+  "datetime_range",
+  "file"
+];
+const CONDITION_TARGET_TYPES = ["page", "field"];
+const CONDITION_ACTIONS = ["show", "hide", "skip", "require", "disable"];
+const CONDITION_MATCHES = ["all", "any"];
+const CONDITION_OPERATORS = [
+  "eq",
+  "neq",
+  "in",
+  "not_in",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "contains",
+  "not_contains",
+  "is_empty",
+  "not_empty"
+];
+function isFieldType(value) {
+  return FIELD_TYPES.includes(value);
+}
+function isConditionTargetType(value) {
+  return CONDITION_TARGET_TYPES.includes(value);
+}
+function isConditionAction(value) {
+  return CONDITION_ACTIONS.includes(value);
+}
+function isConditionMatch(value) {
+  return CONDITION_MATCHES.includes(value);
+}
+function isConditionOperator(value) {
+  return CONDITION_OPERATORS.includes(value);
+}
+function toBoolean(value, fallback) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  return fallback;
+}
+function toString(value, fallback) {
+  if (typeof value === "string") {
+    return value;
+  }
+  return fallback;
+}
+function toNullableString(value) {
+  if (typeof value === "string" || value === null) {
+    return value;
+  }
+  return void 0;
+}
+function toNumberOrStringOrNull(value) {
+  if (typeof value === "number" || typeof value === "string" || value === null) {
+    return value;
+  }
+  return void 0;
+}
+function normalizeOption(option) {
+  if (typeof option === "string" || typeof option === "number" || typeof option === "boolean" || option === null) {
+    return option;
+  }
+  if (isFormForgeJsonObject(option)) {
+    const value = option.value;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) {
+      return {
+        ...option,
+        value
+      };
+    }
+  }
+  return null;
+}
+function normalizeOptions(value) {
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  const options = [];
+  for (const option of value) {
+    const normalizedOption = normalizeOption(option);
+    if (normalizedOption !== null) {
+      options.push(normalizedOption);
+    }
+  }
+  return options;
+}
+function normalizeField(field, index, fallbackPageKey) {
+  const rawType = toString(field.type, "text");
+  const fieldType = isFieldType(rawType) ? rawType : "text";
+  const name = toString(field.name, `field_${index}`);
+  const fieldKey = toString(field.field_key, `${name}_${index}`);
+  const pageKey = toString(field.page_key, fallbackPageKey);
+  const metaValue = field.meta;
+  const meta = isFormForgeJsonObject(metaValue) ? metaValue : {};
+  const rulesValue = field.rules;
+  const rules = getFormForgeStringArray(rulesValue) ?? [];
+  const normalizedField = {
+    field_key: fieldKey,
+    type: fieldType,
+    name,
+    page_key: pageKey,
+    label: typeof field.label === "string" ? field.label : void 0,
+    required: toBoolean(field.required, false),
+    nullable: toBoolean(field.nullable, false),
+    default: field.default ?? null,
+    rules,
+    meta,
+    placeholder: typeof field.placeholder === "string" ? field.placeholder : void 0,
+    help_text: typeof field.help_text === "string" ? field.help_text : void 0,
+    min: toNumberOrStringOrNull(field.min),
+    max: toNumberOrStringOrNull(field.max),
+    step: toNumberOrStringOrNull(field.step),
+    multiple: toBoolean(field.multiple, false),
+    disabled: toBoolean(field.disabled, false),
+    readonly: toBoolean(field.readonly, false),
+    options: normalizeOptions(field.options)
+  };
+  if (fieldType === "file") {
+    const accept = getFormForgeStringArray(field.accept);
+    const maxSize = typeof field.max_size === "number" || field.max_size === null ? field.max_size : void 0;
+    const maxFiles = typeof field.max_files === "number" || field.max_files === null ? field.max_files : void 0;
+    const storageValue = field.storage;
+    const storage = isFormForgeJsonObject(storageValue) ? storageValue : null;
+    return {
+      ...normalizedField,
+      type: "file",
+      accept,
+      max_size: maxSize,
+      max_files: maxFiles,
+      storage
+    };
+  }
+  return normalizedField;
+}
+function normalizeFieldsList(value, fallbackPageKey, indexOffset = 0) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const fields = [];
+  for (const [index, item] of value.entries()) {
+    if (!isFormForgeJsonObject(item)) {
+      continue;
+    }
+    fields.push(normalizeField(item, indexOffset + index, fallbackPageKey));
+  }
+  return fields;
+}
+function normalizePageFieldsFromSections(value, pageKey, indexOffset) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const fields = [];
+  for (const sectionValue of value) {
+    if (!isFormForgeJsonObject(sectionValue)) {
+      continue;
+    }
+    const sectionFields = normalizeFieldsList(sectionValue.fields, pageKey, indexOffset + fields.length);
+    fields.push(...sectionFields);
+  }
+  return fields;
+}
+function normalizePages(value) {
+  if (!Array.isArray(value)) {
+    return {
+      pages: [],
+      fields: []
+    };
+  }
+  const pages = [];
+  const fields = [];
+  for (const [pageIndex, pageValue] of value.entries()) {
+    if (!isFormForgeJsonObject(pageValue)) {
+      continue;
+    }
+    const pageKey = toString(pageValue.page_key, `page_${pageIndex + 1}`);
+    const pageMetaValue = pageValue.meta;
+    const pageMeta = isFormForgeJsonObject(pageMetaValue) ? pageMetaValue : {};
+    const pageFields = Array.isArray(pageValue.fields) ? normalizeFieldsList(pageValue.fields, pageKey, fields.length) : normalizePageFieldsFromSections(pageValue.sections, pageKey, fields.length);
+    fields.push(...pageFields);
+    pages.push({
+      page_key: pageKey,
+      title: toString(pageValue.title, ""),
+      description: toNullableString(pageValue.description),
+      meta: pageMeta,
+      fields: pageFields
+    });
+  }
+  return {
+    pages,
+    fields
+  };
+}
+function buildPagesFromFlatFields(fields) {
+  const pages = [];
+  for (const field of fields) {
+    let page = pages.find((item) => item.page_key === field.page_key);
+    if (page === void 0) {
+      page = {
+        page_key: field.page_key,
+        title: "",
+        description: null,
+        meta: {},
+        fields: []
+      };
+      pages.push(page);
+    }
+    page.fields.push(field);
+  }
+  return pages;
+}
+function normalizeConditionClause(value, index) {
+  if (!isFormForgeJsonObject(value)) {
+    return null;
+  }
+  const operatorRaw = toString(value.operator, "eq");
+  return {
+    field_key: toString(value.field_key, `field_${index + 1}`),
+    operator: isConditionOperator(operatorRaw) ? operatorRaw : "eq",
+    value: value.value ?? null
+  };
+}
+function normalizeConditions(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const conditions = [];
+  for (const [index, item] of value.entries()) {
+    if (!isFormForgeJsonObject(item)) {
+      continue;
+    }
+    const targetTypeRaw = toString(item.target_type, "field");
+    const actionRaw = toString(item.action, "show");
+    const matchRaw = toString(item.match, "all");
+    const whenValue = item.when;
+    const when = [];
+    if (Array.isArray(whenValue)) {
+      for (const [whenIndex, clause] of whenValue.entries()) {
+        const normalizedClause = normalizeConditionClause(clause, whenIndex);
+        if (normalizedClause !== null) {
+          when.push(normalizedClause);
+        }
+      }
+    }
+    conditions.push({
+      condition_key: toString(item.condition_key, `condition_${index + 1}`),
+      target_type: isConditionTargetType(targetTypeRaw) ? targetTypeRaw : "field",
+      target_key: toString(item.target_key, ""),
+      action: isConditionAction(actionRaw) ? actionRaw : "show",
+      match: isConditionMatch(matchRaw) ? matchRaw : "all",
+      when
+    });
+  }
+  return conditions;
+}
+function normalizeDraftSettings(value) {
+  if (!isFormForgeJsonObject(value)) {
+    return {
+      enabled: false
+    };
+  }
+  return {
+    ...value,
+    enabled: toBoolean(value.enabled, false)
+  };
+}
+export function normalizeFormForgeSchema(payload) {
+  const data = pickFormForgeDataEnvelope(payload);
+  const rootFields = normalizeFieldsList(data.fields, "page_1");
+  const normalizedPages = normalizePages(data.pages);
+  const fields = normalizedPages.fields.length > 0 ? normalizedPages.fields : rootFields;
+  const pages = normalizedPages.pages.length > 0 ? normalizedPages.pages : buildPagesFromFlatFields(fields);
+  const apiValue = data.api;
+  const api = isFormForgeJsonObject(apiValue) ? apiValue : {};
+  const metaValue = data.meta;
+  const meta = isFormForgeJsonObject(metaValue) ? metaValue : void 0;
+  const categoryItem = data.category_item === null ? null : normalizeFormForgeCategory(data.category_item);
+  return {
+    key: toString(data.key, ""),
+    version: toString(data.version, ""),
+    title: toString(data.title, ""),
+    category: typeof data.category === "string" || data.category === null ? data.category : void 0,
+    category_item: categoryItem ?? void 0,
+    is_published: toBoolean(data.is_published, false),
+    fields,
+    pages,
+    conditions: normalizeConditions(data.conditions),
+    drafts: normalizeDraftSettings(data.drafts),
+    api,
+    meta
+  };
+}

package/dist/runtime/utils/submission.d.ts

@@ -0,0 +1,4 @@
+import type { FormForgeJsonSubmissionPayload, FormForgeJsonSubmissionValue, FormForgeSubmissionPayload, FormForgeSubmissionValue } from '../types/index.js';
+export declare function toFormForgeJsonSubmissionValue(value: FormForgeSubmissionValue | undefined): FormForgeJsonSubmissionValue | undefined;
+export declare function toFormForgeJsonSubmissionPayload(payload: FormForgeSubmissionPayload): FormForgeJsonSubmissionPayload;
+//# sourceMappingURL=submission.d.ts.map

package/dist/runtime/utils/submission.js

@@ -0,0 +1,45 @@
+function isFileValue(value) {
+  if (typeof File === "undefined") {
+    return false;
+  }
+  return value instanceof File;
+}
+export function toFormForgeJsonSubmissionValue(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (isFileValue(value)) {
+    return void 0;
+  }
+  if (Array.isArray(value)) {
+    const arrayValue = [];
+    for (const item of value) {
+      const normalizedItem = toFormForgeJsonSubmissionValue(item);
+      if (normalizedItem !== void 0) {
+        arrayValue.push(normalizedItem);
+      }
+    }
+    return arrayValue;
+  }
+  const objectValue = {};
+  for (const [key, nestedValue] of Object.entries(value)) {
+    const normalizedNestedValue = toFormForgeJsonSubmissionValue(nestedValue);
+    if (normalizedNestedValue !== void 0) {
+      objectValue[key] = normalizedNestedValue;
+    }
+  }
+  return objectValue;
+}
+export function toFormForgeJsonSubmissionPayload(payload) {
+  const normalizedPayload = {};
+  for (const [key, value] of Object.entries(payload)) {
+    const normalizedValue = toFormForgeJsonSubmissionValue(value);
+    if (normalizedValue !== void 0) {
+      normalizedPayload[key] = normalizedValue;
+    }
+  }
+  return normalizedPayload;
+}

package/dist/runtime/validation/errors.d.ts

@@ -0,0 +1,5 @@
+import type { FormForgeClientError, FormForgeJsonObject, FormForgeValidationErrorPayload } from '../types/index.js';
+export declare function normalizeFormForgeClientError(status: number, payload: FormForgeJsonObject | null): FormForgeClientError;
+export declare function normalizeNetworkFormForgeError(message: string): FormForgeClientError;
+export declare function parseFormForgeValidationPayload(payload: FormForgeJsonObject | null): FormForgeValidationErrorPayload;
+//# sourceMappingURL=errors.d.ts.map

package/dist/runtime/validation/errors.js

@@ -0,0 +1,130 @@
+import { isFormForgeJsonObject } from "../utils/object.js";
+function mapStatusToCode(status) {
+  if (status === 401) {
+    return "unauthorized";
+  }
+  if (status === 403) {
+    return "forbidden";
+  }
+  if (status === 404) {
+    return "not_found";
+  }
+  if (status === 409) {
+    return "conflict";
+  }
+  if (status === 422) {
+    return "validation";
+  }
+  if (status === 429) {
+    return "rate_limited";
+  }
+  if (status >= 500) {
+    return "server_error";
+  }
+  return "network_error";
+}
+function extractValidationErrors(payload) {
+  if (payload === null) {
+    return void 0;
+  }
+  const rawErrors = payload.errors;
+  if (!isFormForgeJsonObject(rawErrors)) {
+    return void 0;
+  }
+  const fieldErrors = {};
+  for (const [fieldName, fieldValue] of Object.entries(rawErrors)) {
+    if (!Array.isArray(fieldValue)) {
+      continue;
+    }
+    const messages = [];
+    for (const item of fieldValue) {
+      if (typeof item === "string") {
+        messages.push(item);
+      }
+    }
+    if (messages.length > 0) {
+      fieldErrors[fieldName] = messages;
+    }
+  }
+  if (Object.keys(fieldErrors).length === 0) {
+    return void 0;
+  }
+  return fieldErrors;
+}
+function extractMessage(payload) {
+  if (payload === null) {
+    return "Network error";
+  }
+  const messageValue = payload.message;
+  if (typeof messageValue === "string" && messageValue.length > 0) {
+    return messageValue;
+  }
+  return "Request failed";
+}
+function collectPayloadMessages(payload) {
+  if (payload === null) {
+    return [];
+  }
+  const messages = [];
+  const messageValue = payload.message;
+  if (typeof messageValue === "string" && messageValue.trim() !== "") {
+    messages.push(messageValue.trim());
+  }
+  const validationErrors = extractValidationErrors(payload);
+  if (validationErrors !== void 0) {
+    for (const [fieldName, fieldMessages] of Object.entries(validationErrors)) {
+      messages.push(fieldName);
+      for (const fieldMessage of fieldMessages) {
+        if (fieldMessage.trim() !== "") {
+          messages.push(fieldMessage.trim());
+        }
+      }
+    }
+  }
+  return messages;
+}
+function hasCategoryInUseConflict(status, payload) {
+  if (status !== 409) {
+    return false;
+  }
+  const flattened = collectPayloadMessages(payload).map((message) => message.toLowerCase()).join(" ");
+  if (flattened === "") {
+    return false;
+  }
+  const mentionsCategory = flattened.includes("category") || flattened.includes("cat\xE9gorie");
+  const mentionsInUse = flattened.includes("in use") || flattened.includes("linked") || flattened.includes("attach") || flattened.includes("used") || flattened.includes("utilis") || flattened.includes("li\xE9e");
+  return mentionsCategory && mentionsInUse;
+}
+export function normalizeFormForgeClientError(status, payload) {
+  return {
+    status,
+    code: mapStatusToCode(status),
+    message: extractMessage(payload),
+    businessCode: hasCategoryInUseConflict(status, payload) ? "CATEGORY_IN_USE" : void 0,
+    fieldErrors: extractValidationErrors(payload),
+    raw: payload
+  };
+}
+export function normalizeNetworkFormForgeError(message) {
+  return {
+    status: 0,
+    code: "network_error",
+    message,
+    raw: null
+  };
+}
+export function parseFormForgeValidationPayload(payload) {
+  if (payload === null) {
+    return {};
+  }
+  const response = {};
+  const messageValue = payload.message;
+  if (typeof messageValue === "string") {
+    response.message = messageValue;
+  }
+  const errors = extractValidationErrors(payload);
+  if (errors !== void 0) {
+    response.errors = errors;
+  }
+  return response;
+}

package/dist/runtime/validation/zod.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import type { FormForgeFormSchema, FormForgeSubmissionPayload } from '../types/index.js';
+export declare function createFormForgeZodSchema(form: FormForgeFormSchema): z.ZodTypeAny;
+export declare function mapFormForgeZodIssues(error: z.ZodError): Record<string, string[]>;
+export declare function validateFormForgePayload(schema: z.ZodTypeAny, payload: FormForgeSubmissionPayload): Record<string, string[]>;
+//# sourceMappingURL=zod.d.ts.map

package/dist/runtime/validation/zod.js

@@ -0,0 +1,203 @@
+import { z } from "zod";
+const scalarOptionSchema = z.union([z.string(), z.number(), z.boolean(), z.null()]);
+function applySharedStringRules(baseSchema, rules) {
+  let schema = baseSchema;
+  for (const rawRule of rules) {
+    const [ruleName, ruleArgument] = rawRule.split(":");
+    if (ruleName === "email") {
+      schema = schema.email();
+      continue;
+    }
+    if (ruleName === "min" && ruleArgument !== void 0) {
+      const parsedMin = Number.parseInt(ruleArgument, 10);
+      if (!Number.isNaN(parsedMin)) {
+        schema = schema.min(parsedMin);
+      }
+      continue;
+    }
+    if (ruleName === "max" && ruleArgument !== void 0) {
+      const parsedMax = Number.parseInt(ruleArgument, 10);
+      if (!Number.isNaN(parsedMax)) {
+        schema = schema.max(parsedMax);
+      }
+      continue;
+    }
+  }
+  return schema;
+}
+function applyArrayRules(baseSchema, rules) {
+  let schema = baseSchema;
+  for (const rawRule of rules) {
+    const [ruleName, ruleArgument] = rawRule.split(":");
+    if (ruleName === "min" && ruleArgument !== void 0) {
+      const parsedMin = Number.parseInt(ruleArgument, 10);
+      if (!Number.isNaN(parsedMin)) {
+        schema = schema.min(parsedMin);
+      }
+      continue;
+    }
+    if (ruleName === "max" && ruleArgument !== void 0) {
+      const parsedMax = Number.parseInt(ruleArgument, 10);
+      if (!Number.isNaN(parsedMax)) {
+        schema = schema.max(parsedMax);
+      }
+      continue;
+    }
+  }
+  return schema;
+}
+function applyNumberRules(baseSchema, rules) {
+  let schema = baseSchema;
+  for (const rawRule of rules) {
+    const [ruleName, ruleArgument] = rawRule.split(":");
+    if (ruleName === "min" && ruleArgument !== void 0) {
+      const parsedMin = Number.parseFloat(ruleArgument);
+      if (!Number.isNaN(parsedMin)) {
+        schema = schema.min(parsedMin);
+      }
+      continue;
+    }
+    if (ruleName === "max" && ruleArgument !== void 0) {
+      const parsedMax = Number.parseFloat(ruleArgument);
+      if (!Number.isNaN(parsedMax)) {
+        schema = schema.max(parsedMax);
+      }
+      continue;
+    }
+  }
+  return schema;
+}
+function buildFieldBaseSchema(field) {
+  if (field.type === "text" || field.type === "textarea" || field.type === "email") {
+    return applySharedStringRules(z.string(), field.rules);
+  }
+  if (field.type === "number") {
+    return applyNumberRules(z.number(), field.rules);
+  }
+  if (field.type === "select" || field.type === "select_menu" || field.type === "radio") {
+    return scalarOptionSchema;
+  }
+  if (field.type === "checkbox" || field.type === "switch") {
+    return z.boolean();
+  }
+  if (field.type === "checkbox_group") {
+    return applyArrayRules(z.array(scalarOptionSchema), field.rules);
+  }
+  if (field.type === "date" || field.type === "time" || field.type === "datetime") {
+    return applySharedStringRules(z.string(), field.rules);
+  }
+  if (field.type === "date_range" || field.type === "datetime_range") {
+    return z.object({
+      start: z.string().nullable(),
+      end: z.string().nullable()
+    });
+  }
+  if (field.type === "file") {
+    const fileSchema = z.custom((value) => {
+      if (typeof File === "undefined") {
+        return false;
+      }
+      return value instanceof File;
+    });
+    if (field.multiple === true) {
+      return z.array(fileSchema);
+    }
+    return fileSchema;
+  }
+  return scalarOptionSchema;
+}
+function applyRequiredAndNullable(schema, field) {
+  const optionalSchema = schema.optional();
+  if (field.required === false) {
+    return z.preprocess((value) => {
+      if (value === void 0 || value === null) {
+        return void 0;
+      }
+      if (typeof value === "string" && value.trim() === "") {
+        return void 0;
+      }
+      if ((field.type === "date_range" || field.type === "datetime_range") && typeof value === "object" && value !== null) {
+        const rangeValue = value;
+        const isStartEmpty = rangeValue.start === void 0 || rangeValue.start === null || rangeValue.start === "";
+        const isEndEmpty = rangeValue.end === void 0 || rangeValue.end === null || rangeValue.end === "";
+        if (isStartEmpty && isEndEmpty) {
+          return void 0;
+        }
+      }
+      if (field.type === "checkbox_group" && Array.isArray(value) && value.length === 0) {
+        return void 0;
+      }
+      return value;
+    }, optionalSchema);
+  }
+  if (field.type === "text" || field.type === "textarea" || field.type === "email" || field.type === "date" || field.type === "time" || field.type === "datetime") {
+    return schema.refine((value) => {
+      return typeof value === "string" && value.trim() !== "";
+    }, {
+      message: "Required"
+    });
+  }
+  if (field.type === "select" || field.type === "select_menu" || field.type === "radio") {
+    return schema.refine((value) => {
+      if (value === null || value === void 0) {
+        return false;
+      }
+      if (typeof value === "string" && value.trim() === "") {
+        return false;
+      }
+      return true;
+    }, {
+      message: "Required"
+    });
+  }
+  if (field.type === "checkbox_group") {
+    return schema.refine((value) => {
+      return Array.isArray(value) && value.length > 0;
+    }, {
+      message: "Required"
+    });
+  }
+  if (field.type === "date_range" || field.type === "datetime_range") {
+    return schema.refine((value) => {
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+      }
+      const rangeValue = value;
+      const isStartValid = typeof rangeValue.start === "string" && rangeValue.start !== "";
+      const isEndValid = typeof rangeValue.end === "string" && rangeValue.end !== "";
+      return isStartValid && isEndValid;
+    }, {
+      message: "Required"
+    });
+  }
+  return schema;
+}
+export function createFormForgeZodSchema(form) {
+  const shape = {};
+  for (const field of form.fields) {
+    const baseSchema = buildFieldBaseSchema(field);
+    shape[field.name] = applyRequiredAndNullable(baseSchema, field);
+  }
+  return z.object(shape);
+}
+export function mapFormForgeZodIssues(error) {
+  const fieldErrors = {};
+  for (const issue of error.issues) {
+    const [fieldName] = issue.path;
+    if (typeof fieldName !== "string") {
+      continue;
+    }
+    if (fieldErrors[fieldName] === void 0) {
+      fieldErrors[fieldName] = [];
+    }
+    fieldErrors[fieldName].push(issue.message);
+  }
+  return fieldErrors;
+}
+export function validateFormForgePayload(schema, payload) {
+  const result = schema.safeParse(payload);
+  if (result.success) {
+    return {};
+  }
+  return mapFormForgeZodIssues(result.error);
+}