@gaganref/confect-server 10.3.1-fork.9 → 10.3.1-fork.90

package/src/RegistryItems.ts

@@ -38,3 +38,34 @@ export const middlewareKeys = (items: RegistryItems): ReadonlyArray<string> =>
     Array.filter(MiddlewareRegistryItem.isMiddlewareRegistryItem),
     Array.map((item) => item.middlewareSpec.key),
   );
+
+export interface MissingMiddleware {
+  readonly functionName: string;
+  readonly middlewareKey: string;
+}
+
+export const missingRequired = (
+  items: RegistryItems,
+  required: ReadonlyArray<{ readonly key: string }>,
+  groupPath = "",
+): ReadonlyArray<MissingMiddleware> =>
+  Object.entries(items)
+    .sort(([left], [right]) => left.localeCompare(right))
+    .flatMap(([functionName, value]) =>
+      FunctionRegistryItem.isFunctionRegistryItem(value)
+        ? required.flatMap(({ key }) =>
+            value._tag === "Confect" &&
+            value.middlewareAttachments.some(({ spec }) => spec.key === key)
+              ? []
+              : [
+                  {
+                    functionName:
+                      groupPath === ""
+                        ? functionName
+                        : `${groupPath}.${functionName}`,
+                    middlewareKey: key,
+                  },
+                ],
+          )
+        : [],
+    );

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/TableInfo.ts

@@ -18,39 +18,35 @@ import type * as Table from "./Table.js";
 export declare const TypeId: "~@confect/server/TableInfo";
 export type TypeId = typeof TypeId;
 
+// Read through Table's extractors, not `infer`: an intersection with a Table,
+// or an interface extending one, matches `Table<infer ...>` only structurally,
+// which widens the name and scope. `Indexes` stays inferred: a generic table's
+// index names resolve only through the inferred type's constraint.
 export type TableInfo<Table_ extends Table.AnyWithProps> =
-  Table_ extends Table.Table<
-    infer TableName,
-    infer TableSchema_,
-    infer TableValidator,
-    infer Indexes,
-    infer SearchIndexes,
-    infer VectorIndexes,
-    infer Scope
-  >
+  Table_ extends Table.Table<any, any, any, infer Indexes, any, any, any, any>
     ? {
         readonly [TypeId]: TypeId;
         readonly document: WithSystemFields<
-          TableName,
-          Schema.Schema.Type<TableSchema_>,
-          Scope
+          Table.Name<Table_>,
+          Schema.Schema.Type<Table.TableSchema<Table_>>,
+          Table.Scope<Table_>
         >;
         readonly encodedDocument: WithSystemFields<
-          TableName,
-          Schema.Codec.Encoded<TableSchema_>,
-          Scope
+          Table.Name<Table_>,
+          Schema.Codec.Encoded<Table.TableSchema<Table_>>,
+          Table.Scope<Table_>
         >;
         readonly convexDocument: ExtractConvexDocument<
-          TableName,
-          TableValidator,
-          Scope
+          Table.Name<Table_>,
+          Table.TableValidator<Table_>,
+          Table.Scope<Table_>
         >;
         readonly fieldPaths:
-          | keyof IdField<TableName>
-          | ExtractFieldPaths<TableValidator>;
+          | keyof IdField<Table.Name<Table_>>
+          | ExtractFieldPaths<Table.TableValidator<Table_>>;
         readonly indexes: Types.Simplify<Indexes & SystemIndexes>;
-        readonly searchIndexes: SearchIndexes;
-        readonly vectorIndexes: VectorIndexes;
+        readonly searchIndexes: Table.SearchIndexes<Table_>;
+        readonly vectorIndexes: Table.VectorIndexes<Table_>;
       }
     : never;
 

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";
@@ -25,9 +26,11 @@ export * as Handler from "./Handler.js";
 export * as HttpRouter from "./HttpRouter.js";
 export * as MiddlewareImpl from "./MiddlewareImpl.js";
 export * as MiddlewareRegistryItem from "./MiddlewareRegistryItem.js";
+export * as MountInit from "./MountInit.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/httpBody.ts

@@ -0,0 +1,72 @@
+import type * as ByteSize from "effect/ByteSize";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+import * as HttpServerRequest from "effect/http/HttpServerRequest";
+import * as HttpServerResponse from "effect/http/HttpServerResponse";
+
+class BodyTooLarge extends Schema.TaggedError<BodyTooLarge>()(
+  "BodyTooLarge",
+  {},
+) {}
+
+/**
+ * Count the body before downstream middleware or decoding. Configure maxBytes
+ * from the endpoint's policy. Non-identity Content-Encoding receives 415. Read
+ * arrayBuffer in the wrapped effect to verify the same bytes the decoder uses.
+ */
+export const withBodyLimit = <A, E, R>(
+  effect: Effect.Effect<A, E, R>,
+  options: { readonly maxBytes: ByteSize.ByteSize },
+) =>
+  Effect.gen(function* () {
+    const request = yield* HttpServerRequest.HttpServerRequest;
+    const encoding = request.headers["content-encoding"]?.trim().toLowerCase();
+    if (encoding !== undefined && encoding !== "identity")
+      return HttpServerResponse.empty({ status: 415 });
+    let size = 0;
+    const chunks: Array<Uint8Array> = [];
+    const empty =
+      request.source instanceof Request && request.source.body === null;
+    const read = empty
+      ? Effect.void
+      : Stream.runForEach(request.stream, (chunk) => {
+          size += chunk.byteLength;
+          if (BigInt(size) > options.maxBytes)
+            return Effect.fail(new BodyTooLarge());
+          chunks.push(chunk);
+          return Effect.void;
+        });
+    const limited = yield* read.pipe(
+      Effect.as(false),
+      Effect.catchTag("BodyTooLarge", () => Effect.succeed(true)),
+      Effect.orDie,
+    );
+    if (limited) return HttpServerResponse.empty({ status: 413 });
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    const source = new Request(request.originalUrl, {
+      method: request.method,
+      headers: request.headers,
+      ...(request.method === "GET" || request.method === "HEAD"
+        ? {}
+        : { body: bytes }),
+    });
+    // WORKAROUND: Effect 4.0.4 caches text and bytes independently. Remove these
+    // overrides when the minimum Effect version shares text and byte reads.
+    source.arrayBuffer = () => Promise.resolve(bytes.buffer);
+    source.text = () => Promise.resolve(new TextDecoder().decode(bytes));
+    const buffered = HttpServerRequest.fromWeb(source).modify({
+      url: request.url,
+      remoteAddress: request.remoteAddress,
+    });
+    return yield* Effect.provideService(
+      effect,
+      HttpServerRequest.HttpServerRequest,
+      buffered,
+    );
+  });

package/src/internal/httpOptions.ts

@@ -0,0 +1,154 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Layer from "effect/Layer";
+import * as HttpRouter from "effect/http/HttpRouter";
+import * as HttpServerError from "effect/http/HttpServerError";
+import * as HttpServerRequest from "effect/http/HttpServerRequest";
+
+/* oxlint-disable effecttsgo/any-unknown-in-error-context -- Preserve the router's erased request errors at the routing boundary. */
+
+type Route = Parameters<HttpRouter.HttpRouter["addAll"]>[0][number];
+
+const notFound = Effect.flatMap(
+  HttpServerRequest.HttpServerRequest,
+  (request) =>
+    Effect.fail(
+      new HttpServerError.HttpServerError({
+        reason: new HttpServerError.RouteNotFound({ request }),
+      }),
+    ),
+);
+
+// Effect's router adds `/a/:b` and `/a` for `/a/:b?` in one call, so an earlier
+// `/a/:id` rejects both. Split the same way, each form claims `first` alone.
+const optional = /(\/:[^/()]*?)\?(\/?)/;
+const forms = (path: Route["path"]) =>
+  (optional.test(path)
+    ? [path.replace(optional, "$1$2"), path.replace(optional, "$2") || "/"]
+    : [path]) as ReadonlyArray<Route["path"]>;
+
+const missingRouteContext = `Service not found: ${HttpRouter.RouteContext.key}`;
+
+// WORKAROUND: Effect 4.0.4 compiles endpoint middleware, decoding and the
+// handler into one route handler. Its endpoint body reads RouteContext before
+// decoding or calling the handler, so without RouteContext a preflight that
+// middleware passes on stops there. Remove when Effect can run an endpoint's
+// middleware around another handler.
+const preflight = (handler: Route["handler"]) =>
+  handler.pipe(
+    Effect.updateContext(Context.omit(HttpRouter.RouteContext)),
+    Effect.catchDefect((defect) =>
+      defect instanceof Error && defect.message === missingRouteContext
+        ? notFound
+        : Effect.die(defect),
+    ),
+  );
+
+export const withOptions = <A, E, R>(
+  routes: Layer.Layer<A, E, R>,
+  endpoints: ReadonlySet<string>,
+) =>
+  Layer.unwrap(
+    Effect.gen(function* () {
+      const router = yield* HttpRouter.HttpRouter;
+      const registered: Array<{
+        readonly route: Route;
+        readonly prefix: string;
+        readonly context: Context.Context<never>;
+      }> = [];
+      const wrap = (
+        target: HttpRouter.HttpRouter,
+        prefix: string,
+      ): HttpRouter.HttpRouter => {
+        const addAll: HttpRouter.HttpRouter["addAll"] = (entries) =>
+          Effect.contextWith((context: Context.Context<never>) => {
+            for (const route of entries)
+              registered.push({ route, prefix, context });
+            return target.addAll(entries);
+          });
+        return HttpRouter.HttpRouter.of({
+          ...target,
+          addAll,
+          add: (method, path, handler, options) =>
+            addAll([HttpRouter.route(method, path, handler, options)]),
+          prefixed: (next) =>
+            wrap(target.prefixed(next), `${prefix}${next.replace(/\/$/, "")}`),
+        });
+      };
+      const register = Effect.gen(function* () {
+        // Effect's routers decide which paths match: one per declared method,
+        // and `first`, which refuses a path equivalent to an earlier one.
+        const byMethod = new Map<string, HttpRouter.HttpRouter>();
+        const first = yield* HttpRouter.make;
+        const explicit = yield* HttpRouter.make;
+        for (const { route, prefix, context } of registered) {
+          const at = (target: HttpRouter.HttpRouter) =>
+            prefix === "" ? target : target.prefixed(prefix);
+          if (route.method === "OPTIONS" || route.method === "*") {
+            yield* at(explicit).addAll([{ ...route, handler: notFound }]);
+            continue;
+          }
+          const copy: Route = {
+            ...route,
+            method: "OPTIONS",
+            handler: endpoints.has(`${route.method} ${route.path}`)
+              ? preflight(route.handler)
+              : notFound,
+          };
+          const candidate =
+            byMethod.get(route.method) ?? (yield* HttpRouter.make);
+          byMethod.set(route.method, candidate);
+          // Route registration erases request requirements, as in Effect's router.
+          yield* Effect.provideContext(at(candidate).addAll([copy]), context);
+          // Split the prefixed path: an optional parameter may sit in the prefix.
+          const placed =
+            prefix === "" ? copy : HttpRouter.prefixRoute(copy, prefix);
+          for (const path of forms(placed.path)) {
+            const form = first.addAll([{ ...placed, path }]);
+            yield* Effect.exit(Effect.provideContext(form, context));
+          }
+        }
+        // Effect's router answers HEAD from GET where no HEAD route matches. The
+        // root wildcard matches last, unless a HEAD route already claims it.
+        const get = byMethod.get("GET");
+        if (get !== undefined) {
+          const head = byMethod.get("HEAD") ?? (yield* HttpRouter.make);
+          byMethod.set("HEAD", head);
+          yield* Effect.exit(head.add("OPTIONS", "*", get.asHttpEffect()));
+        }
+        // An explicit OPTIONS route on the root wildcard answers every path.
+        const claimed = yield* Effect.exit(
+          explicit.add("OPTIONS", "*", notFound),
+        );
+        if (Exit.isFailure(claimed)) return;
+        const candidates = new Map(
+          Array.from(byMethod, ([method, candidate]) => [
+            method,
+            candidate.asHttpEffect(),
+          ]),
+        );
+        const fallback = first.asHttpEffect();
+        // The root wildcard matches last, so explicit OPTIONS routes still win.
+        yield* router.add(
+          "OPTIONS",
+          "*",
+          Effect.flatMap(HttpServerRequest.HttpServerRequest, (request) => {
+            const method = request.headers["access-control-request-method"];
+            return method === undefined
+              ? fallback
+              : (candidates.get(method) ?? notFound);
+          }),
+        );
+      });
+      return Layer.effectDiscard(register).pipe(
+        Layer.provideMerge(
+          routes.pipe(
+            Layer.provide(
+              Layer.succeed(HttpRouter.HttpRouter, wrap(router, "")),
+            ),
+          ),
+        ),
+      );
+    }),
+  );

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