effect-zero 0.3.2 → 0.4.0

package/src/server.ts

@@ -1,5 +1,5 @@
 import type { ReadonlyJSONValue, Schema as ZeroSchema } from "@rocicorp/zero";
-import { handleGetQueriesRequest } from "@rocicorp/zero/server";
+import { handleQueryRequest } from "@rocicorp/zero/server";
 import * as Arr from "effect/Array";
 import * as Cause from "effect/Cause";
 import * as Chunk from "effect/Chunk";
@@ -29,6 +29,10 @@ import type * as ServerTransaction from "./server-transaction.js";
 import * as Types from "./types/push.js";
 import type { TransformRequestMessage } from "./types/queries.js";
 
+// Updated to:
+// https://github.com/rocicorp/mono/blob/3082c9fa061891067b4bd7dc9fe74f798270d8d7/packages/zero-server/src/push-processor.ts
+// https://github.com/rocicorp/mono/blob/3082c9fa061891067b4bd7dc9fe74f798270d8d7/packages/zero-server/src/process-mutations.ts
+
 type ServerTransactionContext<TSchema extends ZeroSchema, TTransaction> = Omit<
   ReturnType<typeof ServerTransaction.make<string, TSchema, TTransaction>>,
   "use"
@@ -54,6 +58,7 @@ export const processPush = Effect.fn(function* <
         if (mutation.type !== "custom") {
           return yield* new CustomMutationExpectedError();
         }
+
         return yield* processMutation<Mutators.ExtractMutatorsRequirements<TMutators>>(mutators, mutation).pipe(
           Effect.catchAll((e) => processMutationError(transaction, e)),
           Effect.map((result) =>
@@ -65,6 +70,7 @@ export const processPush = Effect.fn(function* <
             clientGroupID: request.clientGroupID,
             upstreamSchema: params.schema,
           }),
+          Effect.provide(ServerSynchronizationContext.Default),
         );
       }),
     ),
@@ -76,7 +82,7 @@ export const processPush = Effect.fn(function* <
   );
 
   return { mutations: Chunk.toArray(responses) } satisfies Types.PushResponse;
-}, Effect.provide(ServerSynchronizationContext.Default));
+});
 
 const processMutation = Effect.fn(function* <R>(mutators: Mutators.AnyMutators<R>, mutation: Types.Mutation) {
   // Support both "namespace|name" and "namespace.name" formats, and single-segment names.
@@ -179,7 +185,7 @@ class MutationUserError extends Data.TaggedError("MutationUserError")<{
   }
 }
 
-export const handleGetQueries = Effect.fn(function* <E, R1, R2>(
+export const handleQuery = Effect.fn(function* <E, R1, R2>(
   queries: MakeQueryResult<E, R1, R2>[],
   schema: ZeroSchema,
   payload: TransformRequestMessage,
@@ -187,19 +193,15 @@ export const handleGetQueries = Effect.fn(function* <E, R1, R2>(
   const runtime = yield* Effect.runtime<R1 | R2>();
   return yield* Effect.tryPromise({
     try: () =>
-      handleGetQueriesRequest(
+      handleQueryRequest(
         (name, args) =>
           Arr.findFirst(queries, (q) => q[QueryNameSymbol] === name).pipe(
             Effect.catchTag("NoSuchElementException", () => new QueryNotFound({ name })),
             Effect.flatMap((query) => query[RunQuerySymbol]({ _tag: "Encoded", args })),
-            Effect.map((query) => ({ query })),
-            (effect) => Runtime.runPromiseExit(runtime, effect),
-            (exit) =>
-              exit.then(
-                Exit.getOrElse((cause) => {
-                  throw new QueryUserError<E>({ cause });
-                }),
-              ),
+            (effect) => Runtime.runSyncExit(runtime, effect),
+            Exit.getOrElse((cause) => {
+              throw new QueryUserError<E>({ cause });
+            }),
           ),
         schema,
         payload as ReadonlyJSONValue,
@@ -207,7 +209,7 @@ export const handleGetQueries = Effect.fn(function* <E, R1, R2>(
     catch: (e) =>
       Option.liftPredicate(e, QueryUserError.is<E>).pipe(
         Option.flatMap((e) => Cause.failureOption(e.cause)),
-        Option.getOrElse(() => new GetQueriesError({ cause: Cause.fail(e) })),
+        Option.getOrElse(() => new QueryRequestError({ cause: Cause.fail(e) })),
       ),
   });
 });
@@ -228,4 +230,4 @@ class QueryUserError<E> extends Data.TaggedError("QueryUserError")<{
   }
 }
 
-class GetQueriesError extends Data.TaggedError("GetQueriesError")<{ cause: Cause.Cause<unknown> }> {}
+class QueryRequestError extends Data.TaggedError("QueryRequestError")<{ cause: Cause.Cause<unknown> }> {}

package/src/snapshot.ts

@@ -2,8 +2,8 @@
 // https://github.com/rocicorp/mono/blob/30f209f2946b4cf2cd2dee459849351498f11308/packages/zero-react/src/use-query.tsx
 // https://github.com/rocicorp/mono/blob/30f209f2946b4cf2cd2dee459849351498f11308/packages/shared/src/deep-clone.ts#L4
 
-import type { JSONValue, ReadonlyJSONValue } from "@rocicorp/zero";
-import type { HumanReadable, QueryResult } from "@rocicorp/zero/react";
+import type { HumanReadable, JSONValue, ReadonlyJSONValue } from "@rocicorp/zero";
+import type { QueryResult } from "@rocicorp/zero/react";
 
 const emptyArray: unknown[] = [];
 

package/src/internal/server.test.ts

@@ -1,37 +0,0 @@
-import { describe, it } from "@effect/vitest";
-import * as Cause from "effect/Cause";
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import { NoTransactionError, ServerSynchronizationContext } from "./server.js";
-
-describe("ServerSynchronizationContext", () => {
-  it.effect(
-    "finalize should return NoTransactionError when called without guard",
-    Effect.fn(function* ({ expect }) {
-      const result = yield* Effect.void.pipe(
-        ServerSynchronizationContext.finalize,
-        Effect.provide(ServerSynchronizationContext.Default),
-        Effect.exit,
-      );
-      Exit.match(result, {
-        onSuccess: () => expect.fail("Expected failure"),
-        onFailure: (cause) => expect(cause).toStrictEqual(Cause.fail(new NoTransactionError())),
-      });
-    }),
-  );
-
-  it.effect(
-    "finalize shouldn't return errors when called with guard",
-    Effect.fn(function* ({ expect }) {
-      const result = yield* Effect.void.pipe(
-        ServerSynchronizationContext.guard,
-        ServerSynchronizationContext.finalize,
-        Effect.provide(ServerSynchronizationContext.Default),
-        Effect.exit,
-      );
-      if (Exit.isFailure(result)) {
-        expect.fail("Expected success", result.cause);
-      }
-    }),
-  );
-});