ballerina-core 1.0.200 → 1.0.201

package/src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/runner.ts

@@ -1,10 +1,11 @@
-import { Map } from "immutable";
+import { Map, Set } from "immutable";
 import {
   ValueInfiniteStreamState,
   ValueStreamPosition,
 } from "../../../../../../../../value-infinite-data-stream/state";
 import {
   replaceWith,
+  SumNType,
   TableAbstractRendererState,
   Unit,
 } from "../../../../../../../../../main";
@@ -22,7 +23,45 @@ const Co = <CustomPresentationContext = Unit, ExtraContext = Unit>() =>
 
 // TODO -- very unsafe, needs work, checking undefined etc,,,
 const DEFAULT_CHUNK_SIZE = 20;
-// if value exists in entity, use that, otherwise load first chunk from infinite stream
+const initialiseFiltersAndSorting = <
+  CustomPresentationContext = Unit,
+  ExtraContext = Unit,
+>(
+  filterTypes: Map<string, SumNType<any>>,
+) => {
+  return Co<CustomPresentationContext, ExtraContext>().Seq([
+    Co<CustomPresentationContext, ExtraContext>()
+      .GetState()
+      .then((current) => {
+        const getDefaultFiltersAndSorting =
+          current.tableApiSource.getDefaultFiltersAndSorting(filterTypes);
+        return Co<CustomPresentationContext, ExtraContext>()
+          .Await(getDefaultFiltersAndSorting(current.parseFromApiByType), () =>
+            console.error("error getting default filters and sorting"),
+          )
+          .then((filtersAndSorting) => {
+            return filtersAndSorting.kind == "l"
+              ? Co<CustomPresentationContext, ExtraContext>().SetState(
+                  TableAbstractRendererState.Updaters.Core.customFormState.children
+                    .filters(replaceWith(filtersAndSorting.value.filters))
+                    .then(
+                      TableAbstractRendererState.Updaters.Core.customFormState.children.sorting(
+                        replaceWith(filtersAndSorting.value.sorting),
+                      ),
+                    ),
+                )
+              : Co<CustomPresentationContext, ExtraContext>().Wait(0);
+          });
+      }),
+    Co<CustomPresentationContext, ExtraContext>().SetState(
+      TableAbstractRendererState.Updaters.Core.customFormState.children.isFilteringInitialized(
+        // always set to true even if the first call fails so we don't block the flow
+        replaceWith(true),
+      ),
+    ),
+  ]);
+};
+
 const intialiseTable = <
   CustomPresentationContext = Unit,
   ExtraContext = Unit,
@@ -41,53 +80,64 @@ const intialiseTable = <
         current.fromTableApiParser,
       );
 
+      console.debug("params", current.customFormState.filterAndSortParam);
+
+      const params =
+        current.customFormState.filterAndSortParam == ""
+          ? Map<string, string>()
+          : Map([
+              ["filtersAndSorting", current.customFormState.filterAndSortParam],
+            ]);
+
       return Co<CustomPresentationContext, ExtraContext>().SetState(
-        replaceWith(TableAbstractRendererState.Default()).then(
-          TableAbstractRendererState.Updaters.Core.customFormState.children
-            .stream(
-              replaceWith(
-                ValueInfiniteStreamState.Default(
-                  DEFAULT_CHUNK_SIZE,
-                  getChunkWithParams(Map<string, string>()),
-                  initialData.size == 0 && hasMoreValues ? "loadMore" : false,
-                ),
+        TableAbstractRendererState.Updaters.Core.customFormState.children
+          .stream(
+            replaceWith(
+              ValueInfiniteStreamState.Default(
+                DEFAULT_CHUNK_SIZE,
+                getChunkWithParams(params),
+                initialData.size == 0 && hasMoreValues ? "loadMore" : false,
+              ),
+            )
+              .then(
+                ValueInfiniteStreamState.Updaters.Coroutine.addLoadedChunk(0, {
+                  data: initialData,
+                  hasMoreValues: hasMoreValues,
+                  from,
+                  to,
+                }),
               )
-                .then(
-                  ValueInfiniteStreamState.Updaters.Coroutine.addLoadedChunk(
-                    0,
-                    {
-                      data: initialData,
-                      hasMoreValues: hasMoreValues,
-                      from,
-                      to,
-                    },
-                  ),
-                )
-                .then(
-                  ValueInfiniteStreamState.Updaters.Core.position(
-                    ValueStreamPosition.Updaters.Core.nextStart(
-                      replaceWith(to),
-                    ),
-                  ),
+              .then(
+                ValueInfiniteStreamState.Updaters.Core.position(
+                  ValueStreamPosition.Updaters.Core.nextStart(replaceWith(to)),
                 ),
-            )
-            .thenMany([
-              TableAbstractRendererState.Updaters.Core.customFormState.children.getChunkWithParams(
-                replaceWith(getChunkWithParams),
               ),
-              TableAbstractRendererState.Updaters.Template.shouldReinitialize(
-                false,
-              ),
-              TableAbstractRendererState.Updaters.Core.customFormState.children.previousRemoteEntityVersionIdentifier(
-                replaceWith(current.remoteEntityVersionIdentifier),
-              ),
-              TableAbstractRendererState.Updaters.Core.customFormState.children.initializationStatus(
-                replaceWith<
-                  TableAbstractRendererState["customFormState"]["initializationStatus"]
-                >("initialized"),
-              ),
-            ]),
-        ),
+          )
+          .thenMany([
+            TableAbstractRendererState.Updaters.Core.customFormState.children.rowStates(
+              replaceWith(Map()),
+            ),
+            TableAbstractRendererState.Updaters.Core.customFormState.children.selectedRows(
+              replaceWith(Set()),
+            ),
+            TableAbstractRendererState.Updaters.Core.customFormState.children.selectedDetailRow(
+              replaceWith(undefined as any),
+            ),
+            TableAbstractRendererState.Updaters.Core.customFormState.children.getChunkWithParams(
+              replaceWith(getChunkWithParams),
+            ),
+            TableAbstractRendererState.Updaters.Template.shouldReinitialize(
+              false,
+            ),
+            TableAbstractRendererState.Updaters.Core.customFormState.children.previousRemoteEntityVersionIdentifier(
+              replaceWith(current.remoteEntityVersionIdentifier),
+            ),
+            TableAbstractRendererState.Updaters.Core.customFormState.children.initializationStatus(
+              replaceWith<
+                TableAbstractRendererState["customFormState"]["initializationStatus"]
+              >("initialized"),
+            ),
+          ]),
       );
     });
 
@@ -107,6 +157,22 @@ const reinitialise = <
       );
     });
 
+export const TableInitialiseFiltersAndSortingRunner = <
+  CustomPresentationContext = Unit,
+  ExtraContext = Unit,
+>(
+  filterTypes: Map<string, SumNType<any>>,
+) =>
+  Co<CustomPresentationContext, ExtraContext>().Template<any>(
+    initialiseFiltersAndSorting<CustomPresentationContext, ExtraContext>(
+      filterTypes,
+    ),
+    {
+      interval: 15,
+      runFilter: (props) =>
+        props.context.customFormState.isFilteringInitialized == false,
+    },
+  );
 export const TableReinitialiseRunner = <
   CustomPresentationContext = Unit,
   ExtraContext = Unit,

package/src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/state.ts

@@ -1,12 +1,10 @@
-import { Map, OrderedMap, Set } from "immutable";
+import { Map, OrderedMap, Set, List } from "immutable";
 
 import {
   simpleUpdater,
-  BasicUpdater,
   Updater,
   SimpleCallback,
   simpleUpdaterWithChildren,
-  MapRepo,
   ValueOrErrors,
   PredicateValue,
   ValueRecord,
@@ -26,6 +24,14 @@ import {
   RecordType,
   ValueTuple,
   ValueUnit,
+  FilterType,
+  MapRepo,
+  ValueFilter,
+  DispatchParsedType,
+  CommonAbstractRendererForeignMutationsExpected,
+  Value,
+  SumNType,
+  ValueSumN,
 } from "../../../../../../../../main";
 import { Debounced } from "../../../../../../../debounced/state";
 import { BasicFun } from "../../../../../../../fun/state";
@@ -44,9 +50,14 @@ export type TableAbstractRendererReadonlyContext<
 > & {
   tableApiSource: DispatchTableApiSource;
   fromTableApiParser: (value: unknown) => ValueOrErrors<PredicateValue, string>;
+  parseFromApiByType: (
+    type: DispatchParsedType<any>,
+  ) => (raw: any) => ValueOrErrors<PredicateValue, string>;
   tableHeaders: string[];
   columnLabels: Map<string, string | undefined>;
   apiMethods: Array<TableMethod>;
+  sorting: Array<string>;
+  highlightedFilters: Array<string>;
 };
 
 export type TableAbstractRendererSelectedDetailRow =
@@ -56,11 +67,14 @@ export type TableAbstractRendererSelectedDetailRow =
 
 export type TableAbstractRendererState = CommonAbstractRendererState & {
   customFormState: {
+    isFilteringInitialized: boolean;
     selectedRows: Set<string>;
     rowStates: Map<string, RecordAbstractRendererState>;
     selectedDetailRow: TableAbstractRendererSelectedDetailRow;
     initializationStatus: "not initialized" | "initialized" | "reinitializing";
-    streamParams: Debounced<Map<string, string>>;
+    filters: Map<string, List<ValueFilter>>;
+    sorting: Map<string, "Ascending" | "Descending" | undefined>;
+    filterAndSortParam: string;
     stream: ValueInfiniteStreamState;
     getChunkWithParams: BasicFun<
       Map<string, string>,
@@ -68,22 +82,27 @@ export type TableAbstractRendererState = CommonAbstractRendererState & {
     >;
     previousRemoteEntityVersionIdentifier: string;
     shouldReinitialize: boolean;
+    filterStates: Map<string, List<any>>;
   };
 };
 export const TableAbstractRendererState = {
   Default: (): TableAbstractRendererState => ({
     ...CommonAbstractRendererState.Default(),
     customFormState: {
+      isFilteringInitialized: false,
       initializationStatus: "not initialized",
       selectedRows: Set(),
       selectedDetailRow: undefined,
-      streamParams: Debounced.Default(Map()),
+      filterAndSortParam: "",
       rowStates: Map(),
+      filters: Map(),
+      sorting: Map(),
       // TODO: replace with sum
       getChunkWithParams: undefined as any,
       stream: undefined as any,
       previousRemoteEntityVersionIdentifier: "",
       shouldReinitialize: false,
+      filterStates: Map(),
     },
   }),
   Updaters: {
@@ -96,7 +115,13 @@ export const TableAbstractRendererState = {
           "stream",
         ),
         ...simpleUpdater<TableAbstractRendererState["customFormState"]>()(
-          "streamParams",
+          "filterAndSortParam",
+        ),
+        ...simpleUpdater<TableAbstractRendererState["customFormState"]>()(
+          "filters",
+        ),
+        ...simpleUpdater<TableAbstractRendererState["customFormState"]>()(
+          "sorting",
         ),
         ...simpleUpdater<TableAbstractRendererState["customFormState"]>()(
           "initializationStatus",
@@ -116,6 +141,12 @@ export const TableAbstractRendererState = {
         ...simpleUpdater<TableAbstractRendererState["customFormState"]>()(
           "rowStates",
         ),
+        ...simpleUpdater<TableAbstractRendererState["customFormState"]>()(
+          "filterStates",
+        ),
+        ...simpleUpdater<TableAbstractRendererState["customFormState"]>()(
+          "isFilteringInitialized",
+        ),
       })("customFormState"),
       ...simpleUpdaterWithChildren<TableAbstractRendererState>()({
         ...simpleUpdater<TableAbstractRendererState["commonFormState"]>()(
@@ -124,15 +155,111 @@ export const TableAbstractRendererState = {
       })("commonFormState"),
     },
     Template: {
-      searchText: (
-        key: string,
-        _: BasicUpdater<string>,
+      updateFilters: (
+        filters: Map<string, List<ValueFilter>>,
+        filterTypes: Map<string, SumNType<any>>,
+        toApiRaw: (
+          type: DispatchParsedType<any>,
+          value: PredicateValue,
+          state: any,
+        ) => ValueOrErrors<any, string>,
       ): Updater<TableAbstractRendererState> =>
-        TableAbstractRendererState.Updaters.Core.customFormState.children.streamParams(
-          Debounced.Updaters.Template.value(
-            MapRepo.Updaters.upsert(key, () => "", _),
-          ),
+        Updater((_) =>
+          TableAbstractRendererState.Updaters.Core.customFormState.children
+            .filters(replaceWith(filters))
+            .then(
+              TableAbstractRendererState.Updaters.Core.customFormState.children.filterAndSortParam(
+                replaceWith(
+                  TableAbstractRendererState.Operations.parseFiltersAndSortingToBase64String(
+                    filters,
+                    filterTypes,
+                    _.customFormState.sorting,
+                    toApiRaw,
+                    _.customFormState.isFilteringInitialized,
+                  ),
+                ),
+              ),
+            )
+            .then(
+              TableAbstractRendererState.Updaters.Core.customFormState.children.shouldReinitialize(
+                replaceWith(true),
+              ),
+            )(_),
         ),
+      addSorting: (
+        columnName: string,
+        direction: "Ascending" | "Descending" | undefined,
+        filterTypes: Map<string, SumNType<any>>,
+        toApiRaw: (
+          type: DispatchParsedType<any>,
+          value: PredicateValue,
+          state: any,
+        ) => ValueOrErrors<any, string>,
+      ): Updater<TableAbstractRendererState> => {
+        const sortingUpdater = MapRepo.Updaters.upsert(
+          columnName,
+          () => undefined,
+          replaceWith(direction),
+        );
+        return Updater<TableAbstractRendererState>((_) =>
+          TableAbstractRendererState.Updaters.Core.customFormState.children
+            .sorting(sortingUpdater)
+            .then(
+              TableAbstractRendererState.Updaters.Core.customFormState.children.filterAndSortParam(
+                replaceWith(
+                  TableAbstractRendererState.Operations.parseFiltersAndSortingToBase64String(
+                    _.customFormState.filters,
+                    filterTypes,
+                    sortingUpdater(_.customFormState.sorting),
+                    toApiRaw,
+                    _.customFormState.isFilteringInitialized,
+                  ),
+                ),
+              ),
+            )
+            .then(
+              TableAbstractRendererState.Updaters.Core.customFormState.children.shouldReinitialize(
+                replaceWith(true),
+              ),
+            )(_),
+        );
+      },
+      removeSorting: (
+        columnName: string,
+        filterTypes: Map<string, SumNType<any>>,
+        toApiRaw: (
+          type: DispatchParsedType<any>,
+          value: PredicateValue,
+          state: any,
+        ) => ValueOrErrors<any, string>,
+      ): Updater<TableAbstractRendererState> => {
+        const sortingUpdater = MapRepo.Updaters.remove<
+          string,
+          "Ascending" | "Descending" | undefined
+        >(columnName);
+        return Updater<TableAbstractRendererState>((_) =>
+          TableAbstractRendererState.Updaters.Core.customFormState.children
+            .sorting(sortingUpdater)
+            .then(
+              TableAbstractRendererState.Updaters.Core.customFormState.children.filterAndSortParam(
+                replaceWith(
+                  TableAbstractRendererState.Operations.parseFiltersAndSortingToBase64String(
+                    _.customFormState.filters,
+                    filterTypes,
+                    sortingUpdater(_.customFormState.sorting),
+                    toApiRaw,
+                    _.customFormState.isFilteringInitialized,
+                  ),
+                ),
+              ),
+            )
+            .then(
+              TableAbstractRendererState.Updaters.Core.customFormState.children.shouldReinitialize(
+                replaceWith(true),
+              ),
+            )(_),
+        );
+      },
       loadMore: (): Updater<TableAbstractRendererState> =>
         TableAbstractRendererState.Updaters.Core.customFormState.children.stream(
           ValueInfiniteStreamState.Updaters.Template.loadMore(),
@@ -145,6 +272,85 @@ export const TableAbstractRendererState = {
   },
   // TODO: clean up the streams to accept data as a value or errors
   Operations: {
+    parseFiltersAndSortingToBase64String: (
+      filterValues: Map<string, List<ValueFilter>>,
+      sumNFilterTypes: Map<string, SumNType<any>>,
+      sorting: Map<string, "Ascending" | "Descending" | undefined>,
+      toApiRaw: (
+        type: DispatchParsedType<any>,
+        value: PredicateValue,
+        state: any,
+      ) => ValueOrErrors<any, string>,
+      isFilteringInitialized: boolean,
+    ): string => {
+      if (
+        !isFilteringInitialized ||
+        (filterValues.valueSeq().every((filters) => filters.size == 0) &&
+          sorting.size == 0)
+      ) {
+        return "";
+      }
+      const filterTypes = sumNFilterTypes.map(
+        (sumNType) => sumNType.args as Array<FilterType<any>>,
+      );
+      const parsedFilters = filterValues.map((filters, columnName) =>
+        filters.map((filter) => {
+          const filterTypeIndex = filterTypes
+            .get(columnName)
+            ?.findIndex((f) => f.kind == filter.kind);
+          if (filterTypeIndex == undefined || filterTypeIndex < 0) {
+            console.error(
+              `filter ${filter.kind} type not found for column ${columnName}`,
+            );
+            return ValueOrErrors.Default.throwOne(
+              `filter ${filter.kind} type not found for column ${columnName}`,
+            );
+          }
+          const filterType = sumNFilterTypes.get(columnName);
+
+          if (!filterType) {
+            console.error(
+              `filter ${filter.kind} type not found for column ${columnName}`,
+            );
+            return ValueOrErrors.Default.throwOne(
+              `filter ${filter.kind} type not found for column ${columnName}`,
+            );
+          }
+
+          const sumValue = ValueSumN.Default(
+            filterTypeIndex,
+            filterType.args.length,
+            filter,
+          );
+
+          return toApiRaw(filterType, sumValue, {});
+        }),
+      );
+      if (
+        parsedFilters.some((filter) => filter.some((f) => f.kind == "errors"))
+      ) {
+        console.error(
+          "error parsing filters to api",
+          parsedFilters
+            .filter((filter) => filter.some((f) => f.kind == "errors"))
+            .toJS(),
+        );
+        return "";
+      }
+
+      // TODO: Deal with this monadically
+      const parsedFiltersValues = parsedFilters
+        .map((filter) => filter.map((f) => (f as Value<PredicateValue>).value))
+        .toJS();
+      const params = {
+        Filters: parsedFiltersValues,
+        Sorting: sorting
+          .entrySeq()
+          .toList()
+          .filter((sorting) => sorting[1] != undefined),
+      };
+      return btoa(JSON.stringify(params));
+    },
     tableValuesToValueRecord: (
       values: any,
       fromApiRaw: (value: any) => ValueOrErrors<PredicateValue, string>,
@@ -205,6 +411,12 @@ export type TableAbstractRendererViewForeignMutationsExpected<Flags = Unit> = {
     | undefined;
   duplicate: ValueCallbackWithOptionalFlags<string, Flags> | undefined;
   reinitialize: SimpleCallback<void>;
+  updateFilters: (filters: Map<string, List<ValueFilter>>) => void;
+  addSorting: (
+    columnName: string,
+    direction: "Ascending" | "Descending" | undefined,
+  ) => void;
+  removeSorting: (columnName: string) => void;
 };
 
 export type TableAbstractRendererView<
@@ -251,5 +463,30 @@ export type TableAbstractRendererView<
       TableAbstractRendererState,
       TableAbstractRendererForeignMutationsExpected<Flags>
     >;
+    AllowedFilters: Map<
+      string,
+      {
+        template: (
+          index: number,
+        ) => Template<
+          CommonAbstractRendererReadonlyContext<
+            DispatchParsedType<any>,
+            PredicateValue,
+            CustomPresentationContext,
+            ExtraContext
+          > &
+            TableAbstractRendererState,
+          TableAbstractRendererState,
+          CommonAbstractRendererForeignMutationsExpected
+        >;
+        type: DispatchParsedType<any>;
+        filters: Array<FilterType<any>>;
+        GetDefaultValue: () => PredicateValue;
+        GetDefaultState: () => CommonAbstractRendererState;
+      }
+    >;
+    AllowedSorting: Array<string>;
+    HighlightedFilters: Array<string>;
+    isFilteringSortAndLoadingEnabled: boolean;
   }
 >;