feat(schema-compose): importing type with map from external imports

packages/schema/compose/src/resolve.ts

@@ -29,6 +29,10 @@ import {
   EnumRef,
   EnvDefinition,
   ImportedEnvDefinition,
+  MapDefinition,
+  ArrayDefinition,
+  PropertyDefinition,
+  MethodDefinition,
 } from "@polywrap/wrap-manifest-types-js";
 import {
   parseSchema,
@@ -56,6 +60,8 @@ import {
   createImportedEnvDefinition,
   visitImportedEnvDefinition,
   isImportedEnvType,
+  mapUtils,
+  ScalarType,
 } from "@polywrap/schema-parse";
 
 type ImplementationWithInterfaces = {
@@ -441,6 +447,95 @@ const extractObjectImportDependencies = (
 
 const namespaceTypes = (namespace: string): AbiTransforms => ({
   enter: {
+    PropertyDefinition: (def: PropertyDefinition & Namespaced) => {
+      if (def.__namespaced) {
+        return def;
+      }
+
+      return {
+        ...def,
+        type: mapUtils.appendNamespace(namespace, def.type),
+        __namespaced: true,
+      };
+    },
+    MethodDefinition: (def: MethodDefinition & Namespaced) => {
+      if (def.__namespaced) {
+        return def;
+      }
+
+      return {
+        ...def,
+        type: mapUtils.appendNamespace(namespace, def.type),
+        __namespaced: true,
+      };
+    },
+    MapDefinition: (def: MapDefinition & Namespaced) => {
+      if (def.__namespaced) {
+        return def;
+      }
+
+      return {
+        ...def,
+        type: mapUtils.appendNamespace(namespace, def.type),
+        __namespaced: true,
+      };
+    },
+    ArrayDefinition: (def: ArrayDefinition & Namespaced) => {
+      if (def.__namespaced) {
+        return def;
+      }
+
+      const _item = def.item && {
+        ...def.item,
+        type: mapUtils.appendNamespace(namespace, def.item.type),
+        __namespaced: true,
+      };
+
+      const _array = def.array && {
+        ...def.array,
+        type: mapUtils.appendNamespace(namespace, def.array.type),
+        __namespaced: true,
+      };
+
+      const _object = def.object && {
+        ...def.object,
+        type: mapUtils.appendNamespace(namespace, def.object.type),
+        __namespaced: true,
+      };
+
+      const _enum = def.enum && {
+        ...def.enum,
+        type: mapUtils.appendNamespace(namespace, def.enum.type),
+        __namespaced: true,
+      };
+
+      const _map = def.map && {
+        ...def.map,
+        type: mapUtils.appendNamespace(namespace, def.map.type),
+        __namespaced: true,
+      };
+
+      const _scalar = def.scalar && {
+        ...def.scalar,
+        type: mapUtils.appendNamespace(
+          namespace,
+          def.scalar.type
+        ) as ScalarType,
+        __namespaced: true,
+      };
+
+      return {
+        ...def,
+        item: _item,
+        array: _array,
+        object: _object,
+        enum: _enum,
+        map: _map,
+        scalar: _scalar,
+        type: mapUtils.appendNamespace(namespace, def.type),
+        __namespaced: true,
+      };
+    },
     ObjectRef: (def: ObjectRef & Namespaced) => {
       if (def.__namespaced) {
         return def;

packages/schema/parse/src/extract/index.ts

@@ -22,3 +22,5 @@ export const extractors: SchemaExtractorBuilder[] = [
   getEnvVisitor,
   getImportedEnvTypesVisitor,
 ];
+
+export * as mapUtils from "./utils/map-utils";

packages/schema/parse/src/extract/utils/map-utils.ts

@@ -108,6 +108,47 @@ const _toGraphQLType = (rootType: string, type: string): string => {
   }
 };
 
+const _appendNamespace = (
+  namespace: string,
+  rootType: string,
+  type: string
+): string => {
+  const parsedCurrentType = _parseCurrentType(rootType, type);
+  let { subType } = parsedCurrentType;
+  const { currentType } = parsedCurrentType;
+
+  if (!subType) {
+    return isScalarType(currentType)
+      ? currentType
+      : `${namespace}_${currentType}`;
+  }
+
+  switch (currentType) {
+    case "Array": {
+      if (subType.endsWith("!")) {
+        subType = subType.slice(0, -1);
+      }
+      return `[${_appendNamespace(namespace, rootType, subType)}]`;
+    }
+    case "Map": {
+      const firstDelimiter = subType.indexOf(",");
+
+      const keyType = subType.substring(0, firstDelimiter).trim();
+      const valType = subType.substring(firstDelimiter + 1).trim();
+
+      return `Map<${_appendNamespace(
+        namespace,
+        rootType,
+        keyType
+      )}, ${_appendNamespace(namespace, rootType, valType)}>`;
+    }
+    default:
+      throw new Error(
+        `Found unknown type ${currentType} while parsing ${rootType}`
+      );
+  }
+};
+
 const _parseMapType = (
   rootType: string,
   type: string,
@@ -189,3 +230,7 @@ export function parseMapType(type: string, name?: string): GenericDefinition {
 export function toGraphQLType(type: string): string {
   return _toGraphQLType(type, type);
 }
+
+export function appendNamespace(namespace: string, type: string): string {
+  return _appendNamespace(namespace, type, type);
+}

packages/test-cases/cases/compose/002-external-imports/00-sanity/imports-ext/external.eth/module.ts

@@ -65,7 +65,61 @@ export const abi: WrapAbi = {
               "required": true,
               "kind": 4
             }
-          }
+          },
+          {
+            "kind": 34,
+            "map":  {
+              "array":  {
+                "item":  {
+                  "kind": 8192,
+                  "name": "map",
+                  "required": true,
+                  "type": "ExternalType",
+                },
+                "kind": 18,
+                "name": "map",
+                "object":  {
+                  "kind": 8192,
+                  "name": "map",
+                  "required": true,
+                  "type": "ExternalType",
+                },
+                "required": true,
+                "type": "[ExternalType]",
+              },
+              "key":  {
+                "kind": 4,
+                "name": "map",
+                "required": true,
+                "type": "String",
+              },
+              "kind": 262146,
+              "name": "map",
+              "required": true,
+              "type": "Map<String, [ExternalType]>",
+              "value":  {
+                "item":  {
+                  "kind": 8192,
+                  "name": "map",
+                  "required": true,
+                  "type": "ExternalType",
+                },
+                "kind": 18,
+                "name": "map",
+                "object": {
+                  "kind": 8192,
+                  "name": "map",
+                  "required": true,
+                  "type": "ExternalType",
+                },
+                "required": true,
+                "type": "[ExternalType]",
+              },
+            },
+            "name": "map",
+            "required": true,
+            "type": "Map<String, [ExternalType]>",
+          },
         ],
         "return": {
           "type": "String",

packages/test-cases/cases/compose/002-external-imports/00-sanity/output/module.graphql

@@ -56,6 +56,7 @@ type Namespace_Module @imported(
 ) {
   envMethod(
     arg: String!
+    map: Map! @annotate(type: "Map<String!, [Namespace_ExternalType!]!>!")
   ): String! @env(required: true)
 
   optEnvMethod(

packages/test-cases/cases/compose/002-external-imports/00-sanity/output/module.ts

@@ -7,6 +7,10 @@ import {
   WrapAbi,
   createImportedModuleDefinition,
   createImportedEnvDefinition,
+  createMapPropertyDefinition,
+  createMapKeyDefinition,
+  createArrayDefinition,
+  createObjectRef,
 } from "@polywrap/schema-parse";
 
 export const abi: WrapAbi = {
@@ -47,6 +51,26 @@ export const abi: WrapAbi = {
               type: "String",
               required: true,
             }),
+            createMapPropertyDefinition({
+              name: "map",
+              type: "Map<String, [Namespace_ExternalType]>",
+              required: true,
+              key: createMapKeyDefinition({
+                name: "map",
+                required: true,
+                type: "String"
+              }),
+              value: createArrayDefinition({
+                name: "map",
+                type: "[Namespace_ExternalType]",
+                required: true,
+                item: createObjectRef({
+                  name: "map",
+                  type: "Namespace_ExternalType",
+                  required: true,
+                })
+              })
+            })
           ],
           env: {
             required: true

packages/test-cases/cases/wrappers/wasm-as/interface-invoke/test-interface/schema.graphql

@@ -6,6 +6,7 @@ type Module {
 
 type Argument {
   str: String!
+  map: Map @annotate(type: "Map<String!, [InterfaceType!]!>")
 }
 
 type InterfaceType {