@confect/server 9.0.0-next.5 → 9.0.0-next.6

package/src/RegisteredFunctions.ts

@@ -2,18 +2,8 @@ import type * as FunctionSpec from "@confect/core/FunctionSpec";
 import type * as GroupSpec from "@confect/core/GroupSpec";
 import * as Registry from "@confect/core/Registry";
 import type * as Spec from "@confect/core/Spec";
-import {
-  Array,
-  Effect,
-  type Layer,
-  Option,
-  pipe,
-  Predicate,
-  Ref,
-  String,
-  type Types,
-} from "effect";
-import type * as Api from "./Api";
+import { Effect, type Layer, Ref, type Types } from "effect";
+import type * as DatabaseSchema from "./DatabaseSchema";
 import type * as GroupImpl from "./GroupImpl";
 import { mapLeaves } from "./internal/utils";
 import type * as RegisteredFunction from "./RegisteredFunction";
@@ -27,106 +17,90 @@ type RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = {
     Groups,
     GroupName
   > extends infer Group extends GroupSpec.AnyWithProps
-    ? GroupSpec.Groups<Group> extends infer SubGroups extends
-        GroupSpec.AnyWithProps
-      ? Types.Simplify<
-          RegisteredFunctionsHelper<SubGroups> & {
-            [FunctionName in FunctionSpec.Name<
-              GroupSpec.Functions<Group>
-            >]: FunctionSpec.WithName<
-              GroupSpec.Functions<Group>,
-              FunctionName
-            > extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps
-              ? RegisteredFunction.RegisteredFunction<FunctionSpec_>
-              : never;
-          }
-        >
-      : {
-          [FunctionName in FunctionSpec.Name<
-            GroupSpec.Functions<Group>
-          >]: FunctionSpec.WithName<
-            GroupSpec.Functions<Group>,
-            FunctionName
-          > extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps
-            ? RegisteredFunction.RegisteredFunction<FunctionSpec_>
-            : never;
-        }
+    ? RegisteredFunctionsForGroupSpec<Group>
     : never;
 };
 
+/** The `RegisteredFunction` record for a group's own declared functions. */
+type RegisteredFunctionsOf<Group extends GroupSpec.AnyWithProps> = {
+  [FunctionName in FunctionSpec.Name<
+    GroupSpec.Functions<Group>
+  >]: FunctionSpec.WithName<
+    GroupSpec.Functions<Group>,
+    FunctionName
+  > extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps
+    ? RegisteredFunction.RegisteredFunction<FunctionSpec_>
+    : never;
+};
+
+/**
+ * The registered-functions record for a single group, derived from the group's
+ * own `GroupSpec`: its declared functions, plus any nested subgroups it carries
+ * directly. This is the node that `buildForGroup` returns — computed from the
+ * leaf `GroupSpec` itself rather than by navigating the project-wide assembled
+ * `Spec` to a dot-path, so the per-group registry's type depends only on its
+ * own leaf. For the filesystem layout a leaf `GroupSpec` carries no subgroups
+ * (subdirectory children are assembled separately into `_generated/spec.ts`),
+ * so this resolves to just the leaf's functions.
+ */
+export type RegisteredFunctionsForGroupSpec<
+  Group extends GroupSpec.AnyWithProps,
+> =
+  GroupSpec.Groups<Group> extends infer SubGroups extends GroupSpec.AnyWithProps
+    ? Types.Simplify<
+        RegisteredFunctionsHelper<SubGroups> & RegisteredFunctionsOf<Group>
+      >
+    : RegisteredFunctionsOf<Group>;
+
 export interface AnyWithProps {
   readonly [key: string]: RegisteredFunction.Any | AnyWithProps;
 }
 
-type RegisteredFunctionsAtPath<
-  Tree,
-  Path extends string,
-> = Path extends `${infer Head}.${infer Tail}`
-  ? Head extends keyof Tree
-    ? Tree[Head] extends AnyWithProps
-      ? RegisteredFunctionsAtPath<Tree[Head], Tail>
-      : never
-    : never
-  : Path extends keyof Tree
-    ? Tree[Path]
-    : never;
-
-export type ForGroupPath<
-  Spec_ extends Spec.AnyWithProps,
-  Path extends string,
-> = RegisteredFunctionsAtPath<RegisteredFunctions<Spec_>, Path>;
-
 /**
  * Build the registered Convex functions for a single group from its finalized
  * `GroupImpl` layer.
  *
- * The `groupLayer` parameter requires `GroupImpl<string, "Finalized">`, so
- * impls that were never piped through `GroupImpl.finalize` (and impls with
- * unmet `FunctionImpl` requirements, which cannot be finalized) are rejected
- * at the codegen boundary, not just deep inside Convex at runtime.
+ * The `groupLayer` parameter requires `GroupImpl<"Finalized">`, so impls that
+ * were never piped through `GroupImpl.finalize` (and impls with unmet
+ * `FunctionImpl` requirements, which cannot be finalized) are rejected at the
+ * codegen boundary, not just deep inside Convex at runtime.
+ *
+ * The group layer is built with a fresh, isolated `Registry` (rather than the
+ * globally-cached default `Context.Reference`), so each `FunctionImpl.make`
+ * registers under its flat, single-segment function-name key without colliding
+ * with any other group built in the same process — the built registry holds
+ * exactly this group's functions at the top level.
+ *
+ * Only the runtime `databaseSchema` value is needed at runtime (it is forwarded
+ * to `makeRegisteredFunction` to build each function's ctx services); the
+ * group's `GroupSpec` is supplied purely as the `Group` type parameter to shape
+ * the returned record. The generated caller passes it explicitly and imports
+ * the leaf spec type-only (`typeof import("…/<group>.spec")["default"]`), so a
+ * function's bundle never imports a spec module at runtime.
  */
-export const buildForGroup = <
-  Api_ extends Api.AnyWithProps,
-  const GroupPath_ extends string,
->(
-  api: Api_,
-  groupPath: GroupPath_,
-  groupLayer: Layer.Layer<GroupImpl.GroupImpl<string, "Finalized">>,
+export const buildForGroup = <Group extends GroupSpec.AnyWithProps>(
+  databaseSchema: DatabaseSchema.AnyWithProps,
+  groupLayer: Layer.Layer<GroupImpl.GroupImpl<"Finalized">>,
   makeRegisteredFunction: (
-    api: Api_,
+    databaseSchema: DatabaseSchema.AnyWithProps,
     registryItem: RegistryItem.AnyWithProps,
   ) => RegisteredFunction.Any,
-): ForGroupPath<Api_["spec"], GroupPath_> => {
+): RegisteredFunctionsForGroupSpec<Group> => {
   const registryItems = Effect.gen(function* () {
     const registry = yield* Registry.Registry;
     return yield* Ref.get(registry);
-  }).pipe(Effect.provide(groupLayer), Effect.runSync);
+  }).pipe(
+    Effect.provide(groupLayer),
+    Effect.provideService(
+      Registry.Registry,
+      Ref.unsafeMake<Registry.RegistryItems>({}),
+    ),
+    Effect.runSync,
+  );
 
-  const registeredFunctions = mapLeaves<
-    RegistryItem.AnyWithProps,
-    RegisteredFunction.Any
-  >(
+  return mapLeaves<RegistryItem.AnyWithProps, RegisteredFunction.Any>(
     registryItems as { [key: string]: RegistryItem.AnyWithProps },
     RegistryItem.isRegistryItem,
-    (registryItem) => makeRegisteredFunction(api, registryItem),
-  );
-
-  return pipe(
-    String.split(groupPath, "."),
-    Array.reduce(
-      Option.some<unknown>(registeredFunctions),
-      (currentNode, segment) =>
-        currentNode.pipe(
-          Option.filter(Predicate.isRecord),
-          Option.flatMap((nodeRecord) =>
-            segment in nodeRecord
-              ? Option.some(nodeRecord[segment])
-              : Option.none(),
-          ),
-        ),
-    ),
-    Option.getOrThrowWith(
-      () => new Error(`No functions registered for group path "${groupPath}"`),
-    ),
-  ) as ForGroupPath<Api_["spec"], GroupPath_>;
+    (registryItem) => makeRegisteredFunction(databaseSchema, registryItem),
+  ) as RegisteredFunctionsForGroupSpec<Group>;
 };

package/src/RegisteredNodeFunction.ts

@@ -7,14 +7,13 @@ import {
 } from "convex/server";
 import type { Effect } from "effect";
 import { Layer, Match, type Schema } from "effect";
-import type * as Api from "./Api";
 import type * as DatabaseSchema from "./DatabaseSchema";
 import type * as Handler from "./Handler";
 import * as RegisteredFunction from "./RegisteredFunction";
 import type * as RegistryItem from "./RegistryItem";
 
-export const make = <Api_ extends Api.AnyWithPropsWithRuntime<"Node">>(
-  api: Api_,
+export const make = (
+  databaseSchema: DatabaseSchema.AnyWithProps,
   { functionSpec, handler }: RegistryItem.AnyWithProps,
 ): RegisteredFunction.Any =>
   Match.value(functionSpec.functionProvenance).pipe(
@@ -30,7 +29,7 @@ export const make = <Api_ extends Api.AnyWithPropsWithRuntime<"Node">>(
       );
 
       return genericFunction(
-        nodeActionFunction(api.databaseSchema, {
+        nodeActionFunction(databaseSchema, {
           args: functionProvenance.args,
           returns: functionProvenance.returns,
           error: functionProvenance.error,