@confect/core 10.0.0-next.8 → 10.0.0

package/src/Refs.ts

@@ -4,8 +4,9 @@ import * as Option from "effect/Option";
 import * as Record from "effect/Record";
 import type * as FunctionSpec from "./FunctionSpec";
 import type * as GroupSpec from "./GroupSpec";
+import type * as MiddlewareSpec from "./MiddlewareSpec";
 import * as Ref from "./Ref";
-import type * as Spec from "./Spec";
+import * as Spec from "./Spec";
 
 export type Refs<
   Spec_ extends Spec.AnyWithProps,
@@ -22,7 +23,11 @@ type GroupRefs<
   Predicate extends Ref.Any,
 > = Types.Simplify<
   OmitEmpty<Helper<GroupSpec.Groups<Group>, Predicate>> &
-    FilteredFunctions<GroupSpec.Functions<Group>, Predicate>
+    FilteredFunctions<
+      GroupSpec.Functions<Group>,
+      Predicate,
+      MiddlewareSpec.Error<GroupSpec.MiddlewareSpecs<Group>>
+    >
 >;
 
 type OmitEmpty<T> = {
@@ -37,6 +42,7 @@ type FunctionSpecMatchesPredicate<
     FunctionSpec.GetRuntimeAndFunctionType<FunctionSpec_>,
     FunctionSpec.GetFunctionVisibility<FunctionSpec_>,
     any,
+    any,
     any
   > extends Predicate
     ? true
@@ -45,17 +51,29 @@ type FunctionSpecMatchesPredicate<
 type FilteredFunctions<
   FunctionSpecs extends FunctionSpec.AnyWithProps,
   Predicate extends Ref.Any,
+  MiddlewareError,
 > = {
-  [Name in FunctionSpec.Name<FunctionSpecs> as FunctionSpec.WithName<
-    FunctionSpecs,
-    Name
-  > extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps
-    ? FunctionSpecMatchesPredicate<FunctionSpec_, Predicate> extends true
-      ? Name
+  [
+    Name in FunctionSpec.Name<FunctionSpecs> as FunctionSpec.WithName<
+      FunctionSpecs,
+      Name
+    > extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps
+      ? FunctionSpecMatchesPredicate<FunctionSpec_, Predicate> extends true
+        ? Name
+        : never
       : never
-    : never]: FunctionSpec.WithName<FunctionSpecs, Name> extends infer F extends
+  ]: FunctionSpec.WithName<FunctionSpecs, Name> extends infer F extends
     FunctionSpec.AnyWithProps
-    ? Ref.FromFunctionSpec<F>
+    ? Ref.FromFunctionSpec<
+        F,
+        F extends {
+          readonly functionProvenance: { readonly _tag: "Confect" };
+        }
+          ?
+              | MiddlewareError
+              | MiddlewareSpec.Error<FunctionSpec.MiddlewareSpecs<F>>
+          : never
+      >
     : never;
 };
 
@@ -80,7 +98,7 @@ type Any =
 export const make = <Spec_ extends Spec.AnyWithProps>(
   spec: Spec_,
 ): FromSpec<Spec_> => {
-  const refs = makeHelper(spec.groups);
+  const refs = makeHelper(Spec.groups(spec));
   return {
     public: refs as Refs<Spec_, Ref.AnyPublic>,
     internal: refs as Refs<Spec_, Ref.AnyInternal>,
@@ -89,20 +107,27 @@ export const make = <Spec_ extends Spec.AnyWithProps>(
 
 const makeHelper = (
   groups: Record.ReadonlyRecord<string, GroupSpec.Any>,
-  functionNamespace: Option.Option<string> = Option.none(),
+  convexFunctionNamespace: Option.Option<string> = Option.none(),
 ): Any =>
   pipe(
     groups as Record.ReadonlyRecord<string, GroupSpec.AnyWithProps>,
     Record.map((group, name) => {
-      const currentFunctionNamespace = Option.match(functionNamespace, {
-        onNone: () => name,
-        onSome: (parentNamespace) => `${parentNamespace}/${name}`,
-      });
+      const currentConvexFunctionNamespace = Option.match(
+        convexFunctionNamespace,
+        {
+          onNone: () => name,
+          onSome: (parentNamespace) => `${parentNamespace}/${name}`,
+        },
+      );
 
       return Record.union(
-        makeHelper(group.groups, Option.some(currentFunctionNamespace)),
+        makeHelper(group.groups, Option.some(currentConvexFunctionNamespace)),
         Record.map(group.functions, (function_) =>
-          Ref.make(currentFunctionNamespace, function_),
+          Ref.make(
+            currentConvexFunctionNamespace,
+            function_,
+            group.middlewareAttachments,
+          ),
         ),
         (_subGroup, _function) => {
           throw new Error(