@confect/core 1.0.0-next.3 → 1.0.0

package/src/Ref.ts

@@ -1,14 +1,15 @@
-import type { FunctionType, FunctionVisibility } from "convex/server";
+import type { FunctionVisibility } from "convex/server";
 import type { Schema } from "effect";
 import type * as FunctionSpec from "./FunctionSpec";
+import type * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";
 
 export interface Ref<
-  _FunctionType extends FunctionType,
+  _RuntimeAndFunctionType extends RuntimeAndFunctionType.RuntimeAndFunctionType,
   _FunctionVisibility extends FunctionVisibility,
   _Args extends Schema.Schema.AnyNoContext,
   _Returns extends Schema.Schema.AnyNoContext,
 > {
-  readonly _FunctionType?: _FunctionType;
+  readonly _RuntimeAndFunctionType?: _RuntimeAndFunctionType;
   readonly _FunctionVisibility?: _FunctionVisibility;
   readonly _Args?: _Args;
   readonly _Returns?: _Returns;
@@ -21,60 +22,80 @@ export interface AnyInternal extends Ref<any, "internal", any, any> {}
 export interface AnyPublic extends Ref<any, "public", any, any> {}
 
 export interface AnyQuery extends Ref<
-  "query",
+  RuntimeAndFunctionType.AnyQuery,
   FunctionVisibility,
   Schema.Schema.AnyNoContext,
   Schema.Schema.AnyNoContext
 > {}
 
 export interface AnyMutation extends Ref<
-  "mutation",
+  RuntimeAndFunctionType.AnyMutation,
   FunctionVisibility,
   Schema.Schema.AnyNoContext,
   Schema.Schema.AnyNoContext
 > {}
 
 export interface AnyAction extends Ref<
-  "action",
+  RuntimeAndFunctionType.AnyAction,
   FunctionVisibility,
   Schema.Schema.AnyNoContext,
   Schema.Schema.AnyNoContext
 > {}
 
 export interface AnyPublicQuery extends Ref<
-  "query",
+  RuntimeAndFunctionType.AnyQuery,
   "public",
   Schema.Schema.AnyNoContext,
   Schema.Schema.AnyNoContext
 > {}
 
 export interface AnyPublicMutation extends Ref<
-  "mutation",
+  RuntimeAndFunctionType.AnyMutation,
   "public",
   Schema.Schema.AnyNoContext,
   Schema.Schema.AnyNoContext
 > {}
 
 export interface AnyPublicAction extends Ref<
-  "action",
+  RuntimeAndFunctionType.AnyAction,
   "public",
   Schema.Schema.AnyNoContext,
   Schema.Schema.AnyNoContext
 > {}
 
+export type GetRuntimeAndFunctionType<Ref_> =
+  Ref_ extends Ref<
+    infer RuntimeAndFunctionType_,
+    infer _FunctionVisibility,
+    infer _Args,
+    infer _Returns
+  >
+    ? RuntimeAndFunctionType_
+    : never;
+
+export type GetRuntime<Ref_> =
+  Ref_ extends Ref<
+    infer RuntimeAndFunctionType_,
+    infer _FunctionVisibility,
+    infer _Args,
+    infer _Returns
+  >
+    ? RuntimeAndFunctionType.GetRuntime<RuntimeAndFunctionType_>
+    : never;
+
 export type GetFunctionType<Ref_> =
   Ref_ extends Ref<
-    infer FunctionType_,
+    infer RuntimeAndFunctionType_,
     infer _FunctionVisibility,
     infer _Args,
     infer _Returns
   >
-    ? FunctionType_
+    ? RuntimeAndFunctionType.GetFunctionType<RuntimeAndFunctionType_>
     : never;
 
 export type GetFunctionVisibility<Ref_> =
   Ref_ extends Ref<
-    infer _FunctionType,
+    infer _RuntimeAndFunctionType,
     infer FunctionVisibility_,
     infer _Args,
     infer _Returns
@@ -84,7 +105,7 @@ export type GetFunctionVisibility<Ref_> =
 
 export type Args<Ref_> =
   Ref_ extends Ref<
-    infer _FunctionType,
+    infer _RuntimeAndFunctionType,
     infer _FunctionVisibility,
     infer Args_,
     infer _Returns
@@ -94,7 +115,7 @@ export type Args<Ref_> =
 
 export type Returns<Ref_> =
   Ref_ extends Ref<
-    infer _FunctionType,
+    infer _RuntimeAndFunctionType,
     infer _FunctionVisibility,
     infer _Args,
     infer Returns_
@@ -103,14 +124,14 @@ export type Returns<Ref_> =
     : never;
 
 export type FromFunctionSpec<F extends FunctionSpec.AnyWithProps> = Ref<
-  FunctionSpec.GetFunctionType<F>,
+  FunctionSpec.GetRuntimeAndFunctionType<F>,
   FunctionSpec.GetFunctionVisibility<F>,
   FunctionSpec.Args<F>,
   FunctionSpec.Returns<F>
 >;
 
 export const make = <
-  FunctionType_ extends FunctionType,
+  RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType,
   FunctionVisibility_ extends FunctionVisibility,
   Args_ extends Schema.Schema.AnyNoContext,
   Returns_ extends Schema.Schema.AnyNoContext,
@@ -120,22 +141,22 @@ export const make = <
    */
   convexFunctionName: string,
   function_: FunctionSpec.FunctionSpec<
-    FunctionType_,
+    RuntimeAndFunctionType_,
     FunctionVisibility_,
     string,
     Args_,
     Returns_
   >,
-): Ref<FunctionType_, FunctionVisibility_, Args_, Returns_> =>
+): Ref<RuntimeAndFunctionType_, FunctionVisibility_, Args_, Returns_> =>
   ({
     [HiddenFunctionKey]: function_,
     [HiddenConvexFunctionNameKey]: convexFunctionName,
-  }) as Ref<FunctionType_, FunctionVisibility_, Args_, Returns_>;
+  }) as Ref<RuntimeAndFunctionType_, FunctionVisibility_, Args_, Returns_>;
 
 const HiddenFunctionKey = "@confect/core/api/HiddenFunctionKey";
 type HiddenFunctionKey = typeof HiddenFunctionKey;
 type HiddenFunction<Ref_ extends Any> = FunctionSpec.FunctionSpec<
-  GetFunctionType<Ref_>,
+  GetRuntimeAndFunctionType<Ref_>,
   GetFunctionVisibility<Ref_>,
   string,
   Args<Ref_>,
@@ -143,11 +164,16 @@ type HiddenFunction<Ref_ extends Any> = FunctionSpec.FunctionSpec<
 >;
 
 export const getFunction = <
-  FunctionType_ extends FunctionType,
+  RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType,
   FunctionVisibility_ extends FunctionVisibility,
   Args_ extends Schema.Schema.AnyNoContext,
   Returns_ extends Schema.Schema.AnyNoContext,
-  Ref_ extends Ref<FunctionType_, FunctionVisibility_, Args_, Returns_>,
+  Ref_ extends Ref<
+    RuntimeAndFunctionType_,
+    FunctionVisibility_,
+    Args_,
+    Returns_
+  >,
 >(
   ref: Ref_,
 ): HiddenFunction<Ref_> => (ref as any)[HiddenFunctionKey];
@@ -158,10 +184,10 @@ type HiddenConvexFunctionNameKey = typeof HiddenConvexFunctionNameKey;
 type HiddenConvexFunctionName = string;
 
 export const getConvexFunctionName = <
-  FunctionType_ extends FunctionType,
+  RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType,
   FunctionVisibility_ extends FunctionVisibility,
   Args_ extends Schema.Schema.AnyNoContext,
   Returns_ extends Schema.Schema.AnyNoContext,
 >(
-  ref: Ref<FunctionType_, FunctionVisibility_, Args_, Returns_>,
+  ref: Ref<RuntimeAndFunctionType_, FunctionVisibility_, Args_, Returns_>,
 ): HiddenConvexFunctionName => (ref as any)[HiddenConvexFunctionNameKey];

package/src/Refs.ts

@@ -1,14 +1,30 @@
 import type { Types } from "effect";
-import { pipe, Record } from "effect";
+import { Array, pipe, Record } from "effect";
 import type * as FunctionSpec from "./FunctionSpec";
-import type * as GroupSpec from "./GroupSpec";
+import * as GroupSpec from "./GroupSpec";
 import * as Ref from "./Ref";
 import type * as Spec from "./Spec";
 
 export type Refs<
-  Spec_ extends Spec.AnyWithProps,
+  ConvexSpec extends Spec.AnyWithPropsWithRuntime<"Convex">,
+  NodeSpec extends Spec.AnyWithPropsWithRuntime<"Node"> = never,
   Predicate extends Ref.Any = Ref.Any,
-> = Types.Simplify<OmitEmpty<Helper<Spec.Groups<Spec_>, Predicate>>>;
+> = Types.Simplify<
+  OmitEmpty<
+    Helper<
+      | Spec.Groups<ConvexSpec>
+      | (NodeSpec extends never
+          ? never
+          : GroupSpec.GroupSpec<
+              "Node",
+              "node",
+              never,
+              NodeSpec["groups"][keyof NodeSpec["groups"]]
+            >),
+      Predicate
+    >
+  >
+>;
 
 type GroupRefs<
   Group extends GroupSpec.AnyWithProps,
@@ -57,16 +73,31 @@ type Any =
     }
   | Ref.Any;
 
-export const make = <Spec_ extends Spec.AnyWithProps>(
-  spec: Spec_,
+export const make = <
+  ConvexSpec extends Spec.AnyWithPropsWithRuntime<"Convex">,
+  NodeSpec extends Spec.AnyWithPropsWithRuntime<"Node"> = never,
+>(
+  convexSpec: ConvexSpec,
+  nodeSpec?: NodeSpec,
 ): {
-  public: Refs<Spec_, Ref.AnyPublic>;
-  internal: Refs<Spec_, Ref.AnyInternal>;
+  public: Refs<ConvexSpec, NodeSpec, Ref.AnyPublic>;
+  internal: Refs<ConvexSpec, NodeSpec, Ref.AnyInternal>;
 } => {
-  const refs = makeHelper(spec.groups);
+  const nodeGroup = nodeSpec
+    ? Array.reduce(
+        Record.values(nodeSpec.groups),
+        GroupSpec.makeNode("node"),
+        (nodeGroupSpec, group) => nodeGroupSpec.addGroup(group),
+      )
+    : null;
+
+  const groups = nodeGroup
+    ? { ...convexSpec.groups, node: nodeGroup }
+    : convexSpec.groups;
+  const refs = makeHelper(groups);
   return {
-    public: refs as Refs<Spec_, Ref.AnyPublic>,
-    internal: refs as Refs<Spec_, Ref.AnyInternal>,
+    public: refs as Refs<ConvexSpec, NodeSpec, Ref.AnyPublic>,
+    internal: refs as Refs<ConvexSpec, NodeSpec, Ref.AnyInternal>,
   };
 };
 

package/src/RuntimeAndFunctionType.ts

@@ -0,0 +1,57 @@
+export type RuntimeAndFunctionType =
+  | { readonly runtime: "Convex"; readonly functionType: "query" }
+  | { readonly runtime: "Convex"; readonly functionType: "mutation" }
+  | { readonly runtime: "Convex"; readonly functionType: "action" }
+  | { readonly runtime: "Node"; readonly functionType: "action" };
+
+export type Runtime = RuntimeAndFunctionType["runtime"];
+
+const make = <
+  Runtime_ extends Runtime,
+  FunctionType_ extends GetFunctionType<WithRuntime<Runtime_>>,
+>(
+  runtime: Runtime_,
+  functionType: FunctionType_,
+): { readonly runtime: Runtime_; readonly functionType: FunctionType_ } => ({
+  runtime,
+  functionType,
+});
+
+export type AnyQuery = Extract<
+  RuntimeAndFunctionType,
+  { readonly functionType: "query" }
+>;
+
+export type AnyMutation = Extract<
+  RuntimeAndFunctionType,
+  { readonly functionType: "mutation" }
+>;
+
+export type AnyAction = Extract<
+  RuntimeAndFunctionType,
+  { readonly functionType: "action" }
+>;
+
+export type WithRuntime<Runtime_ extends Runtime> = Extract<
+  RuntimeAndFunctionType,
+  { readonly runtime: Runtime_ }
+>;
+
+export type GetRuntime<RuntimeAndFunctionType_ extends RuntimeAndFunctionType> =
+  RuntimeAndFunctionType_["runtime"];
+
+export type GetFunctionType<
+  RuntimeAndFunctionType_ extends RuntimeAndFunctionType,
+> = RuntimeAndFunctionType_["functionType"];
+
+export const ConvexQuery = make("Convex", "query");
+export type ConvexQuery = typeof ConvexQuery;
+
+export const ConvexMutation = make("Convex", "mutation");
+export type ConvexMutation = typeof ConvexMutation;
+
+export const ConvexAction = make("Convex", "action");
+export type ConvexAction = typeof ConvexAction;
+
+export const NodeAction = make("Node", "action");
+export type NodeAction = typeof NodeAction;

package/src/Spec.ts

@@ -1,14 +1,31 @@
-import { Predicate, Record } from "effect";
-import type * as GroupSpec from "./GroupSpec";
+import { Array, Predicate, Record } from "effect";
+import * as GroupSpec from "./GroupSpec";
+import type * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";
 
-export const TypeId = "@confect/core/api/Spec";
+export const TypeId = "@confect/core/Spec";
 export type TypeId = typeof TypeId;
 
 export const isSpec = (u: unknown): u is AnyWithProps =>
   Predicate.hasProperty(u, TypeId);
 
-export interface Spec<Groups_ extends GroupSpec.AnyWithProps = never> {
+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,
+> {
   readonly [TypeId]: TypeId;
+  readonly runtime: Runtime;
   readonly groups: {
     [GroupName in GroupSpec.Name<Groups_>]: GroupSpec.WithName<
       Groups_,
@@ -16,16 +33,23 @@ export interface Spec<Groups_ extends GroupSpec.AnyWithProps = never> {
     >;
   };
 
-  add<Group extends GroupSpec.AnyWithProps>(
+  add<Group extends GroupSpec.AnyWithPropsWithRuntime<Runtime>>(
     group: Group,
-  ): Spec<Groups_ | Group>;
+  ): Spec<Runtime, Groups_ | Group>;
 }
 
 export interface Any {
   readonly [TypeId]: TypeId;
 }
 
-export interface AnyWithProps extends Spec<GroupSpec.AnyWithProps> {}
+export interface AnyWithProps extends Spec<
+  RuntimeAndFunctionType.Runtime,
+  GroupSpec.AnyWithProps
+> {}
+
+export interface AnyWithPropsWithRuntime<
+  Runtime extends RuntimeAndFunctionType.Runtime,
+> extends Spec<Runtime, GroupSpec.AnyWithPropsWithRuntime<Runtime>> {}
 
 export type Groups<Spec_ extends AnyWithProps> =
   Spec_["groups"][keyof Spec_["groups"]];
@@ -35,18 +59,59 @@ const Proto = {
 
   add<Group extends GroupSpec.AnyWithProps>(this: AnyWithProps, group: Group) {
     return makeProto({
+      runtime: this.runtime,
       groups: Record.set(this.groups, group.name, group),
     });
   },
 };
 
-const makeProto = <Groups_ extends GroupSpec.AnyWithProps>({
+const makeProto = <
+  Runtime extends RuntimeAndFunctionType.Runtime,
+  Groups_ extends GroupSpec.AnyWithPropsWithRuntime<Runtime>,
+>({
+  runtime,
   groups,
 }: {
+  runtime: Runtime;
   groups: Record.ReadonlyRecord<string, Groups_>;
-}): Spec<Groups_> =>
+}): Spec<Runtime, Groups_> =>
   Object.assign(Object.create(Proto), {
+    runtime,
     groups,
   });
 
-export const make = (): Spec => makeProto({ 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 for use with `Api.make`.
+ * 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 nodeGroup = nodeSpec
+    ? Array.reduce(
+        Record.values(nodeSpec.groups),
+        GroupSpec.makeNode("node"),
+        (nodeGroupSpec, group) => nodeGroupSpec.addGroup(group),
+      )
+    : null;
+
+  const groups = nodeGroup
+    ? { ...convexSpec.groups, node: nodeGroup }
+    : convexSpec.groups;
+
+  return Object.assign(Object.create(Proto), {
+    runtime: "Convex" as const,
+    groups,
+  }) as AnyWithProps;
+};

package/src/index.ts

@@ -5,6 +5,7 @@ export * as GroupSpec from "./GroupSpec";
 export * as PaginationResult from "./PaginationResult";
 export * as Ref from "./Ref";
 export * as Refs from "./Refs";
+export * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";
 export * as Spec from "./Spec";
 export * as SystemFields from "./SystemFields";
 export * as Types from "./Types";