@teleporthq/teleport-plugin-next-workflows 0.43.32 → 0.43.33

package/src/data-api-route-generator.ts

@@ -176,9 +176,26 @@ async function safeQuery(client, sql, params, mode) {
   }
 }
 
-function buildWhereClause(filters, queryParams, startIndex) {
+function isSkippableFilterValue(value) {
+  if (value === undefined || value === null) return true;
+  if (typeof value === 'string' && value.trim() === '') return true;
+  if (Array.isArray(value) && value.length === 0) return true;
+  return false;
+}
+
+function isAllSentinelFilterValue(value, filter) {
+  if (typeof value !== 'string') return false;
+  var normalized = value.trim().toLowerCase();
+  if (filter && typeof filter.treatAsAll === 'string' && filter.treatAsAll.trim().toLowerCase() === normalized) {
+    return true;
+  }
+  return normalized === 'all' || normalized === 'any' || normalized === 'everything' || normalized === '__all__';
+}
+
+function buildWhereClause(filters, queryParams, startIndex, options) {
   var conditions = [];
   var paramIndex = startIndex;
+  var skipOptionalEmpty = !!(options && options.skipOptionalEmpty);
 
   if (!filters || !Array.isArray(filters) || filters.length === 0) {
     return { clause: '', paramIndex: paramIndex };
@@ -194,6 +211,7 @@ function buildWhereClause(filters, queryParams, startIndex) {
     var operand = f.operand || f.operator || '=';
 
     if (value === undefined) continue;
+    if (skipOptionalEmpty && (isSkippableFilterValue(value) || isAllSentinelFilterValue(value, f))) continue;
 
     if (Array.isArray(value)) {
       if (value.length === 0) continue;
@@ -211,6 +229,37 @@ function buildWhereClause(filters, queryParams, startIndex) {
         conditions.push(field + ' IS NOT NULL');
       }
     } else {
+      var normalizedOperand = String(operand || '=').toLowerCase();
+      if (normalizedOperand === 'contains' || normalizedOperand === 'not_contains' || normalizedOperand === 'not-contains') {
+        if (isSkippableFilterValue(value)) {
+          conditions.push('FALSE');
+          continue;
+        }
+        conditions.push(field + (normalizedOperand === 'contains' ? ' ILIKE ' : ' NOT ILIKE ') + '$' + paramIndex);
+        queryParams.push('%' + String(value) + '%');
+        paramIndex++;
+        continue;
+      }
+      if (normalizedOperand === 'startswith' || normalizedOperand === 'starts_with' || normalizedOperand === 'starts-with') {
+        if (isSkippableFilterValue(value)) {
+          conditions.push('FALSE');
+          continue;
+        }
+        conditions.push(field + ' ILIKE $' + paramIndex);
+        queryParams.push(String(value) + '%');
+        paramIndex++;
+        continue;
+      }
+      if (normalizedOperand === 'endswith' || normalizedOperand === 'ends_with' || normalizedOperand === 'ends-with') {
+        if (isSkippableFilterValue(value)) {
+          conditions.push('FALSE');
+          continue;
+        }
+        conditions.push(field + ' ILIKE $' + paramIndex);
+        queryParams.push('%' + String(value));
+        paramIndex++;
+        continue;
+      }
       var validOps = ['=', '!=', '>', '<', '>=', '<=', 'LIKE', 'ILIKE'];
       var sqlOp = validOps.indexOf(operand) !== -1 ? operand : '=';
       conditions.push(field + ' ' + sqlOp + ' $' + paramIndex);
@@ -253,7 +302,7 @@ async function handleSelect(client, body) {
   var cols = selectedColumns.length > 0 ? selectedColumns.join(', ') : '*';
   var sql = 'SELECT ' + cols + ' FROM ' + tableName;
 
-  var where = buildWhereClause(filters, queryParams, 1);
+  var where = buildWhereClause(filters, queryParams, 1, { skipOptionalEmpty: true });
   sql += where.clause;
 
   if (sorts.length > 0) {
@@ -289,7 +338,7 @@ async function handleSelect(client, body) {
 
   var countSql = 'SELECT COUNT(*) FROM ' + tableName;
   var countParams = [];
-  var countWhere = buildWhereClause(filters, countParams, 1);
+  var countWhere = buildWhereClause(filters, countParams, 1, { skipOptionalEmpty: true });
   countSql += countWhere.clause;
   var countResult = await safeQuery(client, countSql, countParams, 'count');
   var count = parseInt(countResult.rows[0].count, 10);
@@ -306,7 +355,7 @@ async function handleCount(client, body) {
 
   var queryParams = [];
   var sql = 'SELECT COUNT(*) FROM ' + tableName;
-  var where = buildWhereClause(filters, queryParams, 1);
+  var where = buildWhereClause(filters, queryParams, 1, { skipOptionalEmpty: true });
   sql += where.clause;
 
   var result = await safeQuery(client, sql, queryParams, 'count');

package/src/nodes/data/data-select.ts

@@ -11,6 +11,42 @@ async function data_select(config: any, context: any) {
   const rawQueryUserPart = config.rawQueryUserPart
   const baseUrl = (context && context.__baseUrl) || ''
 
+  function isEmptyFilterValue(value: any) {
+    if (value === undefined || value === null) return true
+    if (typeof value === 'string' && value.trim() === '') return true
+    if (Array.isArray(value) && value.length === 0) return true
+    return false
+  }
+
+  function isAllSentinel(value: any, filter: any) {
+    if (typeof value !== 'string') return false
+    const normalized = value.trim().toLowerCase()
+    const configured = filter && filter.treatAsAll
+    if (typeof configured === 'string' && configured.trim().toLowerCase() === normalized) {
+      return true
+    }
+    return (
+      normalized === 'all' ||
+      normalized === 'any' ||
+      normalized === 'everything' ||
+      normalized === '__all__'
+    )
+  }
+
+  function shouldSkipOptionalFilter(filter: any) {
+    if (!filter) return true
+    const value = filter.destination !== undefined ? filter.destination : filter.value
+    if (isEmptyFilterValue(value)) return true
+    if (isAllSentinel(value, filter)) return true
+    if (Array.isArray(filter.skipIfValue) && filter.skipIfValue.indexOf(value) !== -1) return true
+    if (filter.skipIfEmpty === true && isEmptyFilterValue(value)) return true
+    return false
+  }
+
+  const effectiveFilters = filters.filter(function (filter: any) {
+    return !shouldSkipOptionalFilter(filter)
+  })
+
   // A filter whose value is the unresolved route-param sentinel (see
   // resolveTemplateTokenString in runtime-utils) — e.g. a select scoped to
   // {{Current Page Entity.id}} that runs on a page with no such route param
@@ -19,8 +55,8 @@ async function data_select(config: any, context: any) {
   // WHOLE workflow (a single unresolvable filter must never kill the note-create
   // submit). Never fall through to an unscoped query. Observable via the warn +
   // the __skippedUnavailableFilter marker.
-  for (let __fi = 0; __fi < filters.length; __fi++) {
-    const __f: any = filters[__fi]
+  for (let __fi = 0; __fi < effectiveFilters.length; __fi++) {
+    const __f: any = effectiveFilters[__fi]
     if (
       __f &&
       (__f.value === '__TQ_UNRESOLVED_ROUTE_PARAM__' ||
@@ -39,7 +75,7 @@ async function data_select(config: any, context: any) {
   }
 
   try {
-    const payload: any = { tableName, filters, sorts, selectedColumns }
+    const payload: any = { tableName, filters: effectiveFilters, sorts, selectedColumns }
     if (limit !== undefined && limit !== null) {
       payload.limit = limit
     }

package/src/nodes/general/general-extract-form-data.ts

@@ -97,11 +97,47 @@ async function general_extract_form_data(config: any, context: Record<string, un
     }
 
     const fieldKeys = Object.keys(fields)
-    const result: Record<string, any> = { fields }
+    const result: Record<string, any> = { fields, formData: fields }
     for (let fi = 0; fi < fieldKeys.length; fi++) {
       result[fieldKeys[fi]] = fields[fieldKeys[fi]]
     }
 
+    // Workflows generated/imported from HTML often refer to a form control by
+    // its DOM id (`class-session-select`) while FormData exposes submitted
+    // values by name (`class_session_id`). Preserve the canonical name keys
+    // above, and add non-overwriting aliases for id/data-form-field-id so both
+    // conventions resolve to the same submitted value.
+    try {
+      const addAlias = (alias: string | null | undefined, name: string | undefined) => {
+        if (!alias || !name) return
+        if (fields[name] === undefined) return
+        if (result[alias] === undefined) {
+          result[alias] = fields[name]
+        }
+      }
+      const controls = (formEl as HTMLFormElement).querySelectorAll(
+        'input[name], select[name], textarea[name], button[name]'
+      )
+      for (let ci = 0; ci < controls.length; ci++) {
+        const control = controls[ci] as HTMLInputElement
+        addAlias(control.id, control.name)
+        addAlias(control.getAttribute('data-form-field-id'), control.name)
+      }
+      const outsideControls = document.querySelectorAll(
+        'input[name], select[name], textarea[name], button[name]'
+      )
+      for (let oi = 0; oi < outsideControls.length; oi++) {
+        const control = outsideControls[oi] as HTMLInputElement
+        if (formEl.contains(control)) continue
+        const ownerForm = control.closest('form')
+        if (ownerForm && ownerForm !== formEl) continue
+        addAlias(control.id, control.name)
+        addAlias(control.getAttribute('data-form-field-id'), control.name)
+      }
+    } catch (_aliasErr) {
+      /* aliases are best-effort; canonical name-based fields remain intact */
+    }
+
     // Diagnostic: surface any required inputs whose value is empty at extraction
     // time so downstream custom-JS validators have something concrete to report
     // instead of a generic "please fill in all required fields" message.