🐛 fixed cli integration

Author: aexol

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "graphql-editor-cli",
-  "version": "0.7.3",
+  "version": "0.7.4",
   "description": "GraphQL -> anything. Use GraphQL as your source of truth. GraphQL Editor Official CLI.",
   "main": "lib/api.js",
   "author": "Artur Czemiel",

packages/cli/package-lock.json

@@ -1,7 +1,7 @@
 import { ChildProcess, spawn } from 'child_process';
 import path from 'path';
 import { SIGINT } from 'constants';
-import { findNodeModules } from '@/api';
+import { findNodeModules } from '@/api.js';
 
 export const terminate = async (ch?: ChildProcess): Promise<void | number> => {
   if (!ch) return;

packages/cli/package.json

@@ -29,31 +29,8 @@ export const getReturnTypeName = (ref: TypeRef): string | undefined => {
   return ref.name;
 };
 
-export const NewIntegration = (
-  integrationName: string,
-  integration: IntegrationSpecificationInput,
-): StuccoConfig => {
-  const res: StuccoConfig = {
-    resolvers: {},
-  };
-  // register integration
-  integrations[integrationName] = integration;
-  for (const typeName in integration) {
-    for (const fieldName in integration[typeName]) {
-      const { handler, ...field } = integration[typeName][fieldName];
-      res.resolvers = {
-        ...res.resolvers,
-        [`${typeName}.${fieldName}`]: {
-          ...field,
-          integration: 'gei',
-          resolve: {
-            name: `${integrationName}@${typeName}.${fieldName}.handler`,
-          },
-        },
-      };
-    }
-  }
-  return res;
+export const NewIntegration = (integration: IntegrationSpecificationInput) => {
+  return integration;
 };
 
 export interface Project extends StuccoConfig {

packages/cli/src/common/spawn.ts

@@ -1,45 +1,71 @@
 import fs from 'fs';
 import yargs from 'yargs';
-import { Resolvers, StuccoConfig } from './api';
+import { IntegrationSpecificationInput, StuccoConfig } from '@/api.js';
 import { fileURLToPath } from 'url';
 
-export const exists = (fn: string) => fs
-  .promises
-  .stat(fn)
-  .then(() => true)
-  .catch((e) => {
-    if (e.code === 'ENOENT') {
-      return false;
-    }
-    throw e;
-  })
+export const exists = (fn: string) =>
+  fs.promises
+    .stat(fn)
+    .then(() => true)
+    .catch((e) => {
+      if (e.code === 'ENOENT') {
+        return false;
+      }
+      throw e;
+    });
 
-export const integrate = async (stuccoJson: string, ...integrationFiles: string[]) => {
-  const stuccoFileOut: StuccoConfig = await exists(stuccoJson)
+export const integrate = async (
+  stuccoJson: string,
+  ...integrationFiles: string[]
+) => {
+  const stuccoFileOut: StuccoConfig = (await exists(stuccoJson))
     ? JSON.parse(fs.readFileSync(stuccoJson, 'utf-8'))
     : {};
 
   const res = await integrateWithConfig(stuccoFileOut, ...integrationFiles);
   fs.writeFileSync(stuccoJson, JSON.stringify(res, null, 4));
-}
+};
 
-export const integrateWithConfig = async (stuccoConfig: StuccoConfig, ...integrationFiles: string[]) => {
-  const integrations = await Promise.all(
+export const integrateWithConfig = async (
+  stuccoConfig: StuccoConfig,
+  ...integrationFiles: string[]
+) => {
+  const integrations = (await Promise.all(
     integrationFiles.map((integrationFile) =>
-      import(integrationFile).then((mod) => 'default' in mod ? mod.default : mod),
-    )
-  ) as StuccoConfig[];
+      import(integrationFile).then((mod) =>
+        'default' in mod ? mod.default : mod,
+      ),
+    ),
+  )) as IntegrationSpecificationInput[];
+
+  const res: StuccoConfig = {
+    resolvers: {},
+  };
+  // register integration
+  integrations.map((integration) => {
+    for (const typeName in integration) {
+      for (const fieldName in integration[typeName]) {
+        const { handler, ...field } = integration[typeName][fieldName];
+        res.resolvers = {
+          ...res.resolvers,
+          [`${typeName}.${fieldName}`]: {
+            ...field,
+            resolve: {
+              name: `${typeName}.${fieldName}.handler`,
+            },
+          },
+        };
+      }
+    }
+  });
   return {
     ...stuccoConfig,
     resolvers: {
       ...stuccoConfig.resolvers,
-      ...integrations.reduce((pv, cv) => ({
-        ...pv,
-        ...cv.resolvers,
-      }), {} as Resolvers),
+      ...res.resolvers,
     },
   };
-}
+};
 
 if (import.meta.url.startsWith('file:')) {
   const modulePath = fileURLToPath(import.meta.url);
@@ -57,9 +83,9 @@ if (import.meta.url.startsWith('file:')) {
           type: 'string',
           description: 'integration file path',
           default: './src/gei/integrate.ts',
-        }).argv
+        }).argv;
       await integrate(argv['stucco-json'], argv['integration-file']);
-    }
+    };
 
     main().catch((e) => {
       console.error(e);

packages/cli/src/integrations/api.ts

@@ -1,7 +1,7 @@
 {
   "name": "sandbox",
   "private": true,
-  "version": "0.7.3",
+  "version": "0.7.5",
   "description": "GraphQL -> anything. Use GraphQL as your source of truth. GraphQL Editor Official CLI.",
   "author": "Artur Czemiel",
   "license": "MIT",

packages/cli/src/integrations/integrate.ts

@@ -1,7 +1,7 @@
 import { NewIntegration } from "graphql-editor-cli";
 
 // Declare your resolver specifications here to generate JSON from it later using `gei integrate` command
-const integration = NewIntegration("gei-rest", {
+const integration = NewIntegration({
   Query: {
     rest: {
       name: "dsda",

packages/sandbox/package.json

@@ -3,9 +3,8 @@
         "Query.rest": {
             "name": "dsda",
             "description": "dsdsad",
-            "integration": "gei",
             "resolve": {
-                "name": "gei-rest@Query.rest.handler"
+                "name": "Query.rest.handler"
             }
         }
     }