@gaganref/confect-server 10.3.1-fork.42 → 10.3.1-fork.43

package/src/Scheduler.ts

@@ -1,3 +1,4 @@
+import * as ReservedArgument from "./internal/reservedArgument.js";
 import type * as IdScope from "@confect/core/IdScope";
 import { Ref } from "@confect/core";
 import type { GenericId } from "@confect/core/GenericId";
@@ -12,38 +13,34 @@ import * as Layer from "effect/Layer";
 const make = (scheduler: ConvexScheduler) => ({
   cancel: (id: ConvexGenericId<"_scheduled_functions">) =>
     Effect.promise(() => scheduler.cancel(id)),
-  runAfter: <Ref_ extends Ref.AnyMutation | Ref.AnyAction>(
-    delay: Duration.Duration,
-    ref: Ref_,
-    ...args: Ref.OptionalArgs<Ref_>
-  ) => {
+  runAfter: Effect.fn("Scheduler.runAfter")(function* <
+    Ref_ extends Ref.AnyMutation | Ref.AnyAction,
+  >(delay: Duration.Duration, ref: Ref_, ...args: Ref.OptionalArgs<Ref_>) {
     const delayMs = Duration.toMillis(delay);
     const functionReference = Ref.getFunctionReference(ref);
-    const encodedArgs = Ref.encodeArgsSync(
+    const encodedArgs = yield* ReservedArgument.encodeArgs(
       ref,
       (args[0] ?? {}) as Ref.Args<Ref_>,
     );
 
-    return Effect.promise(() =>
+    return yield* Effect.promise(() =>
       scheduler.runAfter(delayMs, functionReference, encodedArgs),
     );
-  },
-  runAt: <Ref_ extends Ref.AnyMutation | Ref.AnyAction>(
-    dateTime: DateTime.DateTime,
-    ref: Ref_,
-    ...args: Ref.OptionalArgs<Ref_>
-  ) => {
+  }),
+  runAt: Effect.fn("Scheduler.runAt")(function* <
+    Ref_ extends Ref.AnyMutation | Ref.AnyAction,
+  >(dateTime: DateTime.DateTime, ref: Ref_, ...args: Ref.OptionalArgs<Ref_>) {
     const timestamp = DateTime.toEpochMillis(dateTime);
     const functionReference = Ref.getFunctionReference(ref);
-    const encodedArgs = Ref.encodeArgsSync(
+    const encodedArgs = yield* ReservedArgument.encodeArgs(
       ref,
       (args[0] ?? {}) as Ref.Args<Ref_>,
     );
 
-    return Effect.promise(() =>
+    return yield* Effect.promise(() =>
       scheduler.runAt(timestamp, functionReference, encodedArgs),
     );
-  },
+  }),
 });
 
 export const Scheduler = Context.Service<ReturnType<typeof make>>(

package/src/internal/reservedArgument.ts

@@ -0,0 +1,56 @@
+import { convexToJson, type Value } from "convex/values";
+import * as Ref from "@confect/core/Ref";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Tracer from "effect/Tracer";
+
+export const Forward = Context.Reference<
+  ((span: Tracer.Span) => unknown) | undefined
+>("@confect/server/RegisteredFunction/Forward", {
+  defaultValue: () => undefined,
+});
+
+const inject = (
+  ref: Ref.Any,
+  encoded: unknown,
+  context: Context.Context<never>,
+): unknown => {
+  if (ref.reservedArgument === undefined || ref.functionType === "query")
+    return encoded;
+  const forward = Context.get(context, Forward);
+  const span = Context.getOrUndefined(context, Tracer.ParentSpan);
+  if (forward === undefined || span?._tag !== "Span") return encoded;
+  try {
+    const value = forward(span);
+    if (value === undefined) return encoded;
+    convexToJson(value as Value);
+    return {
+      ...(encoded as Record<string, unknown>),
+      [ref.reservedArgument]: value,
+    };
+  } catch {
+    return encoded;
+  }
+};
+
+export const runWithCodec = <Ref_ extends Ref.Any>(
+  ref: Ref_,
+  args: Ref.Args<Ref_>,
+  call: (
+    native: Ref.FunctionReference<Ref_>,
+    encoded: unknown,
+  ) => PromiseLike<unknown>,
+) =>
+  Effect.withFiber((fiber) =>
+    Ref.runWithCodec(ref, args, (native, encoded) =>
+      call(native, inject(ref, encoded, fiber.context)),
+    ),
+  );
+
+export const encodeArgs = <Ref_ extends Ref.Any>(
+  ref: Ref_,
+  args: Ref.Args<Ref_>,
+) =>
+  Effect.withFiberSucceed((fiber) =>
+    inject(ref, Ref.encodeArgsSync(ref, args), fiber.context),
+  );