Merge pull request #340 from objectstack-ai/copilot/fix-job-step-error

hotlong · web-flow · commit 458bdfd1371b · 2026-02-03T16:57:53.000+08:00
diff --git a/packages/protocols/graphql/src/index.ts b/packages/protocols/graphql/src/index.ts
@@ -12,6 +12,7 @@ import type { RuntimePlugin, RuntimeContext } from '@objectql/types';
 import { ApolloServer, HeaderMap } from '@apollo/server';
 import { expressMiddleware } from '@apollo/server/express4';
 import { ApolloServerPluginDrainHttpServer } from '@apollo/server/plugin/drainHttpServer';
+import { ApolloServerPluginLandingPageDisabled } from '@apollo/server/plugin/disabled';
 import { buildSubgraphSchema } from '@apollo/subgraph';
 import { gql } from 'graphql-tag';
 import { createServer } from 'http';
@@ -35,6 +36,8 @@ export interface GraphQLPluginConfig {
     port?: number;
     /** Enable introspection (also enables Apollo Sandbox in development) */
     introspection?: boolean;
+    /** Enable GraphQL Playground/landing page (Apollo Sandbox). When false, disables the landing page. */
+    playground?: boolean;
     /** Custom type definitions (optional) */
     typeDefs?: string;
     /** Enable subscriptions via WebSocket */
@@ -219,21 +222,28 @@ export class GraphQLPlugin implements RuntimePlugin {
         }
 
         // Create Apollo Server with WebSocket support
+        const plugins: any[] = [
+            ApolloServerPluginDrainHttpServer({ httpServer: this.httpServer }),
+            {
+                async serverWillStart() {
+                    return {
+                        async drainServer() {
+                            // Cleanup WebSocket server on shutdown
+                        }
+                    };
+                }
+            }
+        ];
+
+        // Disable landing page in test mode when playground is explicitly set to false
+        if (this.config.playground === false) {
+            plugins.push(ApolloServerPluginLandingPageDisabled());
+        }
+
         this.server = new ApolloServer({
             schema,
             introspection: this.config.introspection,
-            plugins: [
-                ApolloServerPluginDrainHttpServer({ httpServer: this.httpServer }),
-                {
-                    async serverWillStart() {
-                        return {
-                            async drainServer() {
-                                // Cleanup WebSocket server on shutdown
-                            }
-                        };
-                    }
-                }
-            ],
+            plugins,
             includeStacktraceInErrorResponses: process.env.NODE_ENV !== 'production',
             formatError: (formattedError, error) => {
                 return {
@@ -296,16 +306,23 @@ export class GraphQLPlugin implements RuntimePlugin {
         const schema = makeExecutableSchema({ typeDefs, resolvers });
 
         // Initialize Apollo Server (without express middleware yet)
+        const plugins: any[] = [
+            {
+                async serverWillStart() {
+                    return { async drainServer() {} };
+                }
+            }
+        ];
+
+        // Disable landing page in test mode when playground is explicitly set to false
+        if (this.config.playground === false) {
+            plugins.push(ApolloServerPluginLandingPageDisabled());
+        }
+
         this.server = new ApolloServer({
             schema,
             introspection: this.config.introspection,
-            plugins: [
-                {
-                    async serverWillStart() {
-                        return { async drainServer() {} };
-                    }
-                }
-            ],
+            plugins,
             includeStacktraceInErrorResponses: process.env.NODE_ENV !== 'production',
         });
 
@@ -646,6 +663,13 @@ export class GraphQLPlugin implements RuntimePlugin {
         const objectTypes = this.getMetaTypes();
         
         let typeDefs = `#graphql
+  # Custom scalars
+  """
+  Represents arbitrary JSON values. Can be used for dynamic data structures.
+  Supports objects, arrays, strings, numbers, booleans, and null.
+  """
+  scalar JSON
+  
   # Common filter types
   input StringFilter {
     eq: String
@@ -959,7 +983,46 @@ export class GraphQLPlugin implements RuntimePlugin {
     private generateResolvers(): any {
         const objectTypes = this.getMetaTypes();
         
+        // Helper function for parsing GraphQL literals to JSON
+        const parseLiteral = (ast: any): any => {
+            if (ast.kind === 'StringValue') {
+                return JSON.parse(ast.value);
+            }
+            if (ast.kind === 'IntValue' || ast.kind === 'FloatValue') {
+                return parseFloat(ast.value);
+            }
+            if (ast.kind === 'BooleanValue') {
+                return ast.value;
+            }
+            if (ast.kind === 'NullValue') {
+                return null;
+            }
+            if (ast.kind === 'ObjectValue') {
+                const obj: any = {};
+                ast.fields.forEach((field: any) => {
+                    obj[field.name.value] = parseLiteral(field.value);
+                });
+                return obj;
+            }
+            if (ast.kind === 'ListValue') {
+                return ast.values.map((value: any) => parseLiteral(value));
+            }
+            return null;
+        };
+        
         const resolvers: any = {
+            // JSON scalar resolver - passes through any value
+            JSON: {
+                __parseValue(value: any) {
+                    return value; // value from the client input variables
+                },
+                __serialize(value: any) {
+                    return value; // value sent to the client
+                },
+                __parseLiteral(ast: any) {
+                    return parseLiteral(ast);
+                }
+            },
             Query: {
                 hello: () => 'Hello from GraphQL Protocol Plugin with Subscriptions!',
                 
diff --git a/packages/protocols/graphql/src/tck.test.ts b/packages/protocols/graphql/src/tck.test.ts
@@ -25,7 +25,7 @@ class GraphQLEndpoint implements ProtocolEndpoint {
   constructor(plugin: GraphQLPlugin, kernel: ObjectKernel) {
     this.plugin = plugin;
     this.kernel = kernel;
-    this.baseUrl = `http://localhost:${plugin.config.port || 4000}`;
+    this.baseUrl = `http://localhost:${plugin.config.port || 4000}/graphql`;
   }
   
   async execute(operation: ProtocolOperation): Promise<ProtocolResponse> {
@@ -66,12 +66,12 @@ class GraphQLEndpoint implements ProtocolEndpoint {
   private async executeCreate(operation: ProtocolOperation): Promise<ProtocolResponse> {
     const entityName = this.capitalize(operation.entity);
     const mutation = `
-      mutation Create${entityName}($data: JSON!) {
-        create${entityName}(data: $data)
+      mutation Create${entityName}($input: ${entityName}Input!) {
+        create${entityName}(input: $input)
       }
     `;
     
-    const result = await this.graphqlRequest(mutation, { data: operation.data });
+    const result = await this.graphqlRequest(mutation, { input: operation.data });
     
     if (result.errors) {
       return {
@@ -91,9 +91,10 @@ class GraphQLEndpoint implements ProtocolEndpoint {
   
   private async executeRead(operation: ProtocolOperation): Promise<ProtocolResponse> {
     const entityName = this.capitalize(operation.entity);
+    const camelName = this.toCamelCase(operation.entity);
     const query = `
-      query Get${entityName}($id: String!) {
-        ${operation.entity}(id: $id)
+      query Get${entityName}($id: ID!) {
+        ${camelName}(id: $id)
       }
     `;
     
@@ -111,21 +112,21 @@ class GraphQLEndpoint implements ProtocolEndpoint {
     
     return {
       success: true,
-      data: result.data[operation.entity]
+      data: result.data[camelName]
     };
   }
   
   private async executeUpdate(operation: ProtocolOperation): Promise<ProtocolResponse> {
     const entityName = this.capitalize(operation.entity);
     const mutation = `
-      mutation Update${entityName}($id: String!, $data: JSON!) {
-        update${entityName}(id: $id, data: $data)
+      mutation Update${entityName}($id: ID!, $input: ${entityName}UpdateInput!) {
+        update${entityName}(id: $id, input: $input)
       }
     `;
     
     const result = await this.graphqlRequest(mutation, {
       id: operation.id,
-      data: operation.data
+      input: operation.data
     });
     
     if (result.errors) {
@@ -147,7 +148,7 @@ class GraphQLEndpoint implements ProtocolEndpoint {
   private async executeDelete(operation: ProtocolOperation): Promise<ProtocolResponse> {
     const entityName = this.capitalize(operation.entity);
     const mutation = `
-      mutation Delete${entityName}($id: String!) {
+      mutation Delete${entityName}($id: ID!) {
         delete${entityName}(id: $id)
       }
     `;
@@ -172,13 +173,14 @@ class GraphQLEndpoint implements ProtocolEndpoint {
   
   private async executeQuery(operation: ProtocolOperation): Promise<ProtocolResponse> {
     const entityName = this.capitalize(operation.entity);
+    const camelName = this.toCamelCase(operation.entity);
     
     let queryArgs = '';
     const variables: any = {};
     
     if (operation.filter) {
-      queryArgs += '$filter: JSON';
-      variables.filter = operation.filter;
+      queryArgs += `$where: ${entityName}Filter`;
+      variables.where = operation.filter;
     }
     
     if (operation.options?.limit) {
@@ -195,7 +197,7 @@ class GraphQLEndpoint implements ProtocolEndpoint {
     
     const query = `
       query List${entityName}${queryArgs ? `(${queryArgs})` : ''} {
-        ${operation.entity}List${this.buildQueryArgs(variables)}
+        ${camelName}List${this.buildQueryArgs(variables)}
       }
     `;
     
@@ -213,7 +215,7 @@ class GraphQLEndpoint implements ProtocolEndpoint {
     
     return {
       success: true,
-      data: result.data[`${operation.entity}List`] || []
+      data: result.data[`${camelName}List`] || []
     };
   }
   
@@ -232,16 +234,16 @@ class GraphQLEndpoint implements ProtocolEndpoint {
     }
     
     const mutations = operation.data.map((item, index) => `
-      item${index}: create${entityName}(data: $data${index})
+      item${index}: create${entityName}(input: $input${index})
     `).join('\n');
     
     const variables: any = {};
     const variableDefinitions = operation.data.map((_, index) => 
-      `$data${index}: JSON!`
+      `$input${index}: ${entityName}Input!`
     ).join(', ');
     
     operation.data.forEach((item, index) => {
-      variables[`data${index}`] = item;
+      variables[`input${index}`] = item;
     });
     
     const mutation = `
@@ -307,11 +309,27 @@ class GraphQLEndpoint implements ProtocolEndpoint {
       body: JSON.stringify({ query, variables })
     });
     
+    const contentType = response.headers.get('content-type');
+    if (!contentType || !contentType.includes('application/json')) {
+      const text = await response.text();
+      throw new Error(`Expected JSON response but got: ${contentType}. Response: ${text.substring(0, 200)}`);
+    }
+    
     return await response.json();
   }
   
   private capitalize(str: string): string {
-    return str.charAt(0).toUpperCase() + str.slice(1);
+    // Convert to PascalCase (handle underscores and hyphens)
+    return str
+      .split(/[_-]/)
+      .filter(word => word.length > 0) // Remove empty segments
+      .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+      .join('');
+  }
+  
+  private toCamelCase(str: string): string {
+    const pascal = this.capitalize(str);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
   }
   
   private buildQueryArgs(variables: any): string {
