@gaganref/confect-server 0.0.0-stage → 10.3.1-fork.2

package/src/FunctionImpl.ts

@@ -0,0 +1,96 @@
+import type * as FunctionSpec from "@confect/core/FunctionSpec";
+import type * as GroupSpec from "@confect/core/GroupSpec";
+import type * as MiddlewareSpec from "@confect/core/MiddlewareSpec";
+import * as Registry from "./Registry";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Ref from "effect/Ref";
+import type * as DatabaseSchema from "./DatabaseSchema";
+import type * as Handler from "./Handler";
+import { setNestedProperty } from "./internal/utils";
+import * as FunctionRegistryItem from "./FunctionRegistryItem";
+
+export interface FunctionImpl<Name_ extends string> {
+  readonly name: Name_;
+}
+
+export const FunctionImpl = <Name_ extends string>({ name }: { name: Name_ }) =>
+  Context.Service<FunctionImpl<Name_>>(`@confect/server/FunctionImpl/${name}`);
+
+/**
+ * Register a single function's implementation into the group's `Registry`.
+ *
+ * The function is registered under a flat, single-segment key (its own `name`),
+ * not a project-wide dot-path. Each group's impl layer is built in
+ * isolation—`RegisteredFunctions.buildForGroup` (and the CLI's `validateImpl`)
+ * provide a fresh `Registry` per group—so function names only need to be unique
+ * within their own group.
+ *
+ * `databaseSchema` is retained purely as a type-level carrier: the handler's
+ * ctx-service requirements (`DatabaseReader`, `QueryCtx<DataModel>`, …) are
+ * derived from it via `Handler.WithName`. It is not read at runtime—the
+ * generated per-group registry forwards the schema value to the function
+ * builders—so impls depend on `_generated/schema` (table schemas) rather than
+ * `_generated/api` (which transitively imports every function spec).
+ */
+export const make = <
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
+  Group extends GroupSpec.AnyWithProps,
+  const Name_ extends FunctionSpec.Name<GroupSpec.Functions<Group>>,
+>(
+  _databaseSchema: DatabaseSchema_,
+  group: Group,
+  name: Name_,
+  handler: Handler.WithName<
+    DatabaseSchema_,
+    GroupSpec.Functions<Group>,
+    Name_,
+    MiddlewareSpec.Provides<
+      | GroupSpec.MiddlewareSpecs<Group>
+      | FunctionSpec.MiddlewareSpecs<
+          FunctionSpec.WithName<GroupSpec.Functions<Group>, Name_>
+        >
+    >
+  >,
+): Layer.Layer<FunctionImpl<Name_>> => {
+  const functionSpec = group.functions[name]!;
+
+  return Layer.effect(
+    FunctionImpl<Name_>({ name }),
+    Effect.gen(function* () {
+      const registry = yield* Registry.Registry;
+
+      yield* Ref.update(registry, (registryItems) =>
+        setNestedProperty(
+          registryItems,
+          [name],
+          FunctionRegistryItem.make({
+            functionSpec,
+            groupMiddlewareAttachments: group.middlewareAttachments,
+            handler,
+          }),
+        ),
+      );
+
+      return { name };
+    }),
+  );
+};
+
+/**
+ * Get the function implementation service type for a specific function name.
+ */
+export type ForFunction<Name_ extends string> = FunctionImpl<Name_>;
+
+/**
+ * Get all function implementation services required for a group spec.
+ */
+export type FromGroupSpec<Group extends GroupSpec.AnyWithProps> =
+  FunctionSpec.Name<
+    GroupSpec.Functions<Group>
+  > extends infer FunctionNames extends string
+    ? FunctionNames extends string
+      ? FunctionImpl<FunctionNames>
+      : never
+    : never;

package/src/FunctionRegistryItem.ts

@@ -0,0 +1,85 @@
+import type * as MiddlewareAttachment from "@confect/core/MiddlewareAttachment";
+import type * as FunctionSpec from "@confect/core/FunctionSpec";
+import * as Lazy from "@confect/core/Lazy";
+import type { FunctionType, FunctionVisibility } from "convex/server";
+import * as Match from "effect/Match";
+import * as Predicate from "effect/Predicate";
+import type * as Schema from "effect/Schema";
+import type * as Handler from "./Handler";
+
+export const TypeId = "~@confect/server/FunctionRegistryItem";
+export type TypeId = typeof TypeId;
+
+export const isFunctionRegistryItem = (value: unknown): value is AnyWithProps =>
+  Predicate.hasProperty(value, TypeId);
+
+const FunctionRegistryItemProto = {
+  [TypeId]: TypeId,
+};
+
+/**
+ * A function registered by `FunctionImpl.make`, one of two shapes keyed by the
+ * spec's provenance.
+ */
+export type AnyWithProps =
+  | ConfectFunctionRegistryItem
+  | ConvexFunctionRegistryItem;
+
+export interface ConfectFunctionRegistryItem {
+  readonly [TypeId]: TypeId;
+  readonly _tag: "Confect";
+  readonly name: string;
+  readonly functionVisibility: FunctionVisibility;
+  readonly functionType: FunctionType;
+  readonly args: Schema.Codec<any, any>;
+  readonly returns: Schema.Codec<any, any>;
+  readonly error?: Schema.Codec<any, any>;
+  readonly middlewareAttachments: ReadonlyArray<MiddlewareAttachment.MiddlewareAttachment>;
+  readonly handler: Handler.AnyConfectProvenance;
+}
+
+export interface ConvexFunctionRegistryItem {
+  readonly [TypeId]: TypeId;
+  readonly _tag: "Convex";
+  readonly handler: Handler.AnyConvexProvenance;
+}
+
+export const make = ({
+  functionSpec,
+  groupMiddlewareAttachments,
+  handler,
+}: {
+  functionSpec: FunctionSpec.AnyWithProps;
+  groupMiddlewareAttachments: ReadonlyArray<MiddlewareAttachment.MiddlewareAttachment>;
+  handler: Handler.Any;
+}): AnyWithProps =>
+  Match.value(functionSpec.functionProvenance).pipe(
+    Match.tag("Convex", (): AnyWithProps =>
+      Object.assign(Object.create(FunctionRegistryItemProto), {
+        _tag: "Convex" as const,
+        handler: handler as Handler.AnyConvexProvenance,
+      }),
+    ),
+    Match.tag("Confect", (provenance): AnyWithProps => {
+      const item = Object.assign(Object.create(FunctionRegistryItemProto), {
+        _tag: "Confect" as const,
+        name: functionSpec.name,
+        functionVisibility: functionSpec.functionVisibility,
+        functionType: functionSpec.runtimeAndFunctionType.functionType,
+        middlewareAttachments: [
+          ...groupMiddlewareAttachments,
+          ...functionSpec.middlewareAttachments,
+        ],
+        handler: handler as Handler.AnyConfectProvenance,
+      });
+
+      Lazy.defineProperty(item, "args", () => provenance.args);
+      Lazy.defineProperty(item, "returns", () => provenance.returns);
+      if ("error" in provenance) {
+        Lazy.defineProperty(item, "error", () => provenance.error);
+      }
+
+      return item as AnyWithProps;
+    }),
+    Match.exhaustive,
+  );

package/src/GroupImpl.ts

@@ -0,0 +1,167 @@
+import type * as GroupSpec from "@confect/core/GroupSpec";
+import type * as MiddlewareSpec from "@confect/core/MiddlewareSpec";
+import * as Registry from "./Registry";
+import * as RegistryItems from "./RegistryItems";
+import * as Array from "effect/Array";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Ref from "effect/Ref";
+import type * as DatabaseSchema from "./DatabaseSchema";
+import type * as FunctionImpl from "./FunctionImpl";
+import type * as MiddlewareImpl from "./MiddlewareImpl";
+
+export const TypeId = "~@confect/server/GroupImpl";
+export type TypeId = typeof TypeId;
+
+export type FinalizationStatus = "Unfinalized" | "Finalized";
+
+export interface GroupImpl<
+  FinalizationStatus_ extends FinalizationStatus = "Unfinalized",
+> {
+  readonly [TypeId]: TypeId;
+  readonly finalizationStatus: FinalizationStatus_;
+  /**
+   * Names of every function registered into this group's layer scope by
+   * `FunctionImpl.make`. Authoritative only when `finalizationStatus` is
+   * `"Finalized"`; the `"Unfinalized"` value is set to `[]` at `make`-time
+   * since the list is only known once `finalize` snapshots the registry.
+   */
+  readonly registeredFunctionNames: ReadonlyArray<string>;
+  /**
+   * Keys of every middleware whose implementation registered into this group's
+   * layer scope via `MiddlewareImpl.make` (and friends). Same authoritativeness
+   * caveat as `registeredFunctionNames`. Lets consumers (the CLI's
+   * `validateImpl`) verify middleware-impl completeness against a `GroupSpec`'s
+   * attached middleware without inspecting the `Registry`.
+   */
+  readonly registeredMiddlewareKeys: ReadonlyArray<string>;
+}
+
+export interface Any extends GroupImpl<FinalizationStatus> {}
+
+export const isGroupImpl = (u: unknown): u is Any =>
+  Predicate.hasProperty(u, TypeId);
+
+export interface AnyFinalized extends GroupImpl<"Finalized"> {}
+export interface AnyUnfinalized extends GroupImpl<"Unfinalized"> {}
+
+export const isFinalizedGroupImpl = (u: unknown): u is AnyFinalized =>
+  isGroupImpl(u) && u.finalizationStatus === "Finalized";
+
+export const isUnfinalizedGroupImpl = (u: unknown): u is AnyUnfinalized =>
+  isGroupImpl(u) && u.finalizationStatus === "Unfinalized";
+
+/**
+ * Build the runtime tag for a `GroupImpl` service. The finalization status is
+ * embedded in the tag string so that `Unfinalized` and `Finalized` are distinct
+ * services at runtime; consumers of a finalized layer (the server's
+ * `RegisteredFunctions.buildForGroup` and the CLI's `validateImpl`) retrieve
+ * the typed `Finalized` service directly rather than scanning the context.
+ *
+ * The tag is keyed only by finalization status—no group path—because each
+ * group's impl layer is built in its own isolated scope
+ * (`buildForGroup`/`validateImpl` each provide a fresh `Registry`), so at most
+ * one `GroupImpl` service of each status exists per build.
+ */
+export const GroupImpl = <FinalizationStatus_ extends FinalizationStatus>({
+  finalizationStatus,
+}: {
+  finalizationStatus: FinalizationStatus_;
+}) =>
+  Context.Service<GroupImpl<FinalizationStatus_>>(
+    `@confect/server/GroupImpl/${finalizationStatus}`,
+  );
+
+/**
+ * Begin a group's impl layer. `databaseSchema` and `group` are retained only as
+ * type-level carriers (`group` drives the required `FunctionImpl` services via
+ * `FromGroupSpec<Group>`; `databaseSchema` keeps the impl's dependency on
+ * `_generated/schema` symmetric with `FunctionImpl.make`). Neither is read at
+ * runtime.
+ */
+export const make = <
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
+  Group extends GroupSpec.AnyWithProps,
+>(
+  _databaseSchema: DatabaseSchema_,
+  _group: Group &
+    MiddlewareSpec.ValidateImplRequires<
+      GroupSpec.Functions<Group>,
+      GroupSpec.MiddlewareSpecs<Group>
+    >,
+): Layer.Layer<
+  GroupImpl<"Unfinalized">,
+  never,
+  FunctionImpl.FromGroupSpec<Group> | MiddlewareImpl.FromGroupSpec<Group>
+> =>
+  Layer.succeed(
+    GroupImpl<"Unfinalized">({ finalizationStatus: "Unfinalized" }),
+    {
+      [TypeId]: TypeId,
+      finalizationStatus: "Unfinalized" as const,
+      registeredFunctionNames: [],
+      registeredMiddlewareKeys: [],
+    },
+  ) as Layer.Layer<
+    GroupImpl<"Unfinalized">,
+    never,
+    FunctionImpl.FromGroupSpec<Group> | MiddlewareImpl.FromGroupSpec<Group>
+  >;
+
+const findUnfinalizedGroupImpl = <S>(
+  context: Context.Context<S>,
+): Option.Option<AnyUnfinalized> =>
+  Array.findFirst(context.mapUnsafe.values(), isUnfinalizedGroupImpl);
+
+/**
+ * Mark a `GroupImpl` layer as fully implemented. The parameter type defaults
+ * `RIn = never`, so passing a layer that still requires any `FunctionImpl`
+ * service produces a type error at the impl author's site. The codegen boundary
+ * requires the resulting `"Finalized"` brand, so omitting this call is also
+ * rejected downstream.
+ *
+ * As a side effect of finalization, the names of every `FunctionImpl` that
+ * registered into this group's scope are snapshotted onto the produced service
+ * value's `registeredFunctionNames` field, so consumers can verify impl
+ * completeness against a `GroupSpec`'s expected functions without having to
+ * inspect the `Registry` themselves.
+ */
+export const finalize = (
+  group: Layer.Layer<GroupImpl<"Unfinalized">>,
+): Layer.Layer<GroupImpl<"Finalized">> =>
+  Layer.flatMap(group, (context): Layer.Layer<GroupImpl<"Finalized">> =>
+    findUnfinalizedGroupImpl(context).pipe(
+      Option.match({
+        onNone: () =>
+          Layer.effect(
+            GroupImpl<"Finalized">({ finalizationStatus: "Finalized" }),
+            Effect.die(
+              new Error(
+                "GroupImpl.finalize: no Unfinalized GroupImpl service was found in the layer's context.",
+              ),
+            ),
+          ),
+        onSome: () =>
+          Layer.effect(
+            GroupImpl<"Finalized">({ finalizationStatus: "Finalized" }),
+            Effect.gen(function* () {
+              const registry = yield* Registry.Registry;
+              const items = yield* Ref.get(registry);
+              return {
+                [TypeId]: TypeId,
+                finalizationStatus: "Finalized" as const,
+                registeredFunctionNames: RegistryItems.functionNames(items),
+                registeredMiddlewareKeys: RegistryItems.middlewareKeys(items),
+              };
+            }),
+          ),
+      }),
+    ),
+  );
+
+export type FromGroupSpec<Group extends GroupSpec.AnyWithProps> =
+  | FunctionImpl.FromGroupSpec<Group>
+  | MiddlewareImpl.FromGroupSpec<Group>;

package/src/GroupRegistry.ts

@@ -0,0 +1,41 @@
+import * as Effect from "effect/Effect";
+import type * as Layer from "effect/Layer";
+import * as Ref from "effect/Ref";
+import * as Registry from "./Registry";
+import type * as RegistryItems from "./RegistryItems";
+import type * as GroupImpl from "./GroupImpl";
+import * as MiddlewareRegistryItem from "./MiddlewareRegistryItem";
+
+export const make = (
+  groupLayer: Layer.Layer<GroupImpl.GroupImpl<"Finalized">>,
+) => {
+  const registryItems = Effect.gen(function* () {
+    const registry = yield* Registry.Registry;
+    return yield* Ref.get(registry);
+  }).pipe(
+    Effect.provide(groupLayer),
+    Effect.provideService(
+      Registry.Registry,
+      Ref.makeUnsafe<RegistryItems.RegistryItems>({}),
+    ),
+    Effect.runSync,
+  );
+
+  return partitionRegistryItems(registryItems);
+};
+
+const partitionRegistryItems = (registryItems: RegistryItems.RegistryItems) => {
+  const middlewareRegistryItems = new Map<
+    string,
+    MiddlewareRegistryItem.MiddlewareRegistryItem
+  >();
+  const functionRegistryItems: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(registryItems)) {
+    if (MiddlewareRegistryItem.isMiddlewareRegistryItem(value)) {
+      middlewareRegistryItems.set(value.middlewareSpec.key, value);
+    } else {
+      functionRegistryItems[key] = value;
+    }
+  }
+  return { functionRegistryItems, middlewareRegistryItems };
+};

package/src/Handler.ts

@@ -0,0 +1,191 @@
+import type { FunctionSpec, RuntimeAndFunctionType } from "@confect/core";
+import type * as FunctionProvenance from "@confect/core/FunctionProvenance";
+import type * as NodeServices from "@effect/platform-node/NodeServices";
+import type { Effect } from "effect";
+import type * as ActionCtx from "./ActionCtx";
+import type * as ActionRunner from "./ActionRunner";
+import type * as Auth from "./Auth";
+import type * as DatabaseReader from "./DatabaseReader";
+import type * as DatabaseSchema from "./DatabaseSchema";
+import type * as DatabaseWriter from "./DatabaseWriter";
+import type * as DataModel from "./DataModel";
+import type { ExecutionMetadata } from "./ExecutionMetadata";
+import type { RequestMetadata } from "./RequestMetadata";
+import type { TransactionMetadata } from "./TransactionMetadata";
+import type * as MutationCtx from "./MutationCtx";
+import type * as MutationRunner from "./MutationRunner";
+import type { MutationTransactionContext } from "./MutationTransactionContext";
+import type * as QueryCtx from "./QueryCtx";
+import type * as QueryRunner from "./QueryRunner";
+import type { QueryTransactionContext } from "./QueryTransactionContext";
+import type * as RegisteredFunction from "./RegisteredFunction";
+import type * as Scheduler from "./Scheduler";
+import type { Storage } from "./Storage";
+import type * as StorageActionWriter from "./StorageActionWriter";
+import type * as StorageReader from "./StorageReader";
+import type * as StorageWriter from "./StorageWriter";
+import type * as VectorSearch from "./VectorSearch";
+
+export type Handler<
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
+  FunctionSpec_ extends FunctionSpec.AnyWithProps,
+  R = never,
+> =
+  FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<
+    FunctionSpec_,
+    FunctionProvenance.AnyConvex
+  >
+    ? ConvexProvenanceHandler<FunctionSpec_>
+    : FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<
+          FunctionSpec_,
+          FunctionProvenance.AnyConfect
+        >
+      ? ConfectProvenanceHandler<DatabaseSchema_, FunctionSpec_, R>
+      : never;
+
+type ConvexProvenanceHandler<
+  FunctionSpec_ extends
+    FunctionSpec.AnyWithPropsWithFunctionProvenance<FunctionProvenance.AnyConvex>,
+> = RegisteredFunction.ConvexRegisteredFunction<FunctionSpec_>;
+
+type ConfectProvenanceHandler<
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
+  FunctionSpec_ extends
+    FunctionSpec.AnyWithPropsWithFunctionProvenance<FunctionProvenance.AnyConfect>,
+  R = never,
+> =
+  FunctionSpec_ extends FunctionSpec.WithFunctionType<FunctionSpec_, "query">
+    ? ConfectProvenanceQuery<DatabaseSchema_, FunctionSpec_, R>
+    : FunctionSpec_ extends FunctionSpec.WithFunctionType<
+          FunctionSpec_,
+          "mutation"
+        >
+      ? ConfectProvenanceMutation<DatabaseSchema_, FunctionSpec_, R>
+      : FunctionSpec_ extends FunctionSpec.WithRuntimeAndFunctionType<
+            FunctionSpec_,
+            RuntimeAndFunctionType.ConvexAction
+          >
+        ? ConvexRuntimeAction<DatabaseSchema_, FunctionSpec_, R>
+        : FunctionSpec_ extends FunctionSpec.WithRuntimeAndFunctionType<
+              FunctionSpec_,
+              RuntimeAndFunctionType.NodeAction
+            >
+          ? NodeRuntimeAction<DatabaseSchema_, FunctionSpec_, R>
+          : never;
+
+export type QueryServices<
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
+> =
+  | DatabaseReader.DatabaseReader<DatabaseSchema_>
+  | (DatabaseSchema_["target"]["kind"] extends "component" ? never : Auth.Auth)
+  | StorageReader.ForScope<DatabaseSchema.Scope<DatabaseSchema_>>
+  | ExecutionMetadata
+  | TransactionMetadata
+  | (DatabaseSchema_["target"]["kind"] extends "component" ? never : Storage)
+  | QueryRunner.QueryRunner
+  | QueryTransactionContext
+  | QueryCtx.QueryCtx<
+      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>,
+      DatabaseSchema.Scope<DatabaseSchema_>
+    >;
+
+export type MutationServices<
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
+> =
+  | DatabaseReader.DatabaseReader<DatabaseSchema_>
+  | DatabaseWriter.DatabaseWriter<DatabaseSchema_>
+  | (DatabaseSchema_["target"]["kind"] extends "component" ? never : Auth.Auth)
+  | Scheduler.ForScope<DatabaseSchema.Scope<DatabaseSchema_>>
+  | StorageReader.ForScope<DatabaseSchema.Scope<DatabaseSchema_>>
+  | StorageWriter.ForScope<DatabaseSchema.Scope<DatabaseSchema_>>
+  | ExecutionMetadata
+  | TransactionMetadata
+  | RequestMetadata
+  | (DatabaseSchema_["target"]["kind"] extends "component" ? never : Storage)
+  | QueryRunner.QueryRunner
+  | MutationRunner.MutationRunner
+  | QueryTransactionContext
+  | MutationTransactionContext
+  | MutationCtx.MutationCtx<
+      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>,
+      DatabaseSchema.Scope<DatabaseSchema_>
+    >;
+
+/**
+ * Shared by both action runtimes.
+ */
+export type ActionServices<
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
+> =
+  | Scheduler.ForScope<DatabaseSchema.Scope<DatabaseSchema_>>
+  | (DatabaseSchema_["target"]["kind"] extends "component" ? never : Auth.Auth)
+  | StorageReader.ForScope<DatabaseSchema.Scope<DatabaseSchema_>>
+  | StorageWriter.ForScope<DatabaseSchema.Scope<DatabaseSchema_>>
+  | StorageActionWriter.ForScope<DatabaseSchema.Scope<DatabaseSchema_>>
+  | ExecutionMetadata
+  | RequestMetadata
+  | (DatabaseSchema_["target"]["kind"] extends "component" ? never : Storage)
+  | QueryRunner.QueryRunner
+  | MutationRunner.MutationRunner
+  | ActionRunner.ActionRunner
+  | VectorSearch.VectorSearch<DataModel.FromSchema<DatabaseSchema_>>
+  | ActionCtx.ActionCtx<
+      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>,
+      DatabaseSchema.Scope<DatabaseSchema_>
+    >;
+
+export type ConfectProvenanceQuery<
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
+  FunctionSpec_ extends
+    FunctionSpec.AnyWithPropsWithFunctionType<RuntimeAndFunctionType.AnyQuery>,
+  R = never,
+> = Base<FunctionSpec_, QueryServices<DatabaseSchema_> | R>;
+
+export type ConfectProvenanceMutation<
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
+  FunctionSpec_ extends
+    FunctionSpec.AnyWithPropsWithFunctionType<RuntimeAndFunctionType.AnyMutation>,
+  R = never,
+> = Base<FunctionSpec_, MutationServices<DatabaseSchema_> | R>;
+
+export type ConvexRuntimeAction<
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
+  FunctionSpec_ extends
+    FunctionSpec.AnyWithPropsWithFunctionType<RuntimeAndFunctionType.AnyAction>,
+  R = never,
+> = Base<FunctionSpec_, ActionServices<DatabaseSchema_> | R>;
+
+export type NodeRuntimeAction<
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
+  FunctionSpec_ extends
+    FunctionSpec.AnyWithPropsWithFunctionType<RuntimeAndFunctionType.NodeAction>,
+  R = never,
+> = Base<
+  FunctionSpec_,
+  ActionServices<DatabaseSchema_> | NodeServices.NodeServices | R
+>;
+
+type Base<FunctionSpec_ extends FunctionSpec.AnyWithProps, R> = (
+  args: FunctionSpec.Args<FunctionSpec_>,
+) => Effect.Effect<
+  FunctionSpec.Returns<FunctionSpec_>,
+  FunctionSpec.Error<FunctionSpec_>,
+  R
+>;
+
+export type Any = AnyConfectProvenance | AnyConvexProvenance;
+
+export type AnyConfectProvenance = Base<FunctionSpec.AnyConfect, any>;
+
+export type AnyConvexProvenance = RegisteredFunction.Any;
+
+export type WithName<
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
+  FunctionSpec_ extends FunctionSpec.AnyWithProps,
+  FunctionName extends string,
+  R = never,
+> = Handler<
+  DatabaseSchema_,
+  FunctionSpec.WithName<FunctionSpec_, FunctionName>,
+  R
+>;