@ram_28/kf-ai-sdk 2.0.15 → 2.0.17

package/sdk/components/hooks/useActivityForm/useActivityForm.ts

@@ -8,17 +8,20 @@
 import { useState, useEffect, useCallback, useMemo, useRef } from 'react';
 import { useForm as useReactHookForm } from 'react-hook-form';
 import { useQuery } from '@tanstack/react-query';
-import type { Path, FieldValues } from 'react-hook-form';
 
 import type { Activity } from '../../../workflow/Activity';
-import type {
-  UseActivityFormOptions,
-  UseActivityFormReturn,
-  AllActivityFields,
-} from './types';
+import type { UseActivityFormOptions, UseActivityFormReturn } from './types';
 
+import type { CreateUpdateResponseType } from '../../../types/common';
 import { createActivityResolver } from './createActivityResolver';
 import { createActivityItemProxy } from './createActivityItemProxy';
+import {
+  coerceFieldValue,
+  coerceRecordForForm,
+  createSyncField,
+  createEnhancedRegister,
+  createEnhancedControl,
+} from '../useBDOForm/shared';
 import { toError } from '../../../utils/error-handling';
 import { getBdoSchema } from '../../../api/metadata';
 import {
@@ -28,66 +31,6 @@ import {
 } from '../../../workflow/createFieldFromMeta';
 import type { BaseField } from '../../../bdo/fields/BaseField';
 
-// ============================================================
-// FIELD VALUE COERCION (HTML inputs return strings)
-// ============================================================
-
-/** Coerce form value to match field's expected type before sending to API */
-function coerceFieldValue(
-  field: BaseField<unknown>,
-  value: unknown,
-): unknown {
-  const type = field.meta.Type;
-  // Number: string → number
-  if (typeof value === 'string' && type === 'Number') {
-    return value === '' ? undefined : Number(value);
-  }
-  // Date/DateTime: empty string → undefined
-  if (
-    typeof value === 'string' &&
-    value === '' &&
-    (type === 'Date' || type === 'DateTime')
-  ) {
-    return undefined;
-  }
-  // DateTime: normalize to HH:MM:SS and ensure Z suffix
-  if (typeof value === 'string' && value !== '' && type === 'DateTime') {
-    let normalized = value;
-    if (normalized.endsWith('Z')) normalized = normalized.slice(0, -1);
-    const timePart = normalized.split('T')[1] || '';
-    if ((timePart.match(/:/g) || []).length === 1) {
-      normalized += ':00';
-    }
-    return normalized + 'Z';
-  }
-  return value;
-}
-
-// ============================================================
-// RECORD COERCION (strip trailing Z from DateTime for HTML inputs)
-// ============================================================
-
-/**
- * Coerce record values for form display.
- * Strips trailing 'Z' from DateTime values so `<input type="datetime-local">` works.
- */
-function coerceRecordForForm(
-  fields: Record<string, BaseField<unknown>>,
-  data: Record<string, unknown>,
-): Record<string, unknown> {
-  const result = { ...data };
-  for (const [key, value] of Object.entries(result)) {
-    if (
-      typeof value === 'string' &&
-      fields[key]?.meta.Type === 'DateTime' &&
-      value.endsWith('Z')
-    ) {
-      result[key] = value.slice(0, -1);
-    }
-  }
-  return result;
-}
-
 // ============================================================
 // MAIN HOOK
 // ============================================================
@@ -303,160 +246,64 @@ export function useActivityForm<A extends Activity<any, any, any>>(
   }, [enabled, isMetadataLoading, activityRef, activity_instance_id]);
 
   // ============================================================
-  // SYNC FIELD — validate + send single field value to API
+  // PER-FIELD SYNC (shared with useBDOForm)
   // ============================================================
 
-  const syncField = useCallback(
-    async (fieldName: string) => {
-      if (isComputingRef.current) return;
-      isComputingRef.current = true;
-
-      try {
-        const isValid = await rhf.trigger(fieldName as Path<FieldValues>);
-        if (!isValid) return;
-
-        const rawValue = rhf.getValues(fieldName as any);
-        const field = allFields[fieldName];
-        const value = field
-          ? coerceFieldValue(field, rawValue)
-          : rawValue;
-
-        const response = await activityRef.update(activity_instance_id, {
-          [fieldName]: value,
-        } as any);
-
-        // Field saved — reset dirty state so it's not re-sent on submit
-        rhf.resetField(fieldName as Path<FieldValues>, {
-          defaultValue: rawValue,
-          keepTouched: true,
-          keepError: true,
-        } as any);
-
-        // Update computed/readonly fields from response
-        if (response && typeof response === 'object') {
-          const responseData =
-            (response as any).Data ?? (response as any);
-          if (responseData && typeof responseData === 'object') {
-            const readonlySet = new Set(readonlyFieldNames);
-            for (const key of Object.keys(responseData)) {
-              if (readonlySet.has(key) && responseData[key] !== undefined) {
-                const current = rhf.getValues(key as any);
-                if (current !== responseData[key]) {
-                  rhf.setValue(
-                    key as Path<FieldValues>,
-                    responseData[key] as any,
-                    { shouldDirty: false, shouldValidate: false },
-                  );
-                }
-              }
-            }
-          }
-        }
-      } catch (error) {
-        console.warn('syncField failed:', error);
-      } finally {
-        isComputingRef.current = false;
-      }
-    },
-    [activityRef, readonlyFieldNames, allFields, rhf, activity_instance_id],
+  const syncApiFn = useCallback(
+    (fieldName: string, value: unknown) =>
+      activityRef.update(activity_instance_id, {
+        [fieldName]: value,
+      } as any),
+    [activityRef, activity_instance_id],
   );
 
-  // ============================================================
-  // MODE-AWARE HANDLER ENHANCEMENT
-  // Injects syncField into onChange/onBlur based on consumer's mode
-  // ============================================================
+  const syncField = useMemo(
+    () =>
+      createSyncField({
+        apiFn: syncApiFn,
+        allFields,
+        readonlyFieldNames,
+        rhf,
+        isComputingRef,
+      }),
+    [syncApiFn, allFields, readonlyFieldNames, rhf],
+  );
 
   const syncOnChange = mode === 'onChange' || mode === 'all';
-  const syncOnBlur = mode === 'onBlur' || mode === 'onTouched' || mode === 'all';
+  const syncOnBlur =
+    mode === 'onBlur' || mode === 'onTouched' || mode === 'all';
 
-  // ============================================================
-  // REGISTER (enhanced with mode-aware sync + auto-disable)
-  // ============================================================
-
-  const register = useCallback(
-    (name: string, registerOptions?: any) => {
-      const field = allFields[name];
-      const isReadonly = field ? field.readOnly : false;
-
-      const result = rhf.register(name as Path<FieldValues>, {
-        ...registerOptions,
-        ...(syncOnBlur
-          ? {
-              onBlur: async (e: any) => {
-                await registerOptions?.onBlur?.(e);
-                await syncField(name);
-              },
-            }
-          : {}),
-        ...(syncOnChange
-          ? {
-              onChange: async (e: any) => {
-                await registerOptions?.onChange?.(e);
-                await syncField(name);
-              },
-            }
-          : {}),
-        ...(isReadonly ? { disabled: true } : {}),
-      });
-
-      if (isReadonly) {
-        return { ...result, disabled: true as const };
-      }
-
-      return result;
-    },
+  const register = useMemo(
+    () =>
+      createEnhancedRegister({
+        rhf,
+        allFields,
+        syncField,
+        syncOnBlur,
+        syncOnChange,
+      }),
     [rhf, allFields, syncField, syncOnBlur, syncOnChange],
   ) as UseActivityFormReturn<A>['register'];
 
-  // ============================================================
-  // ENHANCED CONTROL (for Controller — same sync behavior as register)
-  // ============================================================
-
   const enhancedControl = useMemo(
     () =>
-      new Proxy(rhf.control, {
-        get(target, prop, receiver) {
-          if (prop === 'register') {
-            return (name: string, options?: any) => {
-              const result = target.register(name as any, options);
-              const originalOnChange = result.onChange;
-              const originalOnBlur = result.onBlur;
-
-              return {
-                ...result,
-                ...(syncOnChange
-                  ? {
-                      onChange: async (event: any) => {
-                        await originalOnChange(event);
-                        await syncField(name);
-                      },
-                    }
-                  : {}),
-                ...(syncOnBlur
-                  ? {
-                      onBlur: async (event: any) => {
-                        await originalOnBlur(event);
-                        await syncField(name);
-                      },
-                    }
-                  : {}),
-              };
-            };
-          }
-          return Reflect.get(target, prop, receiver);
-        },
+      createEnhancedControl({
+        control: rhf.control,
+        syncField,
+        syncOnBlur,
+        syncOnChange,
       }),
-    [rhf.control, syncField, syncOnChange, syncOnBlur],
+    [rhf.control, syncField, syncOnBlur, syncOnChange],
   );
 
   // ============================================================
-  // HANDLE SUBMIT — activity.update()
+  // HANDLE SUBMIT — activity.update() + activity.complete()
   // ============================================================
 
   const handleSubmit = useCallback(
     (
       onSuccess?: (
-        data: AllActivityFields<A>,
+        data: CreateUpdateResponseType,
         e?: React.BaseSyntheticEvent,
       ) => void | Promise<void>,
       onError?: (
@@ -469,7 +316,7 @@ export function useActivityForm<A extends Activity<any, any, any>>(
           setIsSubmitting(true);
 
           try {
-            // Only send dirty (changed) fields — matches useForm update behavior
+            // Only send dirty (changed) fields — matches useBDOForm behavior
             // Use getValues() to capture Image/File values set via setValue()
             // that RHF resolver doesn't include in `data`
             const cleanedData: Record<string, unknown> = {};
@@ -489,7 +336,7 @@ export function useActivityForm<A extends Activity<any, any, any>>(
                 : value;
             }
 
-            // Save via activity.update()
+            // Send remaining dirty fields via update
             if (Object.keys(cleanedData).length > 0) {
               await activityRef.update(
                 activity_instance_id,
@@ -497,69 +344,10 @@ export function useActivityForm<A extends Activity<any, any, any>>(
               );
             }
 
-            await onSuccess?.(data as AllActivityFields<A>, event);
-          } catch (error) {
-            onError?.(toError(error), event);
-          } finally {
-            setIsSubmitting(false);
-          }
-        },
-        (errors, event) => {
-          onError?.(errors, event);
-        },
-      );
-    },
-    [rhf, activityRef, readonlyFieldNames, allFields, activity_instance_id],
-  ) as UseActivityFormReturn<A>['handleSubmit'];
+            // Complete the activity — advances the workflow
+            const result = await activityRef.complete(activity_instance_id);
 
-  // ============================================================
-  // HANDLE COMPLETE — activity.update() + activity.complete()
-  // ============================================================
-
-  const handleComplete = useCallback(
-    (
-      onSuccess?: (
-        data: AllActivityFields<A>,
-        e?: React.BaseSyntheticEvent,
-      ) => void | Promise<void>,
-      onError?: (
-        error: any,
-        e?: React.BaseSyntheticEvent,
-      ) => void | Promise<void>,
-    ) => {
-      return rhf.handleSubmit(
-        async (data, event) => {
-          setIsSubmitting(true);
-
-          try {
-            // Only send dirty (changed) fields — matches useForm update behavior
-            // Use getValues() to capture Image/File values set via setValue()
-            // that RHF resolver doesn't include in `data`
-            const cleanedData: Record<string, unknown> = {};
-            const readonlySet = new Set(readonlyFieldNames);
-            const dirtyFields = rhf.formState.dirtyFields;
-            const allValues = rhf.getValues() as Record<string, unknown>;
-
-            for (const key of Object.keys(allValues)) {
-              if (readonlySet.has(key) || !dirtyFields[key]) continue;
-              const value =
-                allValues[key] !== undefined
-                  ? allValues[key]
-                  : (data as Record<string, unknown>)[key];
-              const field = allFields[key];
-              cleanedData[key] = field
-                ? coerceFieldValue(field, value)
-                : value;
-            }
-
-            if (Object.keys(cleanedData).length > 0) {
-              await activityRef.update(
-                activity_instance_id,
-                cleanedData as any,
-              );
-            }
-            await activityRef.complete(activity_instance_id);
-            await onSuccess?.(data as AllActivityFields<A>, event);
+            await onSuccess?.(result, event);
           } catch (error) {
             onError?.(toError(error), event);
           } finally {
@@ -572,7 +360,7 @@ export function useActivityForm<A extends Activity<any, any, any>>(
       );
     },
     [rhf, activityRef, readonlyFieldNames, allFields, activity_instance_id],
-  ) as UseActivityFormReturn<A>['handleComplete'];
+  ) as UseActivityFormReturn<A>['handleSubmit'];
 
   // ============================================================
   // CLEAR ERRORS
@@ -598,7 +386,6 @@ export function useActivityForm<A extends Activity<any, any, any>>(
     // Form methods
     register,
     handleSubmit,
-    handleComplete,
     watch: rhf.watch as any,
     setValue: rhf.setValue as any,
     getValues: rhf.getValues as any,

package/sdk/components/hooks/useActivityTable/types.ts

@@ -1,5 +1,4 @@
 import type { Activity } from '../../../workflow/Activity';
-import type { ActivityInstanceFieldsType } from '../../../workflow/types';
 import type { UseTableReturnType, PaginationStateType } from '../useTable/types';
 import type { UseFilterOptionsType } from '../useFilter/types';
 import type { SortType } from '../../../types/common';
@@ -16,17 +15,19 @@ export type ActivityTableStatusType =
   (typeof ActivityTableStatus)[keyof typeof ActivityTableStatus];
 
 /**
- * Row type for activity table data.
- * System fields at top level, entity fields under ADO.
+ * Row type — inferred from Activity's getInProgressList() return type.
+ * Resolves to ActivityInstanceType (proxy with .get()/.set()).
  */
 export type ActivityRowType<A extends Activity<any, any, any>> =
-  A extends Activity<infer E, any, any>
-    ? ActivityInstanceFieldsType & { ADO: E }
+  A extends { getInProgressList(opts?: any): Promise<(infer R)[]> }
+    ? R
     : never;
 
 export interface UseActivityTableOptionsType<
   A extends Activity<any, any, any>,
 > {
+  /** The activity instance to fetch data for */
+  activity: A;
   /** Which operation — determines endpoint (inprogress vs completed) */
   status: ActivityTableStatusType;
   /** Initial state */

package/sdk/components/hooks/useActivityTable/useActivityTable.ts

@@ -7,59 +7,30 @@ import type {
   ActivityRowType,
 } from './types';
 
-const ACTIVITY_SYSTEM_FIELDS = new Set([
-  '_id',
-  'BPInstanceId',
-  'Status',
-  'AssignedTo',
-  'CompletedAt',
-]);
-
-function nestEntityFields(
-  flatRow: Record<string, unknown>,
-): Record<string, unknown> {
-  const result: Record<string, unknown> = {};
-  const ado: Record<string, unknown> = {};
-  for (const [key, value] of Object.entries(flatRow)) {
-    if (ACTIVITY_SYSTEM_FIELDS.has(key)) {
-      result[key] = value;
-    } else {
-      ado[key] = value;
-    }
-  }
-  result.ADO = ado;
-  return result;
-}
-
 export function useActivityTable<A extends Activity<any, any, any>>(
-  activity: A,
   options: UseActivityTableOptionsType<A>,
 ): UseActivityTableReturnType<A> {
-  const { status, ...rest } = options;
+  const { activity, status, ...rest } = options;
   const { businessProcessId, activityId } = activity.meta;
 
-  const ops = useMemo(() => activity._getOps(), [activity]);
-
-  const listFn = useMemo(() => {
-    const rawFn =
+  const listFn = useMemo(
+    () =>
       status === 'inprogress'
-        ? (opts: any) => ops.inProgressList(opts)
-        : (opts: any) => ops.completedList(opts);
-    return async (opts: any) => {
-      const result = await rawFn(opts);
-      return {
-        ...result,
-        Data: result.Data.map(nestEntityFields),
-      } as typeof result;
-    };
-  }, [ops, status]);
+        ? async (opts: any) => ({
+            Data: (await activity.getInProgressList(opts)) as ActivityRowType<A>[],
+          })
+        : async (opts: any) => ({
+            Data: (await activity.getCompletedList(opts)) as ActivityRowType<A>[],
+          }),
+    [activity, status],
+  );
 
   const countFn = useMemo(
     () =>
       status === 'inprogress'
-        ? (opts: any) => ops.inProgressMetric(opts)
-        : (opts: any) => ops.completedMetric(opts),
-    [ops, status],
+        ? async (opts: any) => ({ Count: await activity.inProgressCount(opts) })
+        : async (opts: any) => ({ Count: await activity.completedCount(opts) }),
+    [activity, status],
   );
 
   return useTable<ActivityRowType<A>>({

package/sdk/components/hooks/{useForm → useBDOForm}/index.ts

@@ -1,9 +1,10 @@
-export { useForm } from "./useForm";
+export { useBDOForm } from "./useBDOForm";
 export { createResolver } from "./createResolver";
 export { createItemProxy } from "./createItemProxy";
+export { coerceFieldValue, coerceRecordForForm } from "./shared";
 export type {
-  UseFormOptionsType,
-  UseFormReturnType,
+  UseBDOFormOptionsType,
+  UseBDOFormReturnType,
   FormItemType,
   EditableFormFieldAccessorType,
   ReadonlyFormFieldAccessorType,