@gaganref/confect-server 10.3.1-fork.6 → 10.3.1-fork.60

package/src/Scheduler.ts

@@ -1,5 +1,7 @@
+import * as ReservedArgument from "./internal/reservedArgument.js";
 import type * as IdScope from "@confect/core/IdScope";
-import { Ref } from "@confect/core";
+import type { Ref } from "@confect/core";
+import { getFunctionReference } from "@confect/core/RefInternal";
 import type { GenericId } from "@confect/core/GenericId";
 import type { Scheduler as ConvexScheduler } from "convex/server";
 import type { GenericId as ConvexGenericId } from "convex/values";
@@ -12,38 +14,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 functionReference = getFunctionReference(ref);
+    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 functionReference = getFunctionReference(ref);
+    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/index.ts

@@ -1,3 +1,4 @@
+export * as ActionCall from "./ActionCall.js";
 export * as AiGatewayDecisionClient from "./AiGatewayDecisionClient.js";
 export * as AiGatewayDecisionModel from "./AiGatewayDecisionModel.js";
 export * as AiGatewayLanguageClient from "./AiGatewayLanguageClient.js";
@@ -28,6 +29,7 @@ export * as MiddlewareRegistryItem from "./MiddlewareRegistryItem.js";
 export * as MutationCtx from "./MutationCtx.js";
 export * as MutationRunner from "./MutationRunner.js";
 export * as MutationTransactionContext from "./MutationTransactionContext.js";
+export * as OfficialComponent from "./OfficialComponent.js";
 export * as OrderedQuery from "./OrderedQuery.js";
 export * as QueryCtx from "./QueryCtx.js";
 export * as QueryInitializer from "./QueryInitializer.js";

package/src/internal/DocumentPatch.ts

@@ -0,0 +1,87 @@
+import type { ReadonlyValue } from "@confect/core/SchemaToValidator";
+import { pipe } from "effect/Function";
+import * as Effect from "effect/Effect";
+import * as Record from "effect/Record";
+import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import type * as Table from "../Table.js";
+
+export type EncodedPatch = Record.ReadonlyRecord<
+  string,
+  ReadonlyValue | undefined
+>;
+
+export type PatchEncoder = (
+  patch: Record.ReadonlyRecord<string, unknown>,
+) => Effect.Effect<EncodedPatch, Schema.SchemaError>;
+
+const patchEncoders = new WeakMap<Table.AnyWithProps, PatchEncoder | null>();
+
+/**
+ * Returns the encoder for patches to the table's documents, or `undefined` when
+ * the table's codec does not encode each field independently. The encoder maps
+ * every patched field of the table to its encoded value, or to `undefined` when
+ * the patch unsets the field or the field's codec encodes the value as an
+ * absent key. Keys outside the table's fields are left out.
+ */
+export const encoder = (
+  table: Table.AnyWithProps,
+): PatchEncoder | undefined => {
+  let cached = patchEncoders.get(table);
+  if (cached === undefined) {
+    cached = makePatchEncoder(table);
+    patchEncoders.set(table, cached);
+  }
+  return cached ?? undefined;
+};
+
+// A struct with no encoding of its own encodes each field through that field's
+// codec alone, so a patch encodes field by field. A union or a transformation
+// over the whole struct can make one field's encoding depend on another field.
+// A struct-level check must see the decoded fields before they are encoded,
+// and keys under an index signature have no field codec of their own.
+const makePatchEncoder = (table: Table.AnyWithProps): PatchEncoder | null => {
+  const ast = table.Fields.ast;
+  if (
+    !SchemaAST.isObjects(ast) ||
+    ast.encoding !== undefined ||
+    ast.checks !== undefined ||
+    ast.indexSignatures.length > 0
+  ) {
+    return null;
+  }
+  // A field's codec runs only when the patch gives the field a value, since a
+  // codec can handle a missing key. Each comes from the table, whose codecs
+  // need no services.
+  const fieldEncoders: Record.ReadonlyRecord<
+    string,
+    (
+      value: unknown,
+    ) => Effect.Effect<ReadonlyValue | undefined, Schema.SchemaError>
+  > = Object.fromEntries(
+    ast.propertySignatures.map(({ name, type }) => {
+      const key = String(name);
+      const encode = Schema.encodeUnknownEffect(
+        Schema.Struct({
+          [key]: Schema.optionalKey(
+            Schema.make<Schema.Codec<unknown, ReadonlyValue>>(type),
+          ),
+        }),
+      );
+      return [
+        key,
+        (value: unknown) =>
+          Effect.map(encode({ [key]: value }), (encoded) => encoded[key]),
+      ];
+    }),
+  );
+  return (patch) =>
+    pipe(
+      fieldEncoders,
+      Record.filter((_, name) => Object.hasOwn(patch, name)),
+      Record.map((encode, name) =>
+        patch[name] === undefined ? Effect.undefined : encode(patch[name]),
+      ),
+      Effect.all,
+    );
+};

package/src/internal/observability.ts

@@ -0,0 +1,27 @@
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Layer from "effect/Layer";
+import * as Scope from "effect/Scope";
+import * as ConvexConfigProvider from "../ConvexConfigProvider.js";
+
+const memoMap = Layer.makeMemoMapUnsafe();
+export const scope = Scope.makeUnsafe();
+const layers = new WeakMap<Layer.Layer<never>, Layer.Layer<never>>();
+
+export const memoized = (layer: Layer.Layer<never>): Layer.Layer<never> => {
+  const cached = layers.get(layer);
+  if (cached !== undefined) return cached;
+  const built = Layer.buildWithMemoMap(layer, memoMap, scope).pipe(
+    Effect.provide(ConvexConfigProvider.layer),
+    // A failed first build is retried on the next invocation instead of failing every later one.
+    Effect.cachedWithTTL((exit) =>
+      Exit.isSuccess(exit) ? Duration.infinity : Duration.zero,
+    ),
+    Effect.runSync,
+    Effect.uninterruptible,
+    Layer.effectContext,
+  );
+  layers.set(layer, built);
+  return built;
+};

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),
+  );