ballerina-core 1.0.119 → 1.0.121

package/package.json

@@ -2,7 +2,7 @@
   "name": "ballerina-core",
   "author": "Dr. Giuseppe Maggiore",
   "private": false,
-  "version": "1.0.119",
+  "version": "1.0.121",
   "main": "main.ts",
   "scripts": {
     "prettier": "prettier --write ."

package/src/forms/domains/dispatched-forms/deserializer/domains/specification/domains/apis/state.ts

@@ -1,16 +1,263 @@
-import { DispatchTypeName } from "../types/state";
+import { List, Map } from "immutable";
+import {
+  EntityApi,
+  isObject,
+  isString,
+  ValueOrErrors,
+} from "../../../../../../../../../main";
+import { DispatchIsObject, DispatchTypeName } from "../types/state";
 
 export type SerializedEntityApi = {
   type?: any;
   methods?: any;
 };
 
-// Exist already in the main.ts
-// export type EntityApi = {
-//   type: TypeName;
-//   methods: { create: boolean; get: boolean; update: boolean; default: boolean };
-// };
-// export type GlobalConfigurationApi = {
-//   type: TypeName;
-//   methods: { get: boolean };
-// };
+export type SerializedLookupApi = {
+  enums?: unknown;
+  streams?: unknown;
+  one?: unknown;
+  many?: unknown;
+  tables?: unknown;
+};
+
+export type SpecificationApis = {
+  entities: Map<string, EntityApi>; // TODO move entity apis out
+  enums?: EnumApis;
+  streams?: StreamApis;
+  tables?: TableApis;
+  lookups?: LookupApis;
+};
+
+export type EnumApiName = string;
+export type EnumApis = Map<EnumApiName, DispatchTypeName>;
+export const EnumApis = {
+  Operations: {
+    Deserialize: (
+      serializedApiEnums?: unknown,
+    ): ValueOrErrors<undefined | EnumApis, string> =>
+      serializedApiEnums === undefined
+        ? ValueOrErrors.Default.return(undefined)
+        : !isObject(serializedApiEnums)
+          ? ValueOrErrors.Default.throwOne(
+              `serializedApiEnums is not an object`,
+            )
+          : ValueOrErrors.Operations.All(
+              List<ValueOrErrors<[EnumApiName, DispatchTypeName], string>>(
+                Object.entries(serializedApiEnums).map(([key, value]) =>
+                  !isString(key)
+                    ? ValueOrErrors.Default.throwOne(`key is not a string`)
+                    : !isString(value)
+                      ? ValueOrErrors.Default.throwOne(`value is not a string`)
+                      : ValueOrErrors.Default.return([key, value]),
+                ),
+              ),
+            )
+              .Then((entries) =>
+                ValueOrErrors.Default.return(
+                  Map<EnumApiName, DispatchTypeName>(entries),
+                ),
+              )
+              .MapErrors((errors) =>
+                errors.map(
+                  (error) => `${error}\n...When deserializing enum apis`,
+                ),
+              ),
+  },
+};
+
+export type StreamApiName = string;
+export type StreamApis = Map<StreamApiName, DispatchTypeName>;
+export const StreamApis = {
+  Operations: {
+    Deserialize: (
+      serializedApiStreams?: unknown,
+    ): ValueOrErrors<undefined | StreamApis, string> =>
+      serializedApiStreams === undefined
+        ? ValueOrErrors.Default.return(undefined)
+        : !isObject(serializedApiStreams)
+          ? ValueOrErrors.Default.throwOne(
+              `serializedApiStreams is not an object`,
+            )
+          : ValueOrErrors.Operations.All(
+              List<ValueOrErrors<[StreamApiName, DispatchTypeName], string>>(
+                Object.entries(serializedApiStreams).map(([key, value]) =>
+                  !isString(key)
+                    ? ValueOrErrors.Default.throwOne(`key is not a string`)
+                    : !isString(value)
+                      ? ValueOrErrors.Default.throwOne(`value is not a string`)
+                      : ValueOrErrors.Default.return([key, value]),
+                ),
+              ),
+            )
+              .Then((entries) =>
+                ValueOrErrors.Default.return(
+                  Map<StreamApiName, DispatchTypeName>(entries),
+                ),
+              )
+              .MapErrors((errors) =>
+                errors.map(
+                  (error) => `${error}\n...When deserializing stream apis`,
+                ),
+              ),
+  },
+};
+
+export type TableApiName = string;
+export type TableApis = Map<TableApiName, { type: DispatchTypeName }>;
+export const TableApis = {
+  Operations: {
+    Deserialize: (
+      serializedApiTables?: unknown,
+    ): ValueOrErrors<undefined | TableApis, string> =>
+      serializedApiTables === undefined
+        ? ValueOrErrors.Default.return(undefined)
+        : !isObject(serializedApiTables)
+          ? ValueOrErrors.Default.throwOne(
+              `serializedApiTables is not an object`,
+            )
+          : ValueOrErrors.Operations.All(
+              List<
+                ValueOrErrors<
+                  [TableApiName, { type: DispatchTypeName }],
+                  string
+                >
+              >(
+                Object.entries(serializedApiTables).map(([key, value]) =>
+                  !isString(key)
+                    ? ValueOrErrors.Default.throwOne(`key is not a string`)
+                    : !isObject(value)
+                      ? ValueOrErrors.Default.throwOne(`value is not an object`)
+                      : !("type" in value)
+                        ? ValueOrErrors.Default.throwOne(
+                            `type is missing from value`,
+                          )
+                        : !isString(value.type)
+                          ? ValueOrErrors.Default.throwOne(
+                              `type is not a string`,
+                            )
+                          : // TODO: type assertion is safe but would like typescript to know that
+                            ValueOrErrors.Default.return([
+                              key,
+                              value as { type: DispatchTypeName },
+                            ]),
+                ),
+              ),
+            )
+              .Then((entries) =>
+                ValueOrErrors.Default.return(
+                  Map<TableApiName, { type: DispatchTypeName }>(entries),
+                ),
+              )
+              .MapErrors((errors) =>
+                errors.map(
+                  (error) => `${error}\n...When deserializing table apis`,
+                ),
+              ),
+  },
+};
+
+export type LookupApiName = string;
+export type LookupApis = Map<LookupApiName, LookupApi>;
+export type LookupApi = {
+  enums?: EnumApis;
+  streams?: StreamApis;
+  tables?: TableApis;
+  lookups?: LookupApis;
+  one?: Map<
+    string,
+    {
+      type: DispatchTypeName;
+      methods: {
+        update: boolean;
+        getManyUnlinked: boolean;
+        create: boolean;
+        delete: boolean;
+      };
+    }
+  >;
+  many?: Map<
+    string,
+    {
+      type: DispatchTypeName;
+      methods: {
+        update: boolean;
+        getManyUnlinked: boolean;
+        create: boolean;
+        delete: boolean;
+      };
+    }
+  >;
+};
+
+// TODO add one and many deserialization
+export const LookupApis = {
+  Operations: {
+    isLookupApi: (
+      _: unknown,
+    ): _ is {
+      enums?: unknown;
+      streams?: unknown;
+      tables?: unknown;
+      lookups?: unknown;
+      one?: unknown;
+      many?: unknown;
+    } => DispatchIsObject(_),
+    DeserializeOne: (
+      serializedLookupApi: unknown,
+    ): ValueOrErrors<LookupApi, string> =>
+      !LookupApis.Operations.isLookupApi(serializedLookupApi)
+        ? ValueOrErrors.Default.throwOne(`serializedLookupApi is not an object`)
+        : EnumApis.Operations.Deserialize(serializedLookupApi.enums)
+            .Then((enums) =>
+              StreamApis.Operations.Deserialize(
+                serializedLookupApi.streams,
+              ).Then((streams) =>
+                TableApis.Operations.Deserialize(
+                  serializedLookupApi.tables,
+                ).Then((tables) =>
+                  LookupApis.Operations.Deserialize(
+                    serializedLookupApi.lookups,
+                  ).Then((lookups) =>
+                    ValueOrErrors.Default.return({
+                      enums,
+                      streams,
+                      tables,
+                      lookups,
+                    }),
+                  ),
+                ),
+              ),
+            )
+            .MapErrors((errors) =>
+              errors.map(
+                (error) => `${error}\n...When deserializing lookup api`,
+              ),
+            ),
+    Deserialize: (
+      serializedApiLookups?: unknown,
+    ): ValueOrErrors<undefined | LookupApis, string> =>
+      serializedApiLookups === undefined
+        ? ValueOrErrors.Default.return(undefined)
+        : !isObject(serializedApiLookups)
+          ? ValueOrErrors.Default.throwOne(
+              `serializedApiLookups is not an object`,
+            )
+          : ValueOrErrors.Operations.All(
+              List<ValueOrErrors<[LookupApiName, LookupApi], string>>(
+                Object.entries(serializedApiLookups).map(([key, value]) =>
+                  ValueOrErrors.Default.return([key, value]),
+                ),
+              ),
+            )
+              .Then((entries) =>
+                ValueOrErrors.Default.return(
+                  Map<LookupApiName, LookupApi>(entries),
+                ),
+              )
+              .MapErrors((errors) =>
+                errors.map(
+                  (error) => `${error}\n...When deserializing lookup apis`,
+                ),
+              ),
+  },
+};

package/src/forms/domains/dispatched-forms/deserializer/domains/specification/domains/form/domains/renderers/domains/baseRenderer/domains/list/state.ts

@@ -1,14 +1,17 @@
+import { Map } from "immutable";
 import {
   Expr,
   ValueOrErrors,
 } from "../../../../../../../../../../../../../../../main";
-import { ListType } from "../../../../../../../types/state";
+import { DispatchParsedType, ListType } from "../../../../../../../types/state";
 import {
   BaseBaseRenderer,
   BaseSerializedBaseRenderer,
   ParentContext,
   BaseRenderer,
 } from "../../state";
+import { TableFormRenderer } from "../../../tableFormRenderer/state";
+import { RecordFormRenderer } from "../../../recordFormRenderer/state";
 
 export type SerializedBaseListRenderer = {
   elementRenderer?: unknown;
@@ -18,7 +21,10 @@ export type SerializedBaseListRenderer = {
 
 export type BaseListRenderer<T> = BaseBaseRenderer & {
   kind: "baseListRenderer";
-  elementRenderer: BaseRenderer<T>;
+  elementRenderer:
+    | BaseRenderer<T>
+    | TableFormRenderer<T>
+    | RecordFormRenderer<T>;
   type: ListType<T>;
   concreteRendererName: string;
 };
@@ -27,7 +33,10 @@ export const BaseListRenderer = {
   Default: <T>(
     type: ListType<T>,
     concreteRendererName: string,
-    elementRenderer: BaseRenderer<T>,
+    elementRenderer:
+      | BaseRenderer<T>
+      | TableFormRenderer<T>
+      | RecordFormRenderer<T>,
     visible?: Expr,
     disabled?: Expr,
     label?: string,
@@ -96,6 +105,7 @@ export const BaseListRenderer = {
       serialized: SerializedBaseListRenderer,
       fieldViews: any,
       renderingContext: ParentContext,
+      types: Map<string, DispatchParsedType<T>>,
     ): ValueOrErrors<BaseListRenderer<T>, string> =>
       BaseListRenderer.Operations.tryAsValidBaseListRenderer(serialized)
         .Then((renderer) =>
@@ -113,6 +123,7 @@ export const BaseListRenderer = {
                 fieldViews,
                 "nested",
                 "Element",
+                types,
               ).Then((elementRenderer) =>
                 ValueOrErrors.Default.return(
                   BaseListRenderer.Default(

package/src/forms/domains/dispatched-forms/deserializer/domains/specification/domains/form/domains/renderers/domains/baseRenderer/domains/map/state.ts

@@ -1,8 +1,10 @@
+import { Map } from "immutable";
 import {
   Expr,
+  TableFormRenderer,
   ValueOrErrors,
 } from "../../../../../../../../../../../../../../../main";
-import { MapType } from "../../../../../../../types/state";
+import { DispatchParsedType, MapType } from "../../../../../../../types/state";
 import {
   BaseBaseRenderer,
   BaseSerializedBaseRenderer,
@@ -10,6 +12,7 @@ import {
   ParentContext,
   BaseRenderer,
 } from "../../state";
+import { RecordFormRenderer } from "../../../recordFormRenderer/state";
 
 export type SerializedBaseMapRenderer = {
   keyRenderer?: unknown;
@@ -18,8 +21,8 @@ export type SerializedBaseMapRenderer = {
 
 export type BaseMapRenderer<T> = BaseBaseRenderer & {
   kind: "baseMapRenderer";
-  keyRenderer: BaseRenderer<T>;
-  valueRenderer: BaseRenderer<T>;
+  keyRenderer: BaseRenderer<T> | TableFormRenderer<T> | RecordFormRenderer<T>;
+  valueRenderer: BaseRenderer<T> | TableFormRenderer<T> | RecordFormRenderer<T>;
   type: MapType<T>;
   concreteRendererName: string;
 };
@@ -28,8 +31,11 @@ export const BaseMapRenderer = {
   Default: <T>(
     type: MapType<T>,
     concreteRendererName: string,
-    keyRenderer: BaseRenderer<T>,
-    valueRenderer: BaseRenderer<T>,
+    keyRenderer: BaseRenderer<T> | TableFormRenderer<T> | RecordFormRenderer<T>,
+    valueRenderer:
+      | BaseRenderer<T>
+      | TableFormRenderer<T>
+      | RecordFormRenderer<T>,
     visible?: Expr,
     disabled?: Expr,
     label?: string,
@@ -82,6 +88,7 @@ export const BaseMapRenderer = {
       serialized: SerializedBaseMapRenderer,
       fieldViews: any,
       renderingContext: ParentContext,
+      types: Map<string, DispatchParsedType<T>>,
     ): ValueOrErrors<BaseMapRenderer<T>, string> =>
       BaseMapRenderer.Operations.tryAsValidMapBaseRenderer(serialized)
         .Then((renderer) =>
@@ -99,6 +106,7 @@ export const BaseMapRenderer = {
                 fieldViews,
                 "nested",
                 "Key",
+                types,
               ).Then((deserializedKeyRenderer) =>
                 BaseRenderer.Operations.DeserializeAs(
                   type.args[1],
@@ -106,6 +114,7 @@ export const BaseMapRenderer = {
                   fieldViews,
                   "nested",
                   "Value",
+                  types,
                 ).Then((deserializedValueRenderer) =>
                   ValueOrErrors.Default.return(
                     BaseMapRenderer.Default(

package/src/forms/domains/dispatched-forms/deserializer/domains/specification/domains/form/domains/renderers/domains/baseRenderer/domains/sum/state.ts

@@ -1,4 +1,4 @@
-import { List } from "immutable";
+import { Map } from "immutable";
 import {
   SerializedBaseRenderer,
   BaseSerializedBaseRenderer,
@@ -6,11 +6,13 @@ import {
   BaseBaseRenderer as BaseBaseRenderer,
   ParentContext,
 } from "../../state";
-import { SumType } from "../../../../../../../types/state";
+import { DispatchParsedType, SumType } from "../../../../../../../types/state";
 import {
   Expr,
+  TableFormRenderer,
   ValueOrErrors,
 } from "../../../../../../../../../../../../../../../main";
+import { RecordFormRenderer } from "../../../recordFormRenderer/state";
 
 export type SerializedSumBaseRenderer = {
   leftRenderer?: unknown;
@@ -19,8 +21,8 @@ export type SerializedSumBaseRenderer = {
 
 export type BaseSumRenderer<T> = BaseBaseRenderer & {
   kind: "baseSumRenderer";
-  leftRenderer: BaseRenderer<T>;
-  rightRenderer: BaseRenderer<T>;
+  leftRenderer: BaseRenderer<T> | TableFormRenderer<T> | RecordFormRenderer<T>;
+  rightRenderer: BaseRenderer<T> | TableFormRenderer<T> | RecordFormRenderer<T>;
   type: SumType<T>;
   concreteRendererName: string;
 };
@@ -29,8 +31,14 @@ export const BaseSumRenderer = {
   Default: <T>(
     type: SumType<T>,
     concreteRendererName: string,
-    leftRenderer: BaseRenderer<T>,
-    rightRenderer: BaseRenderer<T>,
+    leftRenderer:
+      | BaseRenderer<T>
+      | TableFormRenderer<T>
+      | RecordFormRenderer<T>,
+    rightRenderer:
+      | BaseRenderer<T>
+      | TableFormRenderer<T>
+      | RecordFormRenderer<T>,
     visible?: Expr,
     disabled?: Expr,
     label?: string,
@@ -83,6 +91,7 @@ export const BaseSumRenderer = {
       serialized: SerializedSumBaseRenderer,
       renderingContext: ParentContext,
       fieldViews: any,
+      types: Map<string, DispatchParsedType<T>>,
     ): ValueOrErrors<BaseSumRenderer<T>, string> =>
       BaseSumRenderer.Operations.tryAsValidSumBaseRenderer(serialized)
         .Then((renderer) =>
@@ -100,6 +109,7 @@ export const BaseSumRenderer = {
                 fieldViews,
                 "nested",
                 "Left",
+                types,
               ).Then((deserializedLeftRenderer) =>
                 BaseRenderer.Operations.DeserializeAs(
                   type.args[1],
@@ -107,6 +117,7 @@ export const BaseSumRenderer = {
                   fieldViews,
                   "nested",
                   "Right",
+                  types,
                 ).Then((deserializedRightRenderer) =>
                   ValueOrErrors.Default.return(
                     BaseSumRenderer.Default(

package/src/forms/domains/dispatched-forms/deserializer/domains/specification/domains/form/domains/renderers/domains/baseRenderer/domains/tuple/state.ts

@@ -1,8 +1,14 @@
+import { Map } from "immutable";
 import {
   Expr,
+  TableFormRenderer,
   ValueOrErrors,
 } from "../../../../../../../../../../../../../../../main";
-import { TupleType } from "../../../../../../../types/state";
+import { RecordFormRenderer } from "../../../recordFormRenderer/state";
+import {
+  DispatchParsedType,
+  TupleType,
+} from "../../../../../../../types/state";
 
 import {
   BaseBaseRenderer,
@@ -19,7 +25,9 @@ export type SerializedBaseTupleRenderer = {
 
 export type BaseTupleRenderer<T> = BaseBaseRenderer & {
   kind: "baseTupleRenderer";
-  itemRenderers: Array<BaseRenderer<T>>;
+  itemRenderers: Array<
+    BaseRenderer<T> | TableFormRenderer<T> | RecordFormRenderer<T>
+  >;
   type: TupleType<T>;
   concreteRendererName: string;
 };
@@ -28,7 +36,9 @@ export const BaseTupleRenderer = {
   Default: <T>(
     type: TupleType<T>,
     concreteRendererName: string,
-    itemRenderers: Array<BaseRenderer<T>>,
+    itemRenderers: Array<
+      BaseRenderer<T> | TableFormRenderer<T> | RecordFormRenderer<T>
+    >,
     visible?: Expr,
     disabled?: Expr,
     label?: string,
@@ -96,6 +106,7 @@ export const BaseTupleRenderer = {
       serialized: SerializedBaseTupleRenderer,
       fieldViews: any,
       renderingContext: ParentContext,
+      types: Map<string, DispatchParsedType<T>>,
     ): ValueOrErrors<BaseTupleRenderer<T>, string> =>
       BaseTupleRenderer.Operations.tryAsValidBaseTupleRenderer(serialized)
         .Then((renderer) =>
@@ -108,7 +119,14 @@ export const BaseTupleRenderer = {
               renderingContext,
             ).Then((disabledExpr) =>
               ValueOrErrors.Operations.All(
-                List<ValueOrErrors<BaseRenderer<T>, string>>(
+                List<
+                  ValueOrErrors<
+                    | BaseRenderer<T>
+                    | TableFormRenderer<T>
+                    | RecordFormRenderer<T>,
+                    string
+                  >
+                >(
                   renderer.itemRenderers.map((itemRenderer, index) =>
                     BaseRenderer.Operations.DeserializeAs(
                       type.args[index],
@@ -116,6 +134,7 @@ export const BaseTupleRenderer = {
                       fieldViews,
                       "nested",
                       `Item ${index + 1}`,
+                      types,
                     ).Then((deserializedItemRenderer) =>
                       ValueOrErrors.Default.return(deserializedItemRenderer),
                     ),

package/src/forms/domains/dispatched-forms/deserializer/domains/specification/domains/form/domains/renderers/domains/baseRenderer/domains/union/state.ts

@@ -1,8 +1,13 @@
 import {
   Expr,
+  TableFormRenderer,
   ValueOrErrors,
 } from "../../../../../../../../../../../../../../../main";
-import { UnionType } from "../../../../../../../types/state";
+import { RecordFormRenderer } from "../../../recordFormRenderer/state";
+import {
+  DispatchParsedType,
+  UnionType,
+} from "../../../../../../../types/state";
 
 import {
   BaseBaseRenderer,
@@ -19,7 +24,10 @@ export type SerializedBaseUnionRenderer = {
 
 export type BaseUnionRenderer<T> = BaseBaseRenderer & {
   kind: "baseUnionRenderer";
-  cases: Map<string, BaseRenderer<T>>;
+  cases: Map<
+    string,
+    BaseRenderer<T> | TableFormRenderer<T> | RecordFormRenderer<T>
+  >;
   type: UnionType<T>;
   concreteRendererName: string;
 };
@@ -28,7 +36,10 @@ export const BaseUnionRenderer = {
   Default: <T>(
     type: UnionType<T>,
     concreteRendererName: string,
-    cases: Map<string, BaseRenderer<T>>,
+    cases: Map<
+      string,
+      BaseRenderer<T> | TableFormRenderer<T> | RecordFormRenderer<T>
+    >,
     visible?: Expr,
     disabled?: Expr,
     label?: string,
@@ -95,6 +106,7 @@ export const BaseUnionRenderer = {
       serialized: SerializedBaseUnionRenderer,
       fieldViews: any,
       renderingContext: ParentContext,
+      types: Map<string, DispatchParsedType<T>>,
     ): ValueOrErrors<BaseUnionRenderer<T>, string> =>
       BaseUnionRenderer.Operations.tryAsValidBaseUnionRenderer(serialized)
         .Then((renderer) =>
@@ -107,7 +119,19 @@ export const BaseUnionRenderer = {
               renderingContext,
             ).Then((disabledExpr) =>
               ValueOrErrors.Operations.All(
-                List<ValueOrErrors<[string, BaseRenderer<T>], string>>(
+                List<
+                  ValueOrErrors<
+                    [
+                      string,
+                      (
+                        | BaseRenderer<T>
+                        | TableFormRenderer<T>
+                        | RecordFormRenderer<T>
+                      ),
+                    ],
+                    string
+                  >
+                >(
                   Object.entries(renderer.cases).map(([caseName, caseProp]) => {
                     const caseType = type.args.get(caseName);
                     if (!caseType) {
@@ -121,6 +145,7 @@ export const BaseUnionRenderer = {
                       fieldViews,
                       "nested",
                       `case ${caseName}`,
+                      types,
                     ).Then((deserializedCase) =>
                       ValueOrErrors.Default.return([
                         caseName,
@@ -134,7 +159,12 @@ export const BaseUnionRenderer = {
                   BaseUnionRenderer.Default(
                     type,
                     renderer.renderer,
-                    Map<string, BaseRenderer<T>>(deserializedCases),
+                    Map<
+                      string,
+                      | BaseRenderer<T>
+                      | TableFormRenderer<T>
+                      | RecordFormRenderer<T>
+                    >(deserializedCases),
                     visibleExpr,
                     disabledExpr,
                     renderer.label,