effect-zero 0.1.1 → 0.2.0

package/src/client.ts

@@ -1,8 +1,5 @@
-import { Atom } from "@effect-atom/atom";
-import type { HumanReadable, Query, ReadonlyJSONValue, Transaction, Schema as ZeroSchema } from "@rocicorp/zero";
-import type { QueryResult } from "@rocicorp/zero/react";
+import { Zero, type ZeroOptions, type Schema as ZeroSchema, type Transaction as ZeroTransaction } from "@rocicorp/zero";
 import * as Cause from "effect/Cause";
-import * as Context from "effect/Context";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
@@ -12,119 +9,72 @@ import * as Predicate from "effect/Predicate";
 import * as Rec from "effect/Record";
 import * as Runtime from "effect/Runtime";
 import * as Schema from "effect/Schema";
-import * as Stream from "effect/Stream";
-import * as Subscribable from "effect/Subscribable";
-import * as SubscriptionRef from "effect/SubscriptionRef";
-import {
-  type AnyMutator,
-  type AnyMutators,
-  type ExtractMutatorsRequirements,
-  MutatorArgsSchemaSym,
-} from "./mutators.js";
-import { deepClone, getDefaultSnapshot, getSnapshot } from "./snapshot.js";
-import { prefixId } from "./utils.js";
-
-// Updated to: https://github.com/rocicorp/mono/blob/2e18f2e1d084c530ebd9bd7fef9bb848e607cc19/packages/zero-pg/src/push-processor.ts
-
-// Necessary workaround for TS declaration generation
-export interface ZeroClientTransaction {
-  readonly _tag: unique symbol;
-}
-
-export const makeClient = <S extends ZeroSchema>() => {
-  // TODO: Maybe prefix this / suffix this with a tag passed in to `make`?
-  const ZeroClientTransaction = Context.Tag(prefixId("ZeroClientTransaction"))<ZeroClientTransaction, Transaction<S>>();
-
-  const use = <A>(fn: (transaction: Transaction<S>, options: { readonly signal: AbortSignal }) => PromiseLike<A>) =>
-    Effect.flatMap(ZeroClientTransaction, (transaction) =>
-      Effect.promise((signal) => fn(transaction, { signal })),
-    ).pipe(
-      Effect.tapErrorCause((cause) => Effect.logError(cause)),
-      Effect.sandbox,
-      Effect.annotateLogs({ module: prefixId("ZeroClient.Transaction"), method: "use" }),
-      Effect.mapError((cause) => new ZeroClientTransactionError({ cause })),
-    );
-
-  const unwrapMutators = Effect.fn(function* <T extends AnyMutators>(mutators: T) {
-    const runtime = yield* Effect.runtime<Exclude<ExtractMutatorsRequirements<T>, ZeroClientTransaction>>();
-
-    function unwrapMutator<E>(mutator: AnyMutator<ExtractMutatorsRequirements<T>, E>) {
-      return async (tx: Transaction<S>, args: unknown) => {
-        const exit = await Schema.decode(mutator[MutatorArgsSchemaSym])(args).pipe(
-          Effect.catchTag("ParseError", (e) => new ZeroClientArgsParseError({ cause: Cause.fail(e) })),
-          Effect.flatMap(mutator),
-          Effect.provideService(ZeroClientTransaction, tx),
-          Runtime.runPromiseExit(runtime),
-        );
-        return Exit.getOrElse(exit, (c) => {
-          // Extract underlying error bypassing FiberFailure
-          throw Cause.squash(c);
-        });
-      };
-    }
-
-    return Rec.map(mutators, (v) =>
-      Match.value(v).pipe(Match.when(Predicate.isFunction, unwrapMutator), Match.orElse(Rec.map(unwrapMutator))),
-    ) as UnwrapMutators<S, T>;
-  });
-
-  const querySub = Effect.fn(function* <T extends keyof S["tables"] & string, R>(query: Query<S, T, R>) {
-    const view = yield* Effect.acquireRelease(
-      Effect.sync(() => query.materialize()),
-      (view) => Effect.sync(() => view.destroy()),
-    );
-
-    const subscriptionRef = yield* SubscriptionRef.make<QueryResult<R>>(getDefaultSnapshot(query.format.singular));
-
-    yield* Stream.asyncEffect<Parameters<Parameters<(typeof view)["addListener"]>[0]>>((emit) =>
-      Effect.sync(() => view.addListener((...args) => emit.single(args))),
-    ).pipe(
-      Stream.mapEffect(([data, resultType]) =>
-        Effect.sync(() => {
-          // logic here borrowed from: https://github.com/rocicorp/mono/blob/288b00ec94f5a9ae6e988513423af25c281dbb2a/packages/zero-react/src/use-query.tsx#L295
-          const cloned = data === undefined ? data : (deepClone(data as ReadonlyJSONValue) as HumanReadable<R>);
-          return getSnapshot<R>(query.format.singular, cloned, resultType);
-        }),
-      ),
-      Stream.runForEach((snapshot) => SubscriptionRef.set(subscriptionRef, snapshot)),
-      Effect.forkScoped,
-    );
-
-    return subscriptionRef.pipe(
-      Subscribable.map(([data, { type: status }]) => ({
-        data,
-        status,
-      })),
-    );
-  });
-
-  /** Create an Atom for the query */
-  const queryAtom = Atom.family(<T extends keyof S["tables"] & string, R>(query: Query<S, T, R>) =>
-    Atom.subscribable(querySub(query)).pipe(Atom.mapResult((res) => res.data)),
+import type * as ClientTransaction from "./client-transaction.js";
+import * as Mutators from "./mutators.js";
+
+type ClientTransactionContext<TSchema extends ZeroSchema> = Omit<
+  ReturnType<typeof ClientTransaction.make<string, TSchema>>,
+  "use"
+>;
+
+export const make = Effect.fn(function* <TSchema extends ZeroSchema, TMutators extends Mutators.AnyMutators>(
+  transaction: ClientTransactionContext<TSchema>,
+  mutators: TMutators,
+  options: Omit<ZeroOptions<TSchema>, "schema" | "mutators">,
+) {
+  const runtime =
+    yield* Effect.runtime<
+      Exclude<Mutators.ExtractMutatorsRequirements<TMutators>, ClientTransaction.ClientTransaction>
+    >();
+
+  function unwrapMutator<E>(mutator: Mutators.AnyMutator<Mutators.ExtractMutatorsRequirements<TMutators>, E>) {
+    return async (tx: ZeroTransaction<TSchema>, args: unknown) => {
+      const exit = await Schema.decode(mutator[Mutators.MutatorSchemaSymbol])(args).pipe(
+        Effect.catchTag("ParseError", (e) => new ClientArgsParseError({ cause: Cause.fail(e) })),
+        Effect.flatMap(mutator),
+        Effect.provideService(transaction, tx),
+        Runtime.runPromiseExit(runtime),
+      );
+      return Exit.getOrElse(exit, (c) => {
+        // Extract underlying error bypassing FiberFailure
+        throw Cause.squash(c);
+      });
+    };
+  }
+
+  const unwrappedMutators = Rec.map(mutators, (v) =>
+    Match.value(v).pipe(Match.when(Predicate.isFunction, unwrapMutator), Match.orElse(Rec.map(unwrapMutator))),
+  ) as UnwrapMutators<TSchema, TMutators>;
+
+  return yield* Effect.acquireRelease(
+    Effect.sync(() => {
+      return new Zero({
+        ...options,
+        schema: transaction.schema,
+        mutators: unwrappedMutators,
+      });
+    }),
+    (zero) => Effect.promise(() => zero.close()),
   );
-
-  return {
-    unwrapMutators,
-    querySub,
-    queryAtom,
-    Transaction: Object.assign(ZeroClientTransaction, { use }),
-  };
-};
-
-type UnwrapMutator<S extends ZeroSchema, T extends AnyMutator> = Parameters<T> extends []
-  ? (transaction: Transaction<S>) => Promise<void>
-  : (transaction: Transaction<S>, args: Schema.Schema.Encoded<T[typeof MutatorArgsSchemaSym]>) => Promise<void>;
-
-export type UnwrapMutators<S extends ZeroSchema, T extends AnyMutators> = {
-  [A in keyof T]: T[A] extends AnyMutator
-    ? UnwrapMutator<S, T[A]>
-    : { [B in keyof T[A]]: T[A][B] extends AnyMutator ? UnwrapMutator<S, T[A][B]> : never };
+});
+
+type UnwrapMutator<TSchema extends ZeroSchema, TMutators extends Mutators.AnyMutator> = Parameters<TMutators> extends []
+  ? (transaction: ZeroTransaction<TSchema>) => Promise<void>
+  : (
+      transaction: ZeroTransaction<TSchema>,
+      args: Schema.Schema.Encoded<TMutators[typeof Mutators.MutatorSchemaSymbol]>,
+    ) => Promise<void>;
+
+type UnwrapMutators<TSchema extends ZeroSchema, TMutators extends Mutators.AnyMutators> = {
+  [A in keyof TMutators]: TMutators[A] extends Mutators.AnyMutator
+    ? UnwrapMutator<TSchema, TMutators[A]>
+    : {
+        [B in keyof TMutators[A]]: TMutators[A][B] extends Mutators.AnyMutator
+          ? UnwrapMutator<TSchema, TMutators[A][B]>
+          : never;
+      };
 } & {};
 
-export class ZeroClientTransactionError extends Data.TaggedError("ZeroClientTransactionError")<{
-  cause: Cause.Cause<unknown>;
-}> {}
-
-export class ZeroClientArgsParseError extends Data.TaggedError("ZeroClientArgsParseError")<{
-  cause: Cause.Cause<ParseResult.ParseError>;
+export class ClientArgsParseError extends Data.TaggedError("ClientArgsParseError")<{
+  readonly cause: Cause.Cause<ParseResult.ParseError>;
 }> {}

package/src/internal/server.ts

@@ -0,0 +1,90 @@
+import type { TransactionProviderInput } from "@rocicorp/zero/server";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
+import * as SynchronizedRef from "effect/SynchronizedRef";
+import { prefixId } from "./utils.js";
+
+export class ServerTransactionInput extends Context.Tag(prefixId("ServerTransactionInput"))<
+  ServerTransactionInput,
+  TransactionProviderInput
+>() {}
+
+export class ServerSynchronizationContext extends Effect.Service<ServerSynchronizationContext>()(
+  prefixId("ServerSynchronizationContext"),
+  {
+    effect: Effect.gen(function* () {
+      return {
+        wasTransactionExecuted: yield* SynchronizedRef.make(false),
+      };
+    }),
+  },
+) {
+  // Ensures that only one transaction is executed at a time and checks that another transaction wasn't already executed.
+  static guard = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+    Effect.flatMap(this, (ctx) =>
+      SynchronizedRef.modifyEffect(
+        ctx.wasTransactionExecuted,
+        Effect.fn(function* (wasTransactionExecuted) {
+          if (wasTransactionExecuted) {
+            return yield* new MultipleTransactionsError();
+          }
+          const result = yield* effect;
+          return [result, true];
+        }),
+      ),
+    );
+
+  static finalize = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+    Effect.gen(this, function* () {
+      const wasTransactionExecuted = yield* this.pipe(Effect.flatMap((ctx) => ctx.wasTransactionExecuted));
+
+      return yield* effect.pipe(
+        // Case #2 "One transaction then fail"
+        // If the transaction was executed successfully, swallow the error and just log it, otherwise re-throw it
+        Effect.catchAllCause((e) => {
+          if (wasTransactionExecuted) {
+            return Effect.logError("Error occurred after transaction execution completed", e);
+          }
+          return Effect.failCause(e);
+        }),
+        // Case #4 "Zero transactions then succeed"
+        // Check that the transaction was executed during the mutation
+        Effect.tap(!wasTransactionExecuted ? new NoTransactionError() : Effect.void),
+      );
+    });
+}
+
+export class NoTransactionError extends Data.TaggedError("NoTransactionError") {}
+export class MultipleTransactionsError extends Data.TaggedError("MultipleTransactionsError") {}
+
+const OutOfOrderMutationErrorTypeId = Symbol.for(prefixId("OutOfOrderMutationError"));
+export class OutOfOrderMutationError extends Data.TaggedError("OutOfOrderMutationError")<{
+  readonly clientID: string;
+  readonly receivedMutationID: number;
+  readonly lastMutationID: number | bigint;
+}> {
+  readonly [OutOfOrderMutationErrorTypeId] = OutOfOrderMutationErrorTypeId;
+  override get message() {
+    return `Client ${this.clientID} sent mutation ID ${this.receivedMutationID} but expected ${this.lastMutationID}`;
+  }
+  static is(e: unknown): e is OutOfOrderMutationError {
+    return Predicate.hasProperty(e, OutOfOrderMutationErrorTypeId);
+  }
+}
+
+const MutationAlreadyProcessedErrorTypeId = Symbol.for(prefixId("MutationAlreadyProcessedError"));
+export class MutationAlreadyProcessedError extends Data.TaggedError("MutationAlreadyProcessedError")<{
+  readonly clientID: string;
+  readonly received: number;
+  readonly actual: number | bigint;
+}> {
+  readonly [MutationAlreadyProcessedErrorTypeId] = MutationAlreadyProcessedErrorTypeId;
+  override get message() {
+    return `Ignoring mutation from ${this.clientID} with ID ${this.received} as it was already processed. Expected: ${this.actual}`;
+  }
+  static is(e: unknown): e is MutationAlreadyProcessedError {
+    return Predicate.hasProperty(e, MutationAlreadyProcessedErrorTypeId);
+  }
+}

package/src/mutators.ts

@@ -4,45 +4,45 @@ import * as Option from "effect/Option";
 import * as Predicate from "effect/Predicate";
 import * as Rec from "effect/Record";
 import * as Schema from "effect/Schema";
-import { prefixId } from "./utils.js";
+import { prefixId } from "./internal/utils.js";
 
 // biome-ignore lint/suspicious/noExplicitAny: upper bound to allow everything
-export type AnyMutatorDef<R = any, TArgs extends any[] = any[]> = (...args: TArgs) => Effect.Effect<any, any, R>;
+export type AnyMutatorFn<R = any, TArgs extends any[] = any[]> = (...args: TArgs) => Effect.Effect<any, any, R>;
 
 // biome-ignore lint/suspicious/noExplicitAny: upper bound to allow everything
-export type AnyMutatorDefs<R = any> = {
-  [K: string]: AnyMutatorDef<R> | { [K: string]: AnyMutatorDef<R> };
+export type AnyMutatorFns<R = any> = {
+  [K: string]: AnyMutatorFn<R> | { [K: string]: AnyMutatorFn<R> };
 };
 
 // biome-ignore lint/suspicious/noExplicitAny: upper bound to allow everything
-export type AnyMutatorSchemaArgs = Schema.Schema<any, any, never>;
-export type AnyMutatorSchema = Record<string, AnyMutatorSchemaArgs | Record<string, AnyMutatorSchemaArgs>>;
+export type AnyMutatorSchema = Schema.Schema<any, any, never>;
+export type AnyMutatorSchemas = Record<string, AnyMutatorSchema | Record<string, AnyMutatorSchema>>;
 
-export type MutatorDefs<TSchema extends AnyMutatorSchema> = {
-  [K in keyof TSchema]: TSchema[K] extends AnyMutatorSchemaArgs
-    ? AnyMutatorDef<unknown, [Schema.Schema.Type<TSchema[K]>]>
-    : TSchema[K] extends infer TSchema extends Record<string, AnyMutatorSchemaArgs>
-      ? { [K in keyof TSchema]: AnyMutatorDef<unknown, [Schema.Schema.Type<TSchema[K]>]> }
+export type MutatorFns<TSchema extends AnyMutatorSchemas> = {
+  [K in keyof TSchema]: TSchema[K] extends AnyMutatorSchema
+    ? AnyMutatorFn<unknown, [Schema.Schema.Type<TSchema[K]>]>
+    : TSchema[K] extends infer TSchema extends Record<string, AnyMutatorSchema>
+      ? { [K in keyof TSchema]: AnyMutatorFn<unknown, [Schema.Schema.Type<TSchema[K]>]> }
       : never;
 };
 
-export const MutatorArgsSchemaSym = Symbol.for(prefixId("MutatorArgsSchema"));
+export const MutatorSchemaSymbol = Symbol.for(prefixId("MutatorSchema"));
 
 export type Mutator<
-  TFunc extends AnyMutatorDef = AnyMutatorDef,
-  TSchema extends AnyMutatorSchemaArgs = AnyMutatorSchemaArgs,
+  TFunc extends AnyMutatorFn = AnyMutatorFn,
+  TSchema extends AnyMutatorSchema = AnyMutatorSchema,
 > = TFunc & {
-  [MutatorArgsSchemaSym]: TSchema;
+  [MutatorSchemaSymbol]: TSchema;
 };
 
-export type Mutators<TSchema extends AnyMutatorSchema, TDefs extends AnyMutatorDefs> = {
-  [K in keyof TDefs & keyof TSchema]: TDefs[K] extends AnyMutatorDef
-    ? TSchema[K] extends AnyMutatorSchemaArgs
-      ? Mutator<TDefs[K], TSchema[K]>
+export type Mutators<TSchema extends AnyMutatorSchemas, TFns extends AnyMutatorFns> = {
+  [K in keyof TFns & keyof TSchema]: TFns[K] extends AnyMutatorFn
+    ? TSchema[K] extends AnyMutatorSchema
+      ? Mutator<TFns[K], TSchema[K]>
       : never
-    : TSchema[K] extends infer TSchema extends Record<string, AnyMutatorSchemaArgs>
-      ? TDefs[K] extends infer TDefs extends Record<string, AnyMutatorDef>
-        ? { [K in keyof TDefs & keyof TSchema]: Mutator<TDefs[K], TSchema[K]> }
+    : TSchema[K] extends infer TSchema extends Record<string, AnyMutatorSchema>
+      ? TFns[K] extends infer TFns extends Record<string, AnyMutatorFn>
+        ? { [K in keyof TFns & keyof TSchema]: Mutator<TFns[K], TSchema[K]> }
         : never
       : never;
 } & {};
@@ -53,30 +53,28 @@ export type AnyMutator<R = any, E = any> = Mutator<(...args: any[]) => Effect.Ef
 // biome-ignore lint/suspicious/noExplicitAny: upper bound to allow everything
 export type AnyMutators<R = any> = Record<string, AnyMutator<R> | Record<string, AnyMutator<R>>>;
 
-export type ExtractMutatorsRequirements<T extends AnyMutators> = T extends AnyMutators<infer R> ? R : never;
+export type ExtractMutatorsRequirements<TMutators extends AnyMutators> = TMutators extends AnyMutators<infer R>
+  ? R
+  : never;
 
-export class MutatorSchema<T extends AnyMutatorSchema> {
-  private constructor(public schema: T) {}
+export const schema = <TSchema extends AnyMutatorSchemas>(schema: TSchema) => schema;
 
-  static make<T extends AnyMutatorSchema>(schema: T) {
-    return new MutatorSchema(schema);
+export function make<TSchema extends AnyMutatorSchemas, TFns extends MutatorFns<TSchema>>(
+  schema: TSchema,
+  mutators: TFns,
+): Mutators<TSchema, TFns>;
+export function make(schema: AnyMutatorSchemas, mutators: AnyMutatorFns): AnyMutators {
+  function makeMutator(schema: AnyMutatorSchema, fn: AnyMutatorFn) {
+    return Object.assign(fn, { [MutatorSchemaSymbol]: schema });
   }
 
-  // Associates mutator with its args schema
-  private makeMutator(argsSchema: AnyMutatorSchemaArgs, fn: AnyMutatorDef): AnyMutator {
-    return Object.assign(fn, { [MutatorArgsSchemaSym]: argsSchema });
-  }
-
-  makeMutators<TDefs extends MutatorDefs<T>>(mutators: TDefs): Mutators<T, TDefs>;
-  makeMutators(mutators: AnyMutatorDefs): AnyMutators {
-    return Rec.map(mutators, (v, name) => {
-      return Match.value([v, this.schema[name]]).pipe(
-        Match.when([Predicate.isFunction, Schema.isSchema], ([mutator, schema]) => this.makeMutator(schema, mutator)),
-        Match.when([Predicate.isRecord, Predicate.isRecord], ([mutator, schema]) =>
-          Rec.map(mutator, (mutator, name) => this.makeMutator(Option.getOrThrow(Rec.get(schema, name)), mutator)),
-        ),
-        Match.orElseAbsurd,
-      );
-    });
-  }
+  return Rec.map(mutators, (v, name) => {
+    return Match.value([v, schema[name]]).pipe(
+      Match.when([Predicate.isFunction, Schema.isSchema], ([mutator, schema]) => makeMutator(schema, mutator)),
+      Match.when([Predicate.isRecord, Predicate.isRecord], ([mutator, schema]) =>
+        Rec.map(mutator, (mutator, name) => makeMutator(Option.getOrThrow(Rec.get(schema, name)), mutator)),
+      ),
+      Match.orElseAbsurd,
+    );
+  });
 }

package/src/query.ts

@@ -0,0 +1,117 @@
+import type { HumanReadable, ReadonlyJSONValue, Zero, Query as ZeroQuery, Schema as ZeroSchema } from "@rocicorp/zero";
+import type { QueryResult as ZeroQueryResult } from "@rocicorp/zero/react";
+import * as Effect from "effect/Effect";
+import * as Equal from "effect/Equal";
+import * as Hash from "effect/Hash";
+import * as Match from "effect/Match";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+import * as Subscribable from "effect/Subscribable";
+import * as SubscriptionRef from "effect/SubscriptionRef";
+import { prefixId } from "./internal/utils.js";
+import { deepClone, getDefaultSnapshot, getSnapshot } from "./snapshot.js";
+
+export type Query<S extends ZeroSchema, T extends keyof S["tables"] & string, R> = ZeroQuery<S, T, R> & Equal.Equal;
+
+type QueryArgs<
+  A extends ReadonlyJSONValue[],
+  B extends unknown[],
+> = // biome-ignore lint/suspicious/noExplicitAny: handles "any query" case
+| { _tag: "Encoded"; args: any extends A ? any : readonly [...A] }
+// biome-ignore lint/suspicious/noExplicitAny: handles "any query" case
+| { _tag: "Decoded"; args: any extends B ? any : readonly [...B] };
+
+export const RunQuerySymbol = Symbol.for(prefixId("RunQuery"));
+export const QueryNameSymbol = Symbol.for(prefixId("QueryName"));
+
+export const make = <
+  N extends string,
+  // The encoded format that is sent over the wire, must conform to JSON
+  A extends ReadonlyJSONValue[],
+  // The decoded format, can be anything
+  B extends unknown[],
+  S extends ZeroSchema,
+  T extends keyof S["tables"] & string,
+  R,
+  E,
+  R1,
+  R2,
+>(options: {
+  name: N;
+  payload: Schema.Schema<readonly [...B], readonly [...A], R1>;
+  query: (...args: NoInfer<B>) => Effect.Effect<ZeroQuery<S, T, R>, E, R2>;
+}) => {
+  const runQuery = Effect.fn(function* (args: QueryArgs<A, B>) {
+    const { encoded, decoded } = yield* Match.valueTags(args, {
+      Encoded: ({ args: encoded }) =>
+        Effect.map(Schema.decode(options.payload)(encoded), (decoded) => ({ encoded, decoded })),
+      Decoded: ({ args: decoded }) =>
+        Effect.map(Schema.encode(options.payload)(decoded), (encoded) => ({ encoded, decoded })),
+    });
+
+    return yield* options.query(...decoded).pipe(
+      Effect.map((rawQuery) => {
+        const query = rawQuery.nameAndArgs(
+          options.name,
+          // We pass the encoded `args` to the `nameAndArgs` method, as that is the wire format which
+          // is sent to the server.
+          encoded,
+        ) as Query<S, T, R>;
+        query[Hash.symbol] = function () {
+          return Hash.hash(this.hash());
+        };
+        query[Equal.symbol] = function (that) {
+          if (Hash.isHash(that)) {
+            return Equal.equals(this[Hash.symbol](), that[Hash.symbol]());
+          }
+          return false;
+        };
+        return query;
+      }),
+    );
+  });
+
+  return Object.assign((...args: B) => runQuery({ _tag: "Decoded", args }), {
+    [QueryNameSymbol]: options.name,
+    [RunQuerySymbol]: runQuery,
+  });
+};
+
+// biome-ignore lint/suspicious/noExplicitAny: accept any query
+export type MakeQueryResult<E = any, R1 = any, R2 = any> = ReturnType<
+  // biome-ignore lint/suspicious/noExplicitAny: accept any query
+  typeof make<string, any, any, ZeroSchema, string, Record<string, any> | undefined, E, R1, R2>
+>;
+
+export const subscribe = Effect.fn(function* <S extends ZeroSchema, T extends keyof S["tables"] & string, R>(
+  zero: Zero<S>,
+  query: ZeroQuery<S, T, R> | Query<S, T, R>,
+) {
+  const view = yield* Effect.acquireRelease(
+    Effect.sync(() => zero.materialize(query)),
+    (view) => Effect.sync(() => view.destroy()),
+  );
+
+  const subscriptionRef = yield* SubscriptionRef.make<ZeroQueryResult<R>>(getDefaultSnapshot(query.format.singular));
+
+  yield* Stream.asyncEffect<Parameters<Parameters<(typeof view)["addListener"]>[0]>>((emit) =>
+    Effect.sync(() => view.addListener((...args) => emit.single(args))),
+  ).pipe(
+    Stream.mapEffect(([data, resultType]) =>
+      Effect.sync(() => {
+        // logic here borrowed from: https://github.com/rocicorp/mono/blob/288b00ec94f5a9ae6e988513423af25c281dbb2a/packages/zero-react/src/use-query.tsx#L295
+        const cloned = (data === undefined ? data : deepClone(data as ReadonlyJSONValue)) as HumanReadable<R>;
+        return getSnapshot<R>(query.format.singular, cloned, resultType);
+      }),
+    ),
+    Stream.runForEach((snapshot) => SubscriptionRef.set(subscriptionRef, snapshot)),
+    Effect.forkScoped,
+  );
+
+  return subscriptionRef.pipe(
+    Subscribable.map(([data, { type: status }]) => ({
+      data,
+      status,
+    })),
+  );
+});