WIP: Add t.effect on field builder (#40)

* Add `t.effect` types

* Add changeset

* Add changeset

* Update

* Changeset

.changeset/new-crabs-report.md

@@ -0,0 +1,5 @@
+---
+"pothos-plugin-effect": minor
+---
+
+Add `t.effect` on field builder

.changeset/strange-monkeys-dress.md

@@ -0,0 +1,7 @@
+---
+"pothos-plugin-effect": minor
+"graphql-effect": minor
+"effect-utils": minor
+---
+
+Support Stream

packages/effect-utils/package.json

@@ -43,7 +43,7 @@
   "devDependencies": {
     "@types/node": "^20.12.7",
     "@vitest/coverage-v8": "*",
-    "effect": "^3.0.6",
+    "effect": "^3.1.0",
     "nanobundle": "*",
     "typescript": "*",
     "vitest": "*"

packages/effect-utils/src/index.ts

@@ -1,3 +1,4 @@
 export { executeEffect } from './executeEffect.js';
 export { executeStream } from './executeStream.js';
+export { isStream } from './isStream.js';
 export type { InferValueType } from './types.js';

packages/effect-utils/src/isStream.test.ts

@@ -0,0 +1,18 @@
+import { expect, test } from 'vitest';
+import { isStream } from './isStream.js';
+import { Effect, pipe, Stream } from 'effect';
+
+test('should returns false if value is Effect', () => {
+  const result = isStream(Effect.succeed(1));
+  expect(result).toBe(false);
+});
+
+test('should returns true if value is Stream', () => {
+  const result = isStream(Stream.make(1));
+  expect(result).toBe(true);
+});
+
+test('should returns false if value is not Effect or Stream ', () => {
+  const result = isStream({ pipe: () => void 0 });
+  expect(result).toBe(false);
+});

packages/effect-utils/src/isStream.ts

@@ -0,0 +1,12 @@
+import { Effect, Stream } from 'effect';
+
+// This is a unsafe way to check if a value is a Stream.
+// I hope that the Effect will expose the `Stream.isStream` function.
+export const isStream = <A, E, R>(
+  value: unknown,
+): value is Stream.Stream<A, E, R> => {
+  return (
+    Effect.isEffect(value) === false &&
+    Object.getPrototypeOf(value).constructor.name.startsWith('Stream')
+  );
+};

packages/graphql-effect/package.json

@@ -45,7 +45,7 @@
   "devDependencies": {
     "@graphql-tools/schema": "^10.0.3",
     "@types/node": "^20.12.7",
-    "effect": "^3.0.6",
+    "effect": "^3.1.0",
     "graphql": "^16.8.1",
     "nanobundle": "*",
     "typescript": "*",

packages/graphql-effect/src/effectResolver.test.ts

@@ -0,0 +1,43 @@
+import { Effect, Stream } from 'effect';
+import { GraphQLFieldResolver } from 'graphql';
+import { expect, test } from 'vitest';
+import { effectResolver } from './effectResolver.js';
+
+const fromAsync = async <T>(iterator: AsyncIterable<T>) => {
+  const result = [];
+
+  for await (const value of iterator) {
+    result.push(value);
+  }
+
+  return result;
+};
+
+test('should resolve Effect as a resolver value', async () => {
+  const resolve: GraphQLFieldResolver<unknown, unknown> = async (
+    _source,
+    _args,
+    _context,
+    _info,
+  ) => Effect.succeed(1);
+
+  const result = await effectResolver(resolve)({}, {}, {}, {} as never);
+
+  expect(result).toBe(1);
+});
+
+test('should resolve Stream as a resolver value', async () => {
+  const resolve: GraphQLFieldResolver<unknown, unknown> = async (
+    _source,
+    _args,
+    _context,
+    _info,
+  ) => Stream.range(1, 5);
+
+  const result = await fromAsync(
+    // @ts-ignore
+    await effectResolver(resolve)({}, {}, {}, {} as never),
+  );
+
+  expect(result).toEqual([1, 2, 3, 4, 5]);
+});

packages/graphql-effect/src/effectResolver.ts

@@ -0,0 +1,24 @@
+import { Effect, Runtime } from 'effect';
+import { executeEffect, executeStream, isStream } from 'effect-utils';
+import type { GraphQLFieldResolver } from 'graphql';
+
+export const effectResolver =
+  (
+    resolve: GraphQLFieldResolver<any, any>,
+    runtime = Runtime.defaultRuntime,
+  ): GraphQLFieldResolver<any, any> =>
+  async (source, args, context, info) => {
+    const result = await resolve(source, args, context, info);
+
+    if (Effect.isEffect(result)) {
+      // @ts-ignore
+      return executeEffect(result, runtime);
+    }
+
+    if (isStream(result)) {
+      // @ts-ignore
+      return executeStream(result, runtime);
+    }
+
+    return result;
+  };

packages/graphql-effect/src/enableExecuteEffect.test.ts

@@ -1,9 +1,19 @@
 import { makeExecutableSchema } from '@graphql-tools/schema';
-import { Context, Effect, Layer, Scope } from 'effect';
-import { execute, parse } from 'graphql';
+import { Context, Effect, Layer, Scope, Stream } from 'effect';
+import { execute, parse, subscribe } from 'graphql';
 import { expect, test } from 'vitest';
 import { enableExecuteEffect } from './enableExecuteEffect.js';
 
+const fromAsync = async <T>(iterator: AsyncIterable<T>) => {
+  const result = [];
+
+  for await (const value of iterator) {
+    result.push(value);
+  }
+
+  return result;
+};
+
 interface EntityService {
   getEntityContent(): Effect.Effect<string>;
 }
@@ -18,7 +28,12 @@ const baseSchema = makeExecutableSchema({
   typeDefs: `type Query {
     foo: String!
     bar: String!
-  }`,
+  }
+  
+  type Subscription {
+    foo: Int!
+  }
+  `,
   resolvers: {
     Query: {
       foo: () => {
@@ -30,6 +45,12 @@ const baseSchema = makeExecutableSchema({
           return yield* entityService.getEntityContent();
         }),
     },
+    Subscription: {
+      foo: {
+        subscribe: () => Stream.range(1, 5),
+        resolve: (value) => value,
+      },
+    },
   },
 });
 
@@ -63,3 +84,41 @@ test('should return "bar" as result', async () => {
     }
   `);
 });
+
+test('should resolve Stream as subscription', async () => {
+  const schema = enableExecuteEffect(baseSchema);
+  const result = await subscribe({
+    schema,
+    document: parse(`subscription { foo }`),
+  });
+
+  expect(await fromAsync(result as any)).toMatchInlineSnapshot(`
+    [
+      {
+        "data": {
+          "foo": 1,
+        },
+      },
+      {
+        "data": {
+          "foo": 2,
+        },
+      },
+      {
+        "data": {
+          "foo": 3,
+        },
+      },
+      {
+        "data": {
+          "foo": 4,
+        },
+      },
+      {
+        "data": {
+          "foo": 5,
+        },
+      },
+    ]
+  `);
+});

packages/graphql-effect/src/enableExecuteEffect.ts

@@ -1,27 +1,21 @@
 import { MapperKind, mapSchema } from '@graphql-tools/utils';
-import { Effect, Runtime } from 'effect';
-import { executeEffect } from 'effect-utils';
+import { Runtime } from 'effect';
 import { GraphQLSchema } from 'graphql';
+import { effectResolver } from './effectResolver.js';
 
 export function enableExecuteEffect<R>(
   schema: GraphQLSchema,
   runtime: Runtime.Runtime<R> = Runtime.defaultRuntime as never,
 ) {
   return mapSchema(schema, {
     [MapperKind.OBJECT_FIELD](fieldConfig) {
-      const originalResolve = fieldConfig.resolve;
+      if (fieldConfig.resolve) {
+        fieldConfig.resolve = effectResolver(fieldConfig.resolve, runtime);
+      }
 
-      fieldConfig.resolve = async (source, args, context, info) => {
-        if (originalResolve) {
-          const result = await originalResolve(source, args, context, info);
-
-          if (Effect.isEffect(result)) {
-            return executeEffect(result as never, runtime);
-          }
-
-          return result;
-        }
-      };
+      if (fieldConfig.subscribe) {
+        fieldConfig.subscribe = effectResolver(fieldConfig.subscribe, runtime);
+      }
 
       return fieldConfig;
     },

packages/graphql-effect/src/index.ts

@@ -1 +1,2 @@
 export { enableExecuteEffect } from './enableExecuteEffect.js';
+export { effectResolver } from './effectResolver.js';

packages/pothos-plugin-effect/package.json

@@ -50,7 +50,7 @@
     "better-sqlite3": "^9.4.0",
     "drizzle-kit": "^0.20.14",
     "drizzle-orm": "^0.29.3",
-    "effect": "^3.0.0",
+    "effect": "^3.1.5",
     "graphql": "*",
     "nanobundle": "*",
     "prisma": "5.9.1",
@@ -63,8 +63,7 @@
     "graphql": "^16 || ^17"
   },
   "dependencies": {
-    "effect-utils": "workspace:^",
-    "type-plus": "^7.6.0"
+    "effect-utils": "workspace:^"
   },
   "packageManager": "[email protected]"
 }