@confect/core 9.0.0-next.8 → 9.0.0

package/src/Spec.ts

@@ -1,9 +1,6 @@
-import * as Array from "effect/Array";
-import * as Option from "effect/Option";
 import * as Predicate from "effect/Predicate";
 import * as Record from "effect/Record";
 import * as GroupSpec from "./GroupSpec";
-import type * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";
 
 export const TypeId = "@confect/core/Spec";
 export type TypeId = typeof TypeId;
@@ -11,24 +8,15 @@ export type TypeId = typeof TypeId;
 export const isSpec = (u: unknown): u is AnyWithProps =>
   Predicate.hasProperty(u, TypeId);
 
-export const isConvexSpec = (
-  u: unknown,
-): u is AnyWithPropsWithRuntime<"Convex"> =>
-  Predicate.hasProperty(u, TypeId) &&
-  Predicate.hasProperty(u, "runtime") &&
-  u.runtime === "Convex";
-
-export const isNodeSpec = (u: unknown): u is AnyWithPropsWithRuntime<"Node"> =>
-  Predicate.hasProperty(u, TypeId) &&
-  Predicate.hasProperty(u, "runtime") &&
-  u.runtime === "Node";
-
-export interface Spec<
-  Runtime extends RuntimeAndFunctionType.Runtime,
-  Groups_ extends GroupSpec.AnyWithPropsWithRuntime<Runtime> = never,
-> {
+/**
+ * A Confect spec: a flat container of function groups. Groups may be of any
+ * runtime — a group built with `GroupSpec.makeNode()` (a Node action group) sits
+ * alongside `GroupSpec.make()` groups in the same namespace. The runtime of a
+ * group lives on the group itself (`GroupSpec.runtime`) and on each function's
+ * `RuntimeAndFunctionType`; the spec does not carry a runtime of its own.
+ */
+export interface Spec<Groups_ extends GroupSpec.AnyWithProps = never> {
   readonly [TypeId]: TypeId;
-  readonly runtime: Runtime;
   readonly groups: {
     [GroupName in GroupSpec.Name<Groups_>]: GroupSpec.WithName<
       Groups_,
@@ -36,31 +24,21 @@ export interface Spec<
     >;
   };
 
-  add<Group extends GroupSpec.AnyWithPropsWithRuntime<Runtime>>(
+  add<Group extends GroupSpec.AnyWithProps>(
     group: Group,
-  ): Spec<Runtime, Groups_ | Group>;
+  ): Spec<Groups_ | Group>;
 
-  addAt<
-    const Name extends string,
-    Group extends GroupSpec.AnyWithPropsWithRuntime<Runtime>,
-  >(
+  addAt<const Name extends string, Group extends GroupSpec.AnyWithProps>(
     name: Name,
     group: Group,
-  ): Spec<Runtime, Groups_ | GroupSpec.NamedAt<Group, Name>>;
+  ): Spec<Groups_ | GroupSpec.NamedAt<Group, Name>>;
 }
 
 export interface Any {
   readonly [TypeId]: TypeId;
 }
 
-export interface AnyWithProps extends Spec<
-  RuntimeAndFunctionType.Runtime,
-  GroupSpec.AnyWithProps
-> {}
-
-export interface AnyWithPropsWithRuntime<
-  Runtime extends RuntimeAndFunctionType.Runtime,
-> extends Spec<Runtime, GroupSpec.AnyWithPropsWithRuntime<Runtime>> {}
+export interface AnyWithProps extends Spec<GroupSpec.AnyWithProps> {}
 
 export type Groups<Spec_ extends AnyWithProps> =
   Spec_["groups"][keyof Spec_["groups"]];
@@ -70,7 +48,6 @@ const Proto = {
 
   add<Group extends GroupSpec.AnyWithProps>(this: AnyWithProps, group: Group) {
     return makeProto({
-      runtime: this.runtime,
       groups: Record.set(this.groups, group.name, group),
     });
   },
@@ -81,62 +58,18 @@ const Proto = {
     group: Group,
   ) {
     return makeProto({
-      runtime: this.runtime,
       groups: Record.set(this.groups, name, GroupSpec.withName(name, group)),
     });
   },
 };
 
-const makeProto = <
-  Runtime extends RuntimeAndFunctionType.Runtime,
-  Groups_ extends GroupSpec.AnyWithPropsWithRuntime<Runtime>,
->({
-  runtime,
+const makeProto = <Groups_ extends GroupSpec.AnyWithProps>({
   groups,
 }: {
-  runtime: Runtime;
   groups: Record.ReadonlyRecord<string, Groups_>;
-}): Spec<Runtime, Groups_> =>
+}): Spec<Groups_> =>
   Object.assign(Object.create(Proto), {
-    runtime,
     groups,
   });
 
-export const make = (): Spec<"Convex"> =>
-  makeProto({ runtime: "Convex", groups: {} });
-
-export const makeNode = (): Spec<"Node"> =>
-  makeProto({ runtime: "Node", groups: {} });
-
-/**
- * Merges a Convex spec with an optional Node spec into a single assembled
- * spec (used by codegen to build `Refs.make` and to enumerate function paths).
- * When `nodeSpec` is provided, its groups are merged under a "node" namespace,
- * mirroring the structure used by `Refs.make`.
- */
-export const merge = <
-  ConvexSpec extends AnyWithPropsWithRuntime<"Convex">,
-  NodeSpec extends AnyWithPropsWithRuntime<"Node">,
->(
-  convexSpec: ConvexSpec,
-  nodeSpec?: NodeSpec,
-): AnyWithProps => {
-  const groups = Option.fromNullable(nodeSpec).pipe(
-    Option.map((nodeSpec_) =>
-      Array.reduce(
-        Record.toEntries(nodeSpec_.groups),
-        GroupSpec.makeNodeAt("node"),
-        (nodeGroupSpec, [name, group]) => nodeGroupSpec.addGroupAt(name, group),
-      ),
-    ),
-    Option.match({
-      onNone: () => convexSpec.groups,
-      onSome: (nodeGroup) => ({ ...convexSpec.groups, node: nodeGroup }),
-    }),
-  );
-
-  return Object.assign(Object.create(Proto), {
-    runtime: "Convex" as const,
-    groups,
-  }) as AnyWithProps;
-};
+export const make = (): Spec => makeProto({ groups: {} });