@qoretechnologies/reqraft 0.10.35-pr.92.ga86e098 → 0.10.35

package/src/helpers/common.ts

@@ -174,6 +174,42 @@ export const splitByteSize = (value?: string): [number | undefined, string | und
   return [amount?.[0] ? Number(amount[0]) : undefined, unit?.[0]];
 };
 
+export type TTimeoutUnit = 'ms' | 'seconds' | 'minutes' | 'hours';
+
+/** Timeout display units, smallest → largest, with the ms multiplier each one
+ * scales by and the symbol shown where space is tight (phone-width selector).
+ * The stored value is always the integer millisecond count. */
+export const TIMEOUT_UNITS: { value: TTimeoutUnit; ms: number; short: string }[] = [
+  { value: 'ms', ms: 1, short: 'ms' },
+  { value: 'seconds', ms: 1000, short: 's' },
+  { value: 'minutes', ms: 60000, short: 'm' },
+  { value: 'hours', ms: 3600000, short: 'h' },
+];
+
+export const timeoutUnitToMs = (unit: TTimeoutUnit): number =>
+  TIMEOUT_UNITS.find(({ value }) => value === unit)!.ms;
+
+export const timeoutUnitSymbol = (unit: TTimeoutUnit): string =>
+  TIMEOUT_UNITS.find(({ value }) => value === unit)!.short;
+
+/** The largest unit that represents `value` without rounding (45000 →
+ * seconds, 90500 → ms). Zero divides evenly by everything, so it stays ms. */
+export const getLargestExactTimeoutUnit = (value?: number): TTimeoutUnit => {
+  for (let i = TIMEOUT_UNITS.length - 1; i >= 0; i--) {
+    if (value != null && value !== 0 && value % TIMEOUT_UNITS[i].ms === 0) {
+      return TIMEOUT_UNITS[i].value;
+    }
+  }
+  return 'ms';
+};
+
+/** Human-readable timeout (e.g. `"45 seconds"`) — scaled to the largest unit
+ * that represents the millisecond count exactly (90500 → `"90500 ms"`). */
+export const formatTimeoutValue = (ms: number): string => {
+  const unit = getLargestExactTimeoutUnit(ms);
+  return `${ms / timeoutUnitToMs(unit)} ${unit}`;
+};
+
 /** Human-readable file size, e.g. `"12.3 KB"` — whole bytes below 1 KiB, one
  *  decimal above. Shared by the ticket thread / references attachment rows. */
 export const formatBytes = (bytes: number): string => {

package/src/helpers/validations.ts

@@ -262,20 +262,45 @@ export const _validateField = (
     case 'file': {
       // Support both the Build-tab typed format ({ name: { type, value } })
       // and the Upload-tab flat format ({ name: 'file.txt' })
-      const nameValue = value?.name?.value ?? value?.name;
-      const contentValue = value?.content?.value ?? value?.content;
-      const nameResult = validateFieldWithResult('string', nameValue);
-      const contentResult = validateFieldWithResult('string', contentValue);
-
-      if (!nameResult.isValid) {
-        return withContext(nameResult, 'File name is invalid');
-      }
-
-      if (!contentResult.isValid) {
-        return withContext(contentResult, 'File content is invalid');
-      }
+      //
+      // A Build-tab sub-value is a full option envelope: it carries its own
+      // `type` and may hold an expression (`is_expression`) or a rich-text
+      // paragraph array rather than a bare string. This used to unwrap `.value`
+      // and validate it as a hard-coded `string` with no field, discarding both
+      // the declared type and the expression flag — so a `concat(...)` filename
+      // arrived at the string validator as `{ exp, args }`, rich text arrived as
+      // an array, and both were rejected with "Value must be a non-empty text".
+      //
+      // Validate each part against its OWN type and route `is_expression`
+      // through `isFunction`, exactly as the `system-options` recursion below
+      // does, so the `field?.isFunction` branch above gets a chance to run.
+      const validateFilePart = (part: any, fallbackType: string): IValidationResult => {
+        const isEnvelope = !!part && isObject(part) && ('value' in part || 'is_expression' in part);
+
+        return isEnvelope
+          ? validateFieldWithResult(part.type || fallbackType, part.value, {
+              isFunction: part.is_expression,
+            } as IFieldValidationProps)
+          : validateFieldWithResult(fallbackType, part);
+      };
 
-      return validResult();
+      // Fall back to the arg_schema's declared types for the flat Upload-tab
+      // shape: `name` is `richtext` (which also accepts a plain string) and
+      // `content` is `data`.
+      const nameResult = validateFilePart(value?.name, 'richtext');
+      const contentResult = validateFilePart(value?.content, 'data');
+
+      // Report both parts. Returning on the first failure meant a bad file name
+      // masked the content result entirely, so the form could only ever surface
+      // one problem at a time.
+      const reasons = [
+        ...(nameResult.isValid ? [] : withContext(nameResult, 'File name is invalid').reasons),
+        ...(contentResult.isValid
+          ? []
+          : withContext(contentResult, 'File content is invalid').reasons),
+      ];
+
+      return reasons.length ? invalidResult(reasons) : validResult();
     }
     case 'number': {
       return resultFromBoolean(
@@ -508,6 +533,17 @@ export const _validateField = (
 
       return validResult();
     }
+    case 'timeout': {
+      // An integer count of milliseconds — the unit selector is display-only,
+      // so the stored value validates as an int.
+      const msResult = validateFieldWithResult('int', value);
+
+      if (!msResult.isValid) {
+        return withContext(msResult, 'Timeout must be a whole number of milliseconds');
+      }
+
+      return validResult();
+    }
     case 'url': {
       const protocolResult = validateFieldWithResult('string', getProtocol(value));
 

package/src/types/Form.ts

@@ -8,12 +8,15 @@ export type TFormFieldType =
   | TQorusType
   | 'softint' | 'softstring' | 'softbool' | 'softfloat' | 'softnumber' | 'softdate' | 'softlist'
   | 'byte-size'
+  // the server emits this for a connection's connect_timeout / timeout;
+  // it is not (yet) in ts-toolkit's TQorusType
+  | 'timeout'
   | 'multi-select'
   | 'schema-definition';
 
 export type TFormFieldValueType<T> =
   T extends 'string' | 'long-string' | 'binary' | 'email' | 'url' | 'enum' | 'select-string' | 'file-as-string' | 'byte-size' ? string
-  : T extends 'int' | 'integer' | 'float' | 'number' ? number
+  : T extends 'int' | 'integer' | 'float' | 'number' | 'timeout' ? number
   : T extends 'bool' | 'boolean' ? boolean
   : T extends 'date' ? Date | string
   : T extends 'hash' | 'free-hash' | 'data' ? Record<string, any>