@saastro/forms 0.1.3

package/dist/chunk-YXKDN3PU.js

@@ -0,0 +1,687 @@
+// src/utils/submitActionExecutors.ts
+function replacePlaceholders(template, values) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_, fieldName) => {
+    const value = values[fieldName];
+    if (value === void 0 || value === null) return "";
+    if (typeof value === "object") return JSON.stringify(value);
+    return String(value);
+  });
+}
+function filterFields(values, includeFields, excludeFields) {
+  let result = { ...values };
+  if (includeFields && includeFields.length > 0) {
+    result = {};
+    for (const field of includeFields) {
+      if (field in values) {
+        result[field] = values[field];
+      }
+    }
+  }
+  if (excludeFields && excludeFields.length > 0) {
+    for (const field of excludeFields) {
+      delete result[field];
+    }
+  }
+  return result;
+}
+function buildAuthHeaders(auth) {
+  if (!auth || auth.type === "none") return {};
+  switch (auth.type) {
+    case "bearer":
+      return auth.token ? { Authorization: `Bearer ${auth.token}` } : {};
+    case "basic":
+      if (auth.username && auth.password) {
+        const credentials = btoa(`${auth.username}:${auth.password}`);
+        return { Authorization: `Basic ${credentials}` };
+      }
+      return {};
+    case "api-key":
+      if (auth.token) {
+        const headerName = auth.headerName || "X-API-Key";
+        return { [headerName]: auth.token };
+      }
+      return {};
+    default:
+      return {};
+  }
+}
+function buildRequestBody(values, bodyConfig) {
+  const filteredValues = filterFields(values, bodyConfig?.includeFields, bodyConfig?.excludeFields);
+  const format = bodyConfig?.format || "json";
+  switch (format) {
+    case "json": {
+      const data = bodyConfig?.template ? JSON.parse(replacePlaceholders(bodyConfig.template, values)) : filteredValues;
+      return {
+        body: JSON.stringify(data),
+        contentType: "application/json"
+      };
+    }
+    case "form-data": {
+      const formData = new FormData();
+      for (const [key, value] of Object.entries(filteredValues)) {
+        if (value instanceof File) {
+          formData.append(key, value);
+        } else if (value !== void 0 && value !== null) {
+          formData.append(key, String(value));
+        }
+      }
+      return {
+        body: formData,
+        contentType: ""
+        // Browser sets this automatically with boundary
+      };
+    }
+    case "url-encoded": {
+      const params = new URLSearchParams();
+      for (const [key, value] of Object.entries(filteredValues)) {
+        if (value !== void 0 && value !== null) {
+          params.append(key, String(value));
+        }
+      }
+      return {
+        body: params.toString(),
+        contentType: "application/x-www-form-urlencoded"
+      };
+    }
+    default:
+      return {
+        body: JSON.stringify(filteredValues),
+        contentType: "application/json"
+      };
+  }
+}
+async function executeWithRetry(fn, retryConfig) {
+  const maxAttempts = retryConfig?.enabled ? retryConfig.maxAttempts : 1;
+  const delayMs = retryConfig?.delayMs || 1e3;
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt < maxAttempts) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs * attempt));
+      }
+    }
+  }
+  throw lastError;
+}
+async function executeHttpAction(action, values) {
+  const { endpoint, body: bodyConfig, auth, retry, timeout = 3e4 } = action;
+  const execute = async () => {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const authHeaders = buildAuthHeaders(auth);
+      const { body, contentType } = buildRequestBody(values, bodyConfig);
+      const headers = {
+        ...endpoint.headers,
+        ...authHeaders
+      };
+      if (contentType) {
+        headers["Content-Type"] = contentType;
+      }
+      const response = await fetch(endpoint.url, {
+        method: endpoint.method,
+        headers,
+        body: endpoint.method !== "GET" ? body : void 0,
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => "Unknown error");
+        throw new Error(`HTTP ${response.status}: ${response.statusText} - ${errorText}`);
+      }
+      const responseText = await response.text();
+      try {
+        return JSON.parse(responseText);
+      } catch {
+        return responseText;
+      }
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  };
+  return executeWithRetry(execute, retry);
+}
+async function generateHmacSignature(payload, secret) {
+  const encoder = new TextEncoder();
+  const keyData = encoder.encode(secret);
+  const messageData = encoder.encode(payload);
+  const key = await crypto.subtle.importKey(
+    "raw",
+    keyData,
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign("HMAC", key, messageData);
+  const hashArray = Array.from(new Uint8Array(signature));
+  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function executeWebhookAction(action, values) {
+  const { url, secret, headers = {}, payloadTemplate, includeFields, excludeFields } = action;
+  const filteredValues = filterFields(values, includeFields, excludeFields);
+  const payload = payloadTemplate ? replacePlaceholders(payloadTemplate, values) : JSON.stringify(filteredValues);
+  const requestHeaders = {
+    "Content-Type": "application/json",
+    ...headers
+  };
+  if (secret) {
+    const signature = await generateHmacSignature(payload, secret);
+    requestHeaders["X-Webhook-Signature"] = `sha256=${signature}`;
+  }
+  const response = await fetch(url, {
+    method: "POST",
+    headers: requestHeaders,
+    body: payload
+  });
+  if (!response.ok) {
+    throw new Error(`Webhook failed: ${response.status} ${response.statusText}`);
+  }
+  const responseText = await response.text();
+  try {
+    return JSON.parse(responseText);
+  } catch {
+    return responseText;
+  }
+}
+function generateDefaultEmailTemplate(values) {
+  const rows = Object.entries(values).map(
+    ([key, value]) => `
+      <tr>
+        <td style="padding: 8px; border: 1px solid #ddd; font-weight: bold;">${key}</td>
+        <td style="padding: 8px; border: 1px solid #ddd;">${typeof value === "object" ? JSON.stringify(value) : String(value ?? "")}</td>
+      </tr>
+    `
+  ).join("");
+  return `
+    <!DOCTYPE html>
+    <html>
+    <head>
+      <meta charset="utf-8">
+      <title>Form Submission</title>
+    </head>
+    <body style="font-family: Arial, sans-serif; padding: 20px;">
+      <h2 style="color: #333;">New Form Submission</h2>
+      <table style="border-collapse: collapse; width: 100%; max-width: 600px;">
+        <thead>
+          <tr style="background-color: #f5f5f5;">
+            <th style="padding: 8px; border: 1px solid #ddd; text-align: left;">Field</th>
+            <th style="padding: 8px; border: 1px solid #ddd; text-align: left;">Value</th>
+          </tr>
+        </thead>
+        <tbody>
+          ${rows}
+        </tbody>
+      </table>
+      <p style="color: #666; font-size: 12px; margin-top: 20px;">
+        Sent via @saastro/forms
+      </p>
+    </body>
+    </html>
+  `;
+}
+async function executeEmailAction(action, values) {
+  const {
+    provider,
+    endpoint,
+    apiKey,
+    to,
+    cc,
+    bcc,
+    from,
+    subject,
+    template,
+    customTemplate,
+    replyTo
+  } = action;
+  const recipients = Array.isArray(to) ? to : [to];
+  const emailSubject = replacePlaceholders(subject, values);
+  const emailBody = template === "custom" && customTemplate ? replacePlaceholders(customTemplate, values) : generateDefaultEmailTemplate(values);
+  const payload = {
+    to: recipients,
+    subject: emailSubject,
+    html: emailBody
+  };
+  if (cc) payload.cc = cc;
+  if (bcc) payload.bcc = bcc;
+  if (from) payload.from = from;
+  if (replyTo) payload.replyTo = replyTo;
+  let url;
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  switch (provider) {
+    case "sendgrid":
+      url = endpoint || "https://api.sendgrid.com/v3/mail/send";
+      if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+      payload.personalizations = [{ to: recipients.map((email) => ({ email })) }];
+      payload.content = [{ type: "text/html", value: emailBody }];
+      delete payload.to;
+      delete payload.html;
+      break;
+    case "resend":
+      url = endpoint || "https://api.resend.com/emails";
+      if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+      break;
+    case "mailgun":
+      url = endpoint || "https://api.mailgun.net/v3/YOUR_DOMAIN/messages";
+      if (apiKey) {
+        headers["Authorization"] = `Basic ${btoa(`api:${apiKey}`)}`;
+      }
+      break;
+    case "smtp":
+    default:
+      url = endpoint || "/api/send-email";
+      break;
+  }
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => "Unknown error");
+    throw new Error(`Email failed: ${response.status} - ${errorText}`);
+  }
+  return response.json().catch(() => ({ success: true }));
+}
+async function executeCustomAction(action, values) {
+  return action.handler(values);
+}
+async function executeSubmitAction(action, values) {
+  switch (action.type) {
+    case "http":
+      return executeHttpAction(action, values);
+    case "webhook":
+      return executeWebhookAction(action, values);
+    case "email":
+      return executeEmailAction(action, values);
+    case "custom":
+      return executeCustomAction(action, values);
+    default:
+      throw new Error(`Unknown action type: ${action.type}`);
+  }
+}
+
+// src/utils/fieldMapping.ts
+function isAdvancedMapping(mapping) {
+  if (typeof mapping !== "object" || mapping === null) return false;
+  return "fields" in mapping || "inject" in mapping || "exclude" in mapping || "passthrough" in mapping;
+}
+function isFieldMapEntry(entry) {
+  return typeof entry === "object" && "to" in entry;
+}
+function isResolver(value) {
+  return typeof value === "object" && value !== null && "$resolver" in value;
+}
+function formatDateYMD(d) {
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+function formatDateDMY(d) {
+  return `${String(d.getDate()).padStart(2, "0")}/${String(d.getMonth() + 1).padStart(2, "0")}/${d.getFullYear()}`;
+}
+function toDate(value) {
+  if (value instanceof Date) return value;
+  return new Date(String(value));
+}
+function applyBuiltinTransform(value, transform) {
+  switch (transform) {
+    case "toString":
+      return value == null ? "" : String(value);
+    case "toNumber":
+      return Number(value);
+    case "toBoolean":
+      return Boolean(value);
+    case "booleanString":
+      return value ? "true" : "false";
+    case "dateISO":
+      return toDate(value).toISOString();
+    case "dateYMD":
+      return formatDateYMD(toDate(value));
+    case "dateDMY":
+      return formatDateDMY(toDate(value));
+    case "dateTimestamp":
+      return toDate(value).getTime();
+    case "trim":
+      return typeof value === "string" ? value.trim() : value;
+    case "lowercase":
+      return typeof value === "string" ? value.toLowerCase() : value;
+    case "uppercase":
+      return typeof value === "string" ? value.toUpperCase() : value;
+    case "emptyToNull":
+      return value === "" || value === void 0 ? null : value;
+    default:
+      return value;
+  }
+}
+function applyTransform(value, transform) {
+  if (typeof transform === "function") {
+    return transform(value);
+  }
+  return applyBuiltinTransform(value, transform);
+}
+async function resolveValue(resolver) {
+  switch (resolver.$resolver) {
+    case "timestamp":
+      return (/* @__PURE__ */ new Date()).toISOString();
+    case "hostname":
+      return typeof window !== "undefined" ? window.location.hostname : "";
+    case "pageUrl":
+      return typeof window !== "undefined" ? window.location.href : "";
+    case "referrer":
+      return typeof document !== "undefined" ? document.referrer : "";
+    case "userAgent":
+      return typeof navigator !== "undefined" ? navigator.userAgent : "";
+    case "urlParam": {
+      if (typeof window === "undefined") return resolver.fallback ?? "";
+      const params = new URLSearchParams(window.location.search);
+      return params.get(resolver.param) ?? resolver.fallback ?? "";
+    }
+    case "ip": {
+      const endpoint = resolver.endpoint || "https://api.ipify.org?format=json";
+      try {
+        const res = await fetch(endpoint);
+        const data = await res.json();
+        return data.ip ?? resolver.fallback ?? "";
+      } catch {
+        return resolver.fallback ?? "";
+      }
+    }
+    case "custom":
+      return resolver.fn();
+    default:
+      return void 0;
+  }
+}
+function resolveValueSync(resolver) {
+  switch (resolver.$resolver) {
+    case "timestamp":
+      return (/* @__PURE__ */ new Date()).toISOString();
+    case "hostname":
+      return typeof window !== "undefined" ? window.location.hostname : "";
+    case "pageUrl":
+      return typeof window !== "undefined" ? window.location.href : "";
+    case "referrer":
+      return typeof document !== "undefined" ? document.referrer : "";
+    case "userAgent":
+      return typeof navigator !== "undefined" ? navigator.userAgent : "";
+    case "urlParam": {
+      if (typeof window === "undefined") return resolver.fallback ?? "";
+      const params = new URLSearchParams(window.location.search);
+      return params.get(resolver.param) ?? resolver.fallback ?? "";
+    }
+    case "ip":
+      return resolver.fallback ?? "[fetching IP...]";
+    case "custom":
+      return "[custom resolver]";
+    default:
+      return void 0;
+  }
+}
+async function applyFieldMapping(values, mapping) {
+  if (!isAdvancedMapping(mapping)) {
+    const result2 = {};
+    for (const [key, value] of Object.entries(values)) {
+      const mappedKey = mapping[key] || key;
+      result2[mappedKey] = value;
+    }
+    return result2;
+  }
+  const { fields, inject, exclude, passthrough = true } = mapping;
+  const excludeSet = new Set(exclude || []);
+  const mappedKeys = /* @__PURE__ */ new Set();
+  const result = {};
+  if (fields) {
+    for (const [formKey, target] of Object.entries(fields)) {
+      mappedKeys.add(formKey);
+      if (excludeSet.has(formKey)) continue;
+      const rawValue = values[formKey];
+      if (isFieldMapEntry(target)) {
+        result[target.to] = target.transform ? applyTransform(rawValue, target.transform) : rawValue;
+      } else {
+        result[target] = rawValue;
+      }
+    }
+  }
+  if (passthrough) {
+    for (const [key, value] of Object.entries(values)) {
+      if (!mappedKeys.has(key) && !excludeSet.has(key)) {
+        result[key] = value;
+      }
+    }
+  }
+  if (inject) {
+    const entries = Object.entries(inject);
+    const resolverEntries = entries.filter(([, v]) => isResolver(v));
+    const staticEntries = entries.filter(([, v]) => !isResolver(v));
+    for (const [key, value] of staticEntries) {
+      result[key] = value;
+    }
+    if (resolverEntries.length > 0) {
+      const resolved = await Promise.all(
+        resolverEntries.map(async ([key, value]) => ({
+          key,
+          value: await resolveValue(value)
+        }))
+      );
+      for (const { key, value } of resolved) {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+}
+function applyFieldMappingSync(values, mapping) {
+  if (!isAdvancedMapping(mapping)) {
+    const result2 = {};
+    for (const [key, value] of Object.entries(values)) {
+      const mappedKey = mapping[key] || key;
+      result2[mappedKey] = value;
+    }
+    return result2;
+  }
+  const { fields, inject, exclude, passthrough = true } = mapping;
+  const excludeSet = new Set(exclude || []);
+  const mappedKeys = /* @__PURE__ */ new Set();
+  const result = {};
+  if (fields) {
+    for (const [formKey, target] of Object.entries(fields)) {
+      mappedKeys.add(formKey);
+      if (excludeSet.has(formKey)) continue;
+      const rawValue = values[formKey];
+      if (isFieldMapEntry(target)) {
+        result[target.to] = target.transform ? applyTransform(rawValue, target.transform) : rawValue;
+      } else {
+        result[target] = rawValue;
+      }
+    }
+  }
+  if (passthrough) {
+    for (const [key, value] of Object.entries(values)) {
+      if (!mappedKeys.has(key) && !excludeSet.has(key)) {
+        result[key] = value;
+      }
+    }
+  }
+  if (inject) {
+    for (const [key, value] of Object.entries(inject)) {
+      if (isResolver(value)) {
+        result[key] = resolveValueSync(value);
+      } else {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+}
+function applyFieldTransforms(fields, values) {
+  const result = { ...values };
+  for (const [fieldName, fieldConfig] of Object.entries(fields)) {
+    const transform = fieldConfig?.transform;
+    if (!transform || !(fieldName in result)) continue;
+    if (typeof transform === "function") {
+      result[fieldName] = transform(result[fieldName]);
+    } else if (Array.isArray(transform)) {
+      result[fieldName] = transform.reduce(
+        (v, t) => applyBuiltinTransform(v, t),
+        result[fieldName]
+      );
+    } else {
+      result[fieldName] = applyBuiltinTransform(result[fieldName], transform);
+    }
+  }
+  return result;
+}
+
+// src/utils/submitOrchestrator.ts
+function evaluateCondition(condition, values) {
+  const fieldValue = values[condition.field];
+  const compareValue = condition.value;
+  const operators = {
+    equals: (a, b) => a === b,
+    notEquals: (a, b) => a !== b,
+    contains: (a, b) => typeof a === "string" && typeof b === "string" && a.includes(b),
+    notContains: (a, b) => typeof a === "string" && typeof b === "string" && !a.includes(b),
+    greaterThan: (a, b) => Number(a) > Number(b),
+    lessThan: (a, b) => Number(a) < Number(b),
+    greaterThanOrEqual: (a, b) => Number(a) >= Number(b),
+    lessThanOrEqual: (a, b) => Number(a) <= Number(b),
+    isTrue: (a) => a === true || a === "true" || a === 1,
+    isFalse: (a) => a === false || a === "false" || a === 0,
+    isEmpty: (a) => a === void 0 || a === null || a === "" || Array.isArray(a) && a.length === 0,
+    isNotEmpty: (a) => a !== void 0 && a !== null && a !== "" && !(Array.isArray(a) && a.length === 0)
+  };
+  const evaluator = operators[condition.operator];
+  return evaluator ? evaluator(fieldValue, compareValue) : true;
+}
+function getActionsByTrigger(config, triggerType, triggerValue) {
+  const actions = config.submitActions;
+  if (!actions) return [];
+  return Object.values(actions).filter((node) => {
+    if (node.disabled) return false;
+    if (node.trigger.type !== triggerType) return false;
+    switch (triggerType) {
+      case "onStepEnter":
+      case "onStepExit":
+        return !node.trigger.stepId || node.trigger.stepId === triggerValue;
+      case "onFieldChange":
+      case "onFieldBlur":
+        return !node.trigger.fieldName || node.trigger.fieldName === triggerValue;
+      default:
+        return true;
+    }
+  });
+}
+function getMinDelayMs(config) {
+  const actions = config.submitActions;
+  if (!actions) return 0;
+  const delayActions = Object.values(actions).filter(
+    (node) => !node.disabled && node.trigger.type === "onDelay"
+  );
+  if (delayActions.length === 0) return 0;
+  return Math.min(...delayActions.map((node) => node.trigger.delayMs || 3e4));
+}
+async function executeActionNode(node, values) {
+  const startedAt = /* @__PURE__ */ new Date();
+  if (node.condition && !evaluateCondition(node.condition, values)) {
+    return {
+      actionId: node.id,
+      actionName: node.action.name,
+      success: true,
+      data: { skipped: true, reason: "Condition not met" },
+      durationMs: 0,
+      startedAt,
+      completedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  const mappedValues = node.fieldMapping ? await applyFieldMapping(values, node.fieldMapping) : values;
+  try {
+    const data = await executeSubmitAction(node.action, mappedValues);
+    const completedAt = /* @__PURE__ */ new Date();
+    return {
+      actionId: node.id,
+      actionName: node.action.name,
+      success: true,
+      data,
+      durationMs: completedAt.getTime() - startedAt.getTime(),
+      startedAt,
+      completedAt
+    };
+  } catch (err) {
+    const completedAt = /* @__PURE__ */ new Date();
+    const error = err instanceof Error ? err : new Error(String(err));
+    return {
+      actionId: node.id,
+      actionName: node.action.name,
+      success: false,
+      error,
+      durationMs: completedAt.getTime() - startedAt.getTime(),
+      startedAt,
+      completedAt
+    };
+  }
+}
+async function executeSubmitActions(actions, values, config) {
+  const startTime = Date.now();
+  const mode = config.submitExecution?.mode || "sequential";
+  const stopOnFirstError = config.submitExecution?.stopOnFirstError ?? false;
+  const sortedActions = [...actions].sort((a, b) => (a.order || 0) - (b.order || 0));
+  const results = [];
+  if (mode === "parallel") {
+    const promises = sortedActions.map((node) => executeActionNode(node, values));
+    const parallelResults = await Promise.all(promises);
+    results.push(...parallelResults);
+  } else {
+    for (const node of sortedActions) {
+      const result = await executeActionNode(node, values);
+      results.push(result);
+      if (!result.success && stopOnFirstError && !node.continueOnError) {
+        break;
+      }
+    }
+  }
+  const successCount = results.filter((r) => r.success).length;
+  const failureCount = results.filter((r) => !r.success).length;
+  return {
+    results,
+    allSuccessful: failureCount === 0,
+    successCount,
+    failureCount,
+    totalDurationMs: Date.now() - startTime
+  };
+}
+async function executeSubmitActionsByTrigger(config, triggerType, values, triggerValue) {
+  const actions = getActionsByTrigger(config, triggerType, triggerValue);
+  if (actions.length === 0) {
+    return {
+      results: [],
+      allSuccessful: true,
+      successCount: 0,
+      failureCount: 0,
+      totalDurationMs: 0
+    };
+  }
+  return executeSubmitActions(actions, values, config);
+}
+
+export {
+  isAdvancedMapping,
+  applyBuiltinTransform,
+  applyTransform,
+  resolveValue,
+  resolveValueSync,
+  applyFieldMapping,
+  applyFieldMappingSync,
+  applyFieldTransforms,
+  executeHttpAction,
+  executeWebhookAction,
+  executeEmailAction,
+  executeCustomAction,
+  executeSubmitAction,
+  getActionsByTrigger,
+  getMinDelayMs,
+  executeSubmitActions,
+  executeSubmitActionsByTrigger
+};
+//# sourceMappingURL=chunk-YXKDN3PU.js.map