ballerina-core 1.0.255 → 1.0.257

package/bin/src/forms/domains/dispatched-forms/deserializer/domains/specification/domains/types/state.js

@@ -1,6 +1,10 @@
 import { List, Map } from "immutable";
 import { ValueOrErrors } from "../../../../../../../../collections/domains/valueOrErrors/state";
-import { DispatchGenericTypes, MapRepo } from "../../../../../../../../../main";
+import {
+  DispatchGenericTypes,
+  MapRepo,
+  isString,
+} from "../../../../../../../../../main";
 export const DispatchisString = (_) => typeof _ == "string";
 export const DispatchIsObject = (_) => typeof _ == "object";
 export const DispatchIsGenericType = (_) =>
@@ -22,6 +26,12 @@ export const DispatchPrimitiveTypeNames = [
   "base64File",
   "secret",
 ];
+const STRINGY_TYPES = [
+  "guid",
+  "entityIdUUID",
+  "entityIdString",
+  "calculatedDisplayValue",
+];
 export const SerializedType = {
   isExtendedType: (type) =>
     typeof type == "object" &&
@@ -39,7 +49,12 @@ export const SerializedType = {
     ),
   isApplication: (_) =>
     DispatchHasFun(_) && DispatchIsGenericType(_.fun) && DispatchHasArgs(_),
-  isLookup: (_, forms) => DispatchisString(_) && forms.has(_),
+  isLookup: (_, injectedPrimitives) =>
+    DispatchisString(_) &&
+    !(injectedPrimitives === null || injectedPrimitives === void 0
+      ? void 0
+      : injectedPrimitives.has(_)) &&
+    !(_ in DispatchPrimitiveTypeNames),
   isList: (_) =>
     SerializedType.isApplication(_) && _.fun == "List" && _.args.length == 1,
   isMap: (_) =>
@@ -424,7 +439,12 @@ export const DispatchParsedType = {
     //                               (v, i) => v.name == snd.args.get(i)!.name,
     //                             )
     //                           : false,
-    ParseRawKeyOf: (rawType, typeNames, serializedTypes, alreadyParsedTypes) =>
+    ParseRawKeyOf: (
+      rawType,
+      serializedTypes,
+      alreadyParsedTypes,
+      injectedPrimitives,
+    ) =>
       (alreadyParsedTypes.has(rawType.args[0])
         ? alreadyParsedTypes
             .get(rawType.args[0])
@@ -434,9 +454,9 @@ export const DispatchParsedType = {
         : DispatchParsedType.Operations.ParseRawType(
             rawType.args[0],
             serializedTypes[rawType.args[0]],
-            typeNames,
             serializedTypes,
             alreadyParsedTypes,
+            injectedPrimitives,
           )
       )
         .Then((parsingResult) =>
@@ -447,18 +467,25 @@ export const DispatchParsedType = {
             : ValueOrErrors.Default.return([
                 DispatchParsedType.Default.union(
                   Map(
-                    parsingResult[0].fields
-                      .keySeq()
-                      .filter(
-                        (key) =>
-                          rawType.args[1] == undefined ||
-                          !rawType.args[1].includes(key),
-                      )
-                      .toArray()
-                      .map((key) => [
-                        key,
-                        DispatchParsedType.Default.record(Map()),
-                      ]),
+                    (() => {
+                      const excludedKeys = rawType.args[1]
+                        ? rawType.args[1].reduce((acc, key) => {
+                            acc[key] = true;
+                            return acc;
+                          }, {})
+                        : null;
+                      return parsingResult[0].fields
+                        .keySeq()
+                        .filter(
+                          (key) =>
+                            excludedKeys == null || !(key in excludedKeys),
+                        )
+                        .toArray()
+                        .map((key) => [
+                          key,
+                          DispatchParsedType.Default.record(Map()),
+                        ]);
+                    })(),
                   ),
                 ),
                 parsingResult[1],
@@ -572,49 +599,47 @@ export const DispatchParsedType = {
           throw new Error(`Unknown type: ${JSON.stringify(type)}`);
       }
     },
+    GetExtendedRecordTypes: (extendedTypeName, alreadyParsedTypes) => {
+      return MapRepo.Operations.tryFindWithError(
+        extendedTypeName,
+        alreadyParsedTypes,
+        () => `cannot find extended type ${extendedTypeName} in types`,
+      ).Then((extendedType) =>
+        extendedType.Then((extendedType) =>
+          extendedType.kind != "record"
+            ? ValueOrErrors.Default.throwOne(
+                `Error: ${JSON.stringify(extendedType)} is not a record type`,
+              )
+            : ValueOrErrors.Default.return([extendedTypeName, extendedType]),
+        ),
+      );
+    },
     ParseRecord: (
       typeName,
       rawType,
-      typeNames,
       serializedTypes,
       alreadyParsedTypes,
       injectedPrimitives,
     ) =>
-      // will already been parsed if it was extended by another type which was already parsed
-      alreadyParsedTypes.has(typeName)
-        ? alreadyParsedTypes
-            .get(typeName)
-            .Then((parsedType) =>
-              parsedType.kind != "record"
-                ? ValueOrErrors.Default.throwOne(
-                    `Error: ${JSON.stringify(parsedType)} is not a record type`,
-                  )
-                : ValueOrErrors.Default.return([
-                    parsedType,
-                    alreadyParsedTypes,
-                  ]),
-            )
-        : !SerializedType.isRecord(rawType)
-          ? ValueOrErrors.Default.throwOne(
-              `Error: ${JSON.stringify(rawType)} is not a valid record`,
-            )
-          : (SerializedType.isExtendedType(rawType)
-              ? ValueOrErrors.Operations.All(
-                  List(
-                    rawType.extends.map((extendedTypeName) =>
-                      alreadyParsedTypes.has(extendedTypeName)
-                        ? alreadyParsedTypes
-                            .get(extendedTypeName)
-                            .Then((extendedType) =>
-                              extendedType.kind != "record"
-                                ? ValueOrErrors.Default.throwOne(
-                                    `Error: ${JSON.stringify(extendedType)} is not a record type`,
-                                  )
-                                : ValueOrErrors.Default.return([
-                                    extendedTypeName,
-                                    extendedType,
-                                  ]),
-                            )
+      !SerializedType.isRecord(rawType)
+        ? ValueOrErrors.Default.throwOne(
+            `Error: ${JSON.stringify(rawType)} is not a valid record`,
+          )
+        : (SerializedType.isExtendedType(rawType)
+            ? rawType.extends
+                .reduce(
+                  (acc, extendedTypeName) =>
+                    acc.Then(([resultMap, accumulatedAlreadyParsedTypes]) =>
+                      accumulatedAlreadyParsedTypes.has(extendedTypeName)
+                        ? DispatchParsedType.Operations.GetExtendedRecordTypes(
+                            extendedTypeName,
+                            accumulatedAlreadyParsedTypes,
+                          ).Then(([extendedTypeName, recordType]) =>
+                            ValueOrErrors.Default.return([
+                              resultMap.set(extendedTypeName, recordType),
+                              accumulatedAlreadyParsedTypes,
+                            ]),
+                          )
                         : serializedTypes[extendedTypeName] == undefined
                           ? ValueOrErrors.Default.throwOne(
                               `Error: cannot find extended type ${extendedTypeName} in types`,
@@ -622,86 +647,103 @@ export const DispatchParsedType = {
                           : DispatchParsedType.Operations.ParseRawType(
                               extendedTypeName,
                               serializedTypes[extendedTypeName],
-                              typeNames,
                               serializedTypes,
-                              alreadyParsedTypes,
+                              accumulatedAlreadyParsedTypes,
                               injectedPrimitives,
                             ).Then((parsedType) =>
                               parsedType[0].kind == "record"
                                 ? ValueOrErrors.Default.return([
-                                    extendedTypeName,
-                                    parsedType[0],
+                                    resultMap.set(
+                                      extendedTypeName,
+                                      parsedType[0],
+                                    ),
+                                    parsedType[1],
                                   ])
                                 : ValueOrErrors.Default.throwOne(
                                     `Error: ${JSON.stringify(parsedType[0])} is not a record type`,
                                   ),
                             ),
                     ),
-                  ),
+                  ValueOrErrors.Default.return([Map(), alreadyParsedTypes]),
                 )
-                  .MapErrors((errors) =>
-                    errors.map(
-                      (error) => `${error}\n...When parsing extended types`,
-                    ),
-                  )
-                  .Then((parsedExtendedRecordTypes) =>
-                    ValueOrErrors.Default.return(
-                      parsedExtendedRecordTypes.reduce(
-                        (acc, type) => acc.set(type[0], type[1]),
-                        Map(),
-                      ),
-                    ),
-                  )
-              : ValueOrErrors.Default.return(Map())
-            ).Then((parsedExtendedRecordTypesMap) =>
-              ValueOrErrors.Operations.All(
-                List(
-                  Object.entries(rawType.fields).map(([fieldName, fieldType]) =>
-                    DispatchParsedType.Operations.ParseRawType(
-                      fieldName,
-                      fieldType,
-                      typeNames,
-                      serializedTypes,
-                      alreadyParsedTypes,
-                      injectedPrimitives,
-                    ).Then((parsedField) =>
-                      ValueOrErrors.Default.return([fieldName, parsedField]),
-                    ),
-                  ),
-                ),
-              )
-                .Then((parsedFields) =>
-                  ValueOrErrors.Default.return(
-                    Map(
-                      parsedFields.map(([fieldName, parsedField]) => [
-                        fieldName,
-                        parsedField[0],
-                      ]),
-                    ),
+                .MapErrors((errors) =>
+                  errors.map(
+                    (error) => `${error}\n...When parsing extended types`,
                   ),
                 )
-                .Then((parsedFieldsMap) =>
-                  ValueOrErrors.Default.return(
-                    DispatchParsedType.Default.record(
-                      parsedFieldsMap.merge(
-                        parsedExtendedRecordTypesMap.reduce(
-                          (acc, type) => acc.merge(type.fields),
-                          Map(),
+                .Then(
+                  ([
+                    parsedExtendedRecordTypesMap,
+                    accumulatedAlreadyParsedTypes,
+                  ]) =>
+                    ValueOrErrors.Default.return([
+                      parsedExtendedRecordTypesMap,
+                      accumulatedAlreadyParsedTypes,
+                    ]),
+                )
+            : ValueOrErrors.Default.return([Map(), alreadyParsedTypes])
+          ).Then(
+            ([parsedExtendedRecordTypesMap, accumulatedAlreadyParsedTypes]) =>
+              Object.keys(rawType.fields)
+                .reduce(
+                  (acc, fieldName) =>
+                    acc.Then(
+                      ([
+                        parsedFieldsMap,
+                        accumulatedAlreadyParsedTypesForFields,
+                      ]) =>
+                        DispatchParsedType.Operations.ParseRawType(
+                          `Record field type: ${fieldName}`,
+                          rawType.fields[fieldName],
+                          serializedTypes,
+                          accumulatedAlreadyParsedTypesForFields,
+                          injectedPrimitives,
+                        ).Then((parsedField) =>
+                          ValueOrErrors.Default.return([
+                            parsedFieldsMap.set(fieldName, parsedField[0]),
+                            parsedField[1],
+                          ]),
                         ),
-                      ),
                     ),
-                  ).Then((parsedRecord) =>
-                    ValueOrErrors.Default.return([
-                      parsedRecord,
+                  ValueOrErrors.Default.return([
+                    Map(),
+                    accumulatedAlreadyParsedTypes,
+                  ]),
+                )
+                .Then(
+                  ([
+                    parsedFieldsMap,
+                    accumulatedAlreadyParsedTypesForFields,
+                  ]) => {
+                    const { mergedFields, updatedAccumulatedTypes } =
                       parsedExtendedRecordTypesMap.reduce(
-                        (acc, type, name) =>
-                          acc.set(name, ValueOrErrors.Default.return(type)),
-                        alreadyParsedTypes,
+                        (acc, type, name) => ({
+                          mergedFields: acc.mergedFields.merge(type.fields),
+                          updatedAccumulatedTypes:
+                            acc.updatedAccumulatedTypes.set(
+                              name,
+                              ValueOrErrors.Default.return(type),
+                            ),
+                        }),
+                        {
+                          mergedFields: Map(),
+                          updatedAccumulatedTypes:
+                            accumulatedAlreadyParsedTypesForFields,
+                        },
+                      );
+                    return ValueOrErrors.Default.return(
+                      DispatchParsedType.Default.record(
+                        parsedFieldsMap.merge(mergedFields),
                       ),
-                    ]),
-                  ),
+                    ).Then((parsedRecord) =>
+                      ValueOrErrors.Default.return([
+                        parsedRecord,
+                        updatedAccumulatedTypes,
+                      ]),
+                    );
+                  },
                 ),
-            ),
+          ),
     ParseRawFilterType: (rawFilterType, arg) => {
       if (typeof rawFilterType != "string") {
         return ValueOrErrors.Default.throwOne(`rawType is not a string`);
@@ -760,22 +802,24 @@ export const DispatchParsedType = {
     ParseRawType: (
       typeName,
       rawType,
-      typeNames,
       serializedTypes,
       alreadyParsedTypes,
       injectedPrimitives,
     ) => {
+      if (
+        alreadyParsedTypes.has(typeName) &&
+        !SerializedType.isLookup(rawType, injectedPrimitives)
+      )
+        return alreadyParsedTypes
+          .get(typeName)
+          .Then((parsedType) =>
+            ValueOrErrors.Default.return([parsedType, alreadyParsedTypes]),
+          );
       const result = (() => {
-        const stringyTypes = [
-          "guid",
-          "entityIdUUID",
-          "entityIdString",
-          "calculatedDisplayValue",
-        ];
         if (SerializedType.isPrimitive(rawType, injectedPrimitives))
           return ValueOrErrors.Default.return([
             DispatchParsedType.Default.primitive(
-              typeof rawType === "string" && stringyTypes.includes(rawType)
+              typeof rawType === "string" && STRINGY_TYPES.includes(rawType)
                 ? "string"
                 : rawType,
             ),
@@ -785,89 +829,85 @@ export const DispatchParsedType = {
           return DispatchParsedType.Operations.ParseRawType(
             `SingleSelection:Element`,
             rawType.args[0],
-            typeNames,
             serializedTypes,
             alreadyParsedTypes,
             injectedPrimitives,
-          ).Then((parsedArgs) =>
+          ).Then(([parsedArg, newAlreadyParsedTypes]) =>
             ValueOrErrors.Default.return([
-              DispatchParsedType.Default.singleSelection([parsedArgs[0]]),
-              alreadyParsedTypes,
+              DispatchParsedType.Default.singleSelection([parsedArg]),
+              newAlreadyParsedTypes,
             ]),
           );
         if (SerializedType.isMultiSelection(rawType))
           return DispatchParsedType.Operations.ParseRawType(
             `MultiSelection:Element`,
             rawType.args[0],
-            typeNames,
             serializedTypes,
             alreadyParsedTypes,
             injectedPrimitives,
-          ).Then((parsedArgs) =>
+          ).Then(([parsedArg, newAlreadyParsedTypes]) =>
             ValueOrErrors.Default.return([
-              DispatchParsedType.Default.multiSelection([parsedArgs[0]]),
-              alreadyParsedTypes,
+              DispatchParsedType.Default.multiSelection([parsedArg]),
+              newAlreadyParsedTypes,
             ]),
           );
         if (SerializedType.isList(rawType))
           return DispatchParsedType.Operations.ParseRawType(
             `List:Element`,
             rawType.args[0],
-            typeNames,
             serializedTypes,
             alreadyParsedTypes,
             injectedPrimitives,
-          ).Then((parsedArgs) =>
+          ).Then(([parsedArg, newAlreadyParsedTypes]) =>
             ValueOrErrors.Default.return([
-              DispatchParsedType.Default.list([parsedArgs[0]]),
-              alreadyParsedTypes,
+              DispatchParsedType.Default.list([parsedArg]),
+              newAlreadyParsedTypes,
             ]),
           );
         if (SerializedType.isTuple(rawType))
-          return ValueOrErrors.Operations.All(
-            List(
-              rawType.args.map((arg, index) =>
-                DispatchParsedType.Operations.ParseRawType(
-                  `Tuple:Item ${index + 1}`,
-                  arg,
-                  typeNames,
-                  serializedTypes,
-                  alreadyParsedTypes,
-                  injectedPrimitives,
+          return rawType.args
+            .reduce(
+              (acc, arg, index) =>
+                acc.Then(([parsedArgsList, accumulatedAlreadyParsedTypes]) =>
+                  DispatchParsedType.Operations.ParseRawType(
+                    `Tuple:Item ${index + 1}`,
+                    arg,
+                    serializedTypes,
+                    accumulatedAlreadyParsedTypes,
+                    injectedPrimitives,
+                  ).Then((parsedArg) =>
+                    ValueOrErrors.Default.return([
+                      parsedArgsList.push(parsedArg[0]),
+                      parsedArg[1],
+                    ]),
+                  ),
                 ),
-              ),
-            ),
-          ).Then((parsedArgs) =>
-            ValueOrErrors.Default.return([
-              DispatchParsedType.Default.tuple(
-                parsedArgs.map(([parsedArg]) => parsedArg).toArray(),
-              ),
-              alreadyParsedTypes,
-            ]),
-          );
+              ValueOrErrors.Default.return([List(), alreadyParsedTypes]),
+            )
+            .Then(([parsedArgsList, accumulatedAlreadyParsedTypes]) =>
+              ValueOrErrors.Default.return([
+                DispatchParsedType.Default.tuple(parsedArgsList.toArray()),
+                accumulatedAlreadyParsedTypes,
+              ]),
+            );
         if (SerializedType.isMap(rawType))
           return DispatchParsedType.Operations.ParseRawType(
             "Map:Key",
             rawType.args[0],
-            typeNames,
             serializedTypes,
             alreadyParsedTypes,
             injectedPrimitives,
-          ).Then((parsedArgs0) =>
+          ).Then(([parsedArg0, newAlreadyParsedTypes]) =>
             DispatchParsedType.Operations.ParseRawType(
               "Map:Value",
               rawType.args[1],
-              typeNames,
               serializedTypes,
-              alreadyParsedTypes,
+              newAlreadyParsedTypes,
               injectedPrimitives,
-            ).Then((parsedArgs1) =>
+            ).Then(([parsedArg1, newAlreadyParsedTypes2]) =>
               ValueOrErrors.Default.return([
-                DispatchParsedType.Default.map([
-                  parsedArgs0[0],
-                  parsedArgs1[0],
-                ]),
-                alreadyParsedTypes,
+                DispatchParsedType.Default.map([parsedArg0, parsedArg1]),
+                newAlreadyParsedTypes2,
               ]),
             ),
           );
@@ -875,25 +915,20 @@ export const DispatchParsedType = {
           return DispatchParsedType.Operations.ParseRawType(
             "Sum:Left",
             rawType.args[0],
-            typeNames,
             serializedTypes,
             alreadyParsedTypes,
             injectedPrimitives,
-          ).Then((parsedArgs0) =>
+          ).Then(([parsedArg0, newAlreadyParsedTypes]) =>
             DispatchParsedType.Operations.ParseRawType(
               "Sum:Right",
               rawType.args[1],
-              typeNames,
               serializedTypes,
-              alreadyParsedTypes,
+              newAlreadyParsedTypes,
               injectedPrimitives,
-            ).Then((parsedArgs1) =>
+            ).Then(([parsedArg1, newAlreadyParsedTypes2]) =>
               ValueOrErrors.Default.return([
-                DispatchParsedType.Default.sum([
-                  parsedArgs0[0],
-                  parsedArgs1[0],
-                ]),
-                alreadyParsedTypes,
+                DispatchParsedType.Default.sum([parsedArg0, parsedArg1]),
+                newAlreadyParsedTypes2,
               ]),
             ),
           );
@@ -901,7 +936,6 @@ export const DispatchParsedType = {
           return DispatchParsedType.Operations.ParseRecord(
             typeName,
             rawType,
-            typeNames,
             serializedTypes,
             alreadyParsedTypes,
             injectedPrimitives,
@@ -910,26 +944,44 @@ export const DispatchParsedType = {
           return DispatchParsedType.Operations.ParseRawType(
             "TableArg",
             rawType.args[0],
-            typeNames,
             serializedTypes,
             alreadyParsedTypes,
             injectedPrimitives,
-          ).Then((parsedArg) =>
-            parsedArg[0].kind != "lookup"
+          ).Then(([parsedArg, newAlreadyParsedTypes]) =>
+            parsedArg.kind != "lookup"
               ? ValueOrErrors.Default.throwOne(
-                  `Error: ${JSON.stringify(parsedArg[0])} is not a lookup type`,
+                  `Error: ${JSON.stringify(parsedArg)} is not a lookup type`,
                 )
               : ValueOrErrors.Default.return([
-                  DispatchParsedType.Default.table(parsedArg[0]),
-                  alreadyParsedTypes,
+                  DispatchParsedType.Default.table(parsedArg),
+                  newAlreadyParsedTypes,
                 ]),
           );
         }
-        if (SerializedType.isLookup(rawType, typeNames))
-          return ValueOrErrors.Default.return([
-            DispatchParsedType.Default.lookup(rawType),
+        if (SerializedType.isLookup(rawType, injectedPrimitives)) {
+          const resolvedType = serializedTypes[rawType];
+          if (alreadyParsedTypes.has(rawType)) {
+            return ValueOrErrors.Default.return([
+              DispatchParsedType.Default.lookup(rawType),
+              alreadyParsedTypes,
+            ]);
+          }
+          return DispatchParsedType.Operations.ParseRawType(
+            typeName,
+            resolvedType,
+            serializedTypes,
             alreadyParsedTypes,
-          ]);
+            injectedPrimitives,
+          ).Then(([parsedType, newAlreadyParsedTypes]) =>
+            ValueOrErrors.Default.return([
+              DispatchParsedType.Default.lookup(rawType),
+              newAlreadyParsedTypes.set(
+                rawType,
+                ValueOrErrors.Default.return(parsedType),
+              ),
+            ]),
+          );
+        }
         if (SerializedType.isUnit(rawType)) {
           return ValueOrErrors.Default.return([
             DispatchParsedType.Default.primitive("unit"),
@@ -937,91 +989,92 @@ export const DispatchParsedType = {
           ]);
         }
         if (SerializedType.isUnion(rawType))
-          // for now we assume all union cases are lookup types
-          return ValueOrErrors.Operations.All(
-            List(
-              rawType.args.map((unionCase) =>
-                DispatchParsedType.Operations.ParseRawType(
-                  `Union:Case ${unionCase.caseName}`,
-                  unionCase.fields == undefined
-                    ? { fields: {} }
-                    : // we allow the record fields to be defined directly in the spec instead of
-                      // inside a fields key
-                      SerializedType.isRecordFields(unionCase.fields)
-                      ? { fields: unionCase.fields }
-                      : unionCase.fields,
-                  typeNames,
-                  serializedTypes,
-                  alreadyParsedTypes,
-                  injectedPrimitives,
-                ).Then((parsedType) =>
-                  ValueOrErrors.Default.return([
-                    unionCase.caseName,
-                    parsedType[0],
-                  ]),
+          return rawType.args
+            .reduce(
+              (acc, unionCase) =>
+                acc.Then(
+                  ([parsedUnionCasesMap, accumulatedAlreadyParsedTypes]) =>
+                    DispatchParsedType.Operations.ParseRawType(
+                      isString(unionCase.fields)
+                        ? unionCase.fields
+                        : `Union:Case ${unionCase.caseName}`,
+                      unionCase.fields == undefined
+                        ? { fields: {} }
+                        : // we allow the record fields to be defined directly in the spec instead of
+                          // inside a fields key
+                          SerializedType.isRecordFields(unionCase.fields)
+                          ? { fields: unionCase.fields }
+                          : unionCase.fields,
+                      serializedTypes,
+                      accumulatedAlreadyParsedTypes,
+                      injectedPrimitives,
+                    ).Then(([parsedType, newAlreadyParsedTypes]) =>
+                      ValueOrErrors.Default.return([
+                        parsedUnionCasesMap.set(unionCase.caseName, parsedType),
+                        newAlreadyParsedTypes,
+                      ]),
+                    ),
                 ),
-              ),
-            ),
-          ).Then((parsedUnionCases) =>
-            ValueOrErrors.Default.return([
-              DispatchParsedType.Default.union(Map(parsedUnionCases)),
-              alreadyParsedTypes,
-            ]),
-          );
-        if (SerializedType.isOne(rawType))
+              ValueOrErrors.Default.return([Map(), alreadyParsedTypes]),
+            )
+            .Then(([parsedUnionCasesMap, accumulatedAlreadyParsedTypes]) =>
+              ValueOrErrors.Default.return([
+                DispatchParsedType.Default.union(parsedUnionCasesMap),
+                accumulatedAlreadyParsedTypes,
+              ]),
+            );
+        if (SerializedType.isOne(rawType)) {
           return DispatchParsedType.Operations.ParseRawType(
-            "One:Element",
             rawType.args[0],
-            typeNames,
+            rawType.args[0],
             serializedTypes,
             alreadyParsedTypes,
             injectedPrimitives,
-          ).Then((parsedArg) =>
-            parsedArg[0].kind != "lookup"
+          ).Then(([parsedArg, newAlreadyParsedTypes]) =>
+            parsedArg.kind != "lookup"
               ? ValueOrErrors.Default.throwOne(
-                  `one content type ${JSON.stringify(parsedArg[0])} is not a lookup type`,
+                  `one content type ${JSON.stringify(parsedArg)} is not a lookup type`,
                 )
               : ValueOrErrors.Default.return([
-                  DispatchParsedType.Default.one(parsedArg[0]),
-                  alreadyParsedTypes,
+                  DispatchParsedType.Default.one(parsedArg),
+                  newAlreadyParsedTypes,
                 ]),
           );
+        }
         if (SerializedType.isReadOnly(rawType))
           return DispatchParsedType.Operations.ParseRawType(
             "ReadOnly:Element",
             rawType.args[0],
-            typeNames,
             serializedTypes,
             alreadyParsedTypes,
             injectedPrimitives,
-          ).Then(([parsedArg, _]) =>
+          ).Then(([parsedArg, newAlreadyParsedTypes]) =>
             ValueOrErrors.Default.return([
               DispatchParsedType.Default.readOnly(parsedArg),
-              alreadyParsedTypes,
+              newAlreadyParsedTypes,
             ]),
           );
         if (SerializedType.isKeyOf(rawType))
           return DispatchParsedType.Operations.ParseRawKeyOf(
             rawType,
-            typeNames,
             serializedTypes,
             alreadyParsedTypes,
+            injectedPrimitives,
           );
         if (SerializedType.isTranslationOverride(rawType))
           return DispatchParsedType.Operations.ParseRawType(
             "TranslationOverride:Language",
             rawType.args[0],
-            typeNames,
             serializedTypes,
             alreadyParsedTypes,
             injectedPrimitives,
-          ).Then(([parsedArg0, ..._]) =>
+          ).Then(([parsedArg0, newAlreadyParsedTypes]) =>
             ValueOrErrors.Default.return([
               DispatchParsedType.Default.map([
                 DispatchParsedType.Default.singleSelection([parsedArg0]),
                 DispatchParsedType.Default.primitive("string"),
               ]),
-              alreadyParsedTypes,
+              newAlreadyParsedTypes,
             ]),
           );
         return ValueOrErrors.Default.throwOne(