chore(): start moving some packages to the core directory (#7215)

packages/core/modules-sdk/src/utils/clean-graphql-schema.ts

@@ -0,0 +1,91 @@
+import { Kind, parse, print, visit } from "graphql"
+
+export function cleanGraphQLSchema(schema: string): {
+  schema: string
+  notFound: Record<string, Record<string, string>>
+} {
+  const extractTypeNameAndKind = (type) => {
+    if (type.kind === Kind.NAMED_TYPE) {
+      return [type.name.value, type.kind]
+    }
+    if (type.kind === Kind.NON_NULL_TYPE || type.kind === Kind.LIST_TYPE) {
+      return extractTypeNameAndKind(type.type)
+    }
+    return [null, null]
+  }
+
+  const ast = parse(schema)
+
+  const typeNames = new Set(["String", "Int", "Float", "Boolean", "ID"])
+  const extendedTypes = new Set()
+
+  const kinds = [
+    Kind.OBJECT_TYPE_DEFINITION,
+    Kind.INTERFACE_TYPE_DEFINITION,
+    Kind.ENUM_TYPE_DEFINITION,
+    Kind.SCALAR_TYPE_DEFINITION,
+    Kind.INPUT_OBJECT_TYPE_DEFINITION,
+    Kind.UNION_TYPE_DEFINITION,
+  ]
+  ast.definitions.forEach((def: any) => {
+    if (kinds.includes(def.kind)) {
+      typeNames.add(def.name.value)
+    } else if (def.kind === Kind.OBJECT_TYPE_EXTENSION) {
+      extendedTypes.add(def.name.value)
+    }
+  })
+
+  const nonExistingMap: Record<string, Record<string, string>> = {}
+  const parentStack: string[] = []
+
+  /*
+    Traverse the graph mapping all the entities + fields and removing the ones that don't exist.
+    Extensions are not removed, but marked with a "__extended" key if the main entity doesn't exist. (example: Link modules injecting fields into another module)
+  */
+  const cleanedAst = visit(ast, {
+    ObjectTypeExtension: {
+      enter(node) {
+        const typeName = node.name.value
+
+        parentStack.push(typeName)
+        if (!typeNames.has(typeName)) {
+          nonExistingMap[typeName] ??= {}
+          nonExistingMap[typeName]["__extended"] = ""
+          return null
+        }
+        return
+      },
+      leave() {
+        parentStack.pop()
+      },
+    },
+    ObjectTypeDefinition: {
+      enter(node) {
+        parentStack.push(node.name.value)
+      },
+      leave() {
+        parentStack.pop()
+      },
+    },
+    FieldDefinition: {
+      leave(node) {
+        const [typeName, kind] = extractTypeNameAndKind(node.type)
+
+        if (!typeNames.has(typeName) && kind === Kind.NAMED_TYPE) {
+          const currentParent = parentStack[parentStack.length - 1]
+
+          nonExistingMap[currentParent] ??= {}
+          nonExistingMap[currentParent][node.name.value] = typeName
+          return null
+        }
+        return
+      },
+    },
+  })
+
+  // Return the schema and the map of non existing entities and fields
+  return {
+    schema: print(cleanedAst),
+    notFound: nonExistingMap,
+  }
+}

packages/core/modules-sdk/src/utils/graphql-schema-to-fields.ts

@@ -0,0 +1,93 @@
+import { GraphQLNamedType, GraphQLObjectType, isObjectType } from "graphql"
+
+/**
+ * From graphql schema get all the fields for the requested type and relations
+ *
+ * @param schemaTypeMap
+ * @param typeName
+ * @param relations
+ *
+ * @example
+ *
+ * const userModule = `
+ * type User {
+ *   id: ID!
+ *   name: String!
+ *   blabla: WHATEVER
+ * }
+ *
+ * type Post {
+ *   author: User!
+ * }
+ * `
+ *
+ * const postModule = `
+ * type Post {
+ *   id: ID!
+ *   title: String!
+ *   date: String
+ * }
+ *
+ * type User {
+ *   posts: [Post!]!
+ * }
+ *
+ * type WHATEVER {
+ *   random_field: String
+ *   post: Post
+ * }
+ * `
+ *
+ * const mergedSchema = mergeTypeDefs([userModule, postModule])
+ * const schema = makeExecutableSchema({
+ *   typeDefs: mergedSchema,
+ * })
+ *
+ * const fields = graphqlSchemaToFields(types, "User", ["posts"])
+ *
+ * console.log(fields)
+ *
+ * // [
+ * //   "id",
+ * //   "name",
+ * //   "posts.id",
+ * //   "posts.title",
+ * //   "posts.date",
+ * // ]
+ */
+export function graphqlSchemaToFields(
+  schemaTypeMap: { [key: string]: GraphQLNamedType },
+  typeName: string,
+  relations: string[] = []
+) {
+  const result: string[] = []
+
+  function traverseFields(typeName, parent = "") {
+    const type = schemaTypeMap[typeName]
+
+    if (!(type instanceof GraphQLObjectType)) {
+      return
+    }
+
+    const fields = type.getFields()
+
+    for (const fieldName in fields) {
+      const field = fields[fieldName]
+      let fieldType = field.type as any
+
+      while (fieldType.ofType) {
+        fieldType = fieldType.ofType
+      }
+
+      const composedField = parent ? `${parent}.${fieldName}` : fieldName
+      if (!isObjectType(fieldType)) {
+        result.push(composedField)
+      } else if (relations.includes(composedField)) {
+        traverseFields(fieldType.name, composedField)
+      }
+    }
+  }
+
+  traverseFields(typeName)
+  return result
+}

packages/core/modules-sdk/src/utils/index.ts

@@ -0,0 +1,3 @@
+export * from "./clean-graphql-schema"
+export * from "./graphql-schema-to-fields"
+export * from "./initialize-factory"

packages/core/modules-sdk/src/utils/initialize-factory.ts

@@ -0,0 +1,44 @@
+import {
+  ExternalModuleDeclaration,
+  InternalModuleDeclaration,
+  ModuleExports,
+  ModuleServiceInitializeCustomDataLayerOptions,
+  ModuleServiceInitializeOptions,
+} from "@medusajs/types"
+import { MODULE_PACKAGE_NAMES } from "../definitions"
+import { MedusaModule } from "../medusa-module"
+
+/**
+ * Generate a initialize module factory that is exported by the module to be initialized manually
+ *
+ * @param moduleName
+ * @param moduleDefinition
+ */
+export function initializeFactory<T>({
+  moduleName,
+  moduleDefinition,
+}: {
+  moduleName: string
+  moduleDefinition: ModuleExports
+}) {
+  return async (
+    options?:
+      | ModuleServiceInitializeOptions
+      | ModuleServiceInitializeCustomDataLayerOptions
+      | ExternalModuleDeclaration
+      | InternalModuleDeclaration,
+    injectedDependencies?: any
+  ) => {
+    const loaded = await MedusaModule.bootstrap<T>({
+      moduleKey: moduleName,
+      defaultPath: MODULE_PACKAGE_NAMES[moduleName],
+      declaration: options as
+        | InternalModuleDeclaration
+        | ExternalModuleDeclaration,
+      injectedDependencies,
+      moduleExports: moduleDefinition,
+    })
+
+    return loaded[moduleName] as T
+  }
+}

packages/core/modules-sdk/src/utils/linking-error.ts

@@ -0,0 +1,24 @@
+const typeToMethod = new Map([
+  [`dismiss`, `dismiss`],
+  [`link`, `create`],
+])
+
+type LinkingErrorMessageInput = {
+  moduleA: string
+  moduleAKey: string
+  moduleB: string
+  moduleBKey: string
+  type: "dismiss" | "link"
+}
+
+/**
+ *
+ * Example: Module to dismiss salesChannel and apiKey by keys sales_channel_id and api_key_id was not found. Ensure the link exists, keys are correct, and the link is passed in the correct order to method 'remoteLink.dismiss'
+ */
+export const linkingErrorMessage = (input: LinkingErrorMessageInput) => {
+  const { moduleA, moduleB, moduleAKey, moduleBKey, type } = input
+  return `Module to type ${moduleA} and ${moduleB} by keys ${moduleAKey} and ${moduleBKey} was not found. Ensure the link exists, keys are correct, and link is passed in the correct order to method 'remoteLink.${typeToMethod.get(
+    type
+  )}'.
+`
+}