@confect/server 1.0.0-next.3 → 1.0.0

package/src/RegisteredFunctions.ts

@@ -1,48 +1,14 @@
 import type * as FunctionSpec from "@confect/core/FunctionSpec";
 import type * as GroupSpec from "@confect/core/GroupSpec";
 import type * as Spec from "@confect/core/Spec";
-import {
-  actionGeneric,
-  type DefaultFunctionArgs,
-  type FunctionVisibility,
-  type GenericActionCtx,
-  type GenericMutationCtx,
-  type GenericQueryCtx,
-  internalActionGeneric,
-  internalMutationGeneric,
-  internalQueryGeneric,
-  mutationGeneric,
-  queryGeneric,
-  type RegisteredAction,
-  type RegisteredMutation,
-  type RegisteredQuery,
-} from "convex/server";
-import { Effect, Layer, Match, pipe, Ref, Schema, type Types } from "effect";
-import * as ActionCtx from "./ActionCtx";
-import * as ActionRunner from "./ActionRunner";
+import type { Layer } from "effect";
+import { Effect, Match, Ref, type Types } from "effect";
 import type * as Api from "./Api";
-import * as Auth from "./Auth";
-import * as DatabaseReader from "./DatabaseReader";
-import type * as DatabaseSchema from "./DatabaseSchema";
-import * as DatabaseWriter from "./DatabaseWriter";
-import type * as DataModel from "./DataModel";
 import * as Impl from "./Impl";
 import { mapLeaves } from "./internal/utils";
-import * as MutationCtx from "./MutationCtx";
-import * as MutationRunner from "./MutationRunner";
-import * as QueryCtx from "./QueryCtx";
-import * as QueryRunner from "./QueryRunner";
+import type * as RegisteredFunction from "./RegisteredFunction";
 import * as Registry from "./Registry";
 import * as RegistryItem from "./RegistryItem";
-import * as Scheduler from "./Scheduler";
-import * as SchemaToValidator from "./SchemaToValidator";
-import { StorageActionWriter, StorageReader, StorageWriter } from "./Storage";
-import * as VectorSearch from "./VectorSearch";
-
-export type RegisteredFunction =
-  | RegisteredQuery<FunctionVisibility, DefaultFunctionArgs, any>
-  | RegisteredMutation<FunctionVisibility, DefaultFunctionArgs, any>
-  | RegisteredAction<FunctionVisibility, DefaultFunctionArgs, any>;
 
 export type RegisteredFunctions<Spec_ extends Spec.AnyWithProps> =
   Types.Simplify<RegisteredFunctionsHelper<Spec.Groups<Spec_>>>;
@@ -80,11 +46,15 @@ type RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = {
 };
 
 export interface AnyWithProps {
-  readonly [key: string]: RegisteredFunction | AnyWithProps;
+  readonly [key: string]: RegisteredFunction.RegisteredFunction | AnyWithProps;
 }
 
 export const make = <Api_ extends Api.AnyWithProps>(
   impl: Layer.Layer<Impl.Impl<Api_, "Finalized">>,
+  makeRegisteredFunction: (
+    api: Api_,
+    registryItem: RegistryItem.AnyWithProps,
+  ) => RegisteredFunction.RegisteredFunction,
 ) =>
   Effect.gen(function* () {
     const registry = yield* Registry.Registry;
@@ -100,274 +70,14 @@ export const make = <Api_ extends Api.AnyWithProps>(
       ),
       Match.when("Finalized", () =>
         Effect.succeed(
-          mapLeaves<RegistryItem.AnyWithProps, RegisteredFunction>(
-            functionImplItems,
-            RegistryItem.isRegistryItem,
-            (registryItem) => makeRegisteredFunction(api, registryItem),
+          mapLeaves<
+            RegistryItem.AnyWithProps,
+            RegisteredFunction.RegisteredFunction
+          >(functionImplItems, RegistryItem.isRegistryItem, (registryItem) =>
+            makeRegisteredFunction(api, registryItem),
           ) as RegisteredFunctions<Api_["spec"]>,
         ),
       ),
       Match.exhaustive,
     );
   }).pipe(Effect.provide(impl), Effect.runSync);
-
-const makeRegisteredFunction = <Api_ extends Api.AnyWithProps>(
-  api: Api_,
-  { function_, handler }: RegistryItem.AnyWithProps,
-): RegisteredFunction =>
-  Match.value(function_.functionType).pipe(
-    Match.when("query", () => {
-      const genericFunction = Match.value(function_.functionVisibility).pipe(
-        Match.when("public", () => queryGeneric),
-        Match.when("internal", () => internalQueryGeneric),
-        Match.exhaustive,
-      );
-
-      return genericFunction(
-        queryFunction(api.databaseSchema, {
-          args: function_.args,
-          returns: function_.returns,
-          handler,
-        }),
-      );
-    }),
-    Match.when("mutation", () => {
-      const genericFunction = Match.value(function_.functionVisibility).pipe(
-        Match.when("public", () => mutationGeneric),
-        Match.when("internal", () => internalMutationGeneric),
-        Match.exhaustive,
-      );
-
-      return genericFunction(
-        mutationFunction(api.databaseSchema, {
-          args: function_.args,
-          returns: function_.returns,
-          handler,
-        }),
-      );
-    }),
-    Match.when("action", () => {
-      const genericFunction = Match.value(function_.functionVisibility).pipe(
-        Match.when("public", () => actionGeneric),
-        Match.when("internal", () => internalActionGeneric),
-        Match.exhaustive,
-      );
-
-      return genericFunction(
-        actionFunction({
-          args: function_.args,
-          returns: function_.returns,
-          handler,
-        }),
-      );
-    }),
-    Match.exhaustive,
-  );
-
-const queryFunction = <
-  Schema extends DatabaseSchema.AnyWithProps,
-  Args,
-  ConvexArgs extends DefaultFunctionArgs,
-  Returns,
-  ConvexReturns,
-  E,
->(
-  schema: Schema,
-  {
-    args,
-    returns,
-    handler,
-  }: {
-    args: Schema.Schema<Args, ConvexArgs>;
-    returns: Schema.Schema<Returns, ConvexReturns>;
-    handler: (
-      a: Args,
-    ) => Effect.Effect<
-      Returns,
-      E,
-      | DatabaseReader.DatabaseReader<Schema>
-      | Auth.Auth
-      | StorageReader
-      | QueryRunner.QueryRunner
-      | QueryCtx.QueryCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>
-    >;
-  },
-) => ({
-  args: SchemaToValidator.compileArgsSchema(args),
-  returns: SchemaToValidator.compileReturnsSchema(returns),
-  handler: (
-    ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,
-    actualArgs: ConvexArgs,
-  ): Promise<ConvexReturns> =>
-    pipe(
-      actualArgs,
-      Schema.decode(args),
-      Effect.orDie,
-      Effect.andThen((decodedArgs) =>
-        pipe(
-          handler(decodedArgs),
-          Effect.provide(
-            Layer.mergeAll(
-              DatabaseReader.layer(schema, ctx.db),
-              Auth.layer(ctx.auth),
-              StorageReader.layer(ctx.storage),
-              QueryRunner.layer(ctx.runQuery),
-              Layer.succeed(
-                QueryCtx.QueryCtx<
-                  DataModel.ToConvex<DataModel.FromSchema<Schema>>
-                >(),
-                ctx,
-              ),
-            ),
-          ),
-        ),
-      ),
-      Effect.andThen((convexReturns) =>
-        Schema.encodeUnknown(returns)(convexReturns),
-      ),
-      Effect.runPromise,
-    ),
-});
-
-export const mutationLayer = <Schema extends DatabaseSchema.AnyWithProps>(
-  schema: Schema,
-  ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,
-) =>
-  Layer.mergeAll(
-    DatabaseReader.layer(schema, ctx.db),
-    DatabaseWriter.layer(schema, ctx.db),
-    Auth.layer(ctx.auth),
-    Scheduler.layer(ctx.scheduler),
-    StorageReader.layer(ctx.storage),
-    StorageWriter.layer(ctx.storage),
-    QueryRunner.layer(ctx.runQuery),
-    MutationRunner.layer(ctx.runMutation),
-    Layer.succeed(
-      MutationCtx.MutationCtx<
-        DataModel.ToConvex<DataModel.FromSchema<Schema>>
-      >(),
-      ctx,
-    ),
-  );
-
-export type MutationServices<Schema extends DatabaseSchema.AnyWithProps> =
-  | DatabaseReader.DatabaseReader<Schema>
-  | DatabaseWriter.DatabaseWriter<Schema>
-  | Auth.Auth
-  | Scheduler.Scheduler
-  | StorageReader
-  | StorageWriter
-  | QueryRunner.QueryRunner
-  | MutationRunner.MutationRunner
-  | MutationCtx.MutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>;
-
-const mutationFunction = <
-  Schema extends DatabaseSchema.AnyWithProps,
-  Args,
-  ConvexArgs extends DefaultFunctionArgs,
-  Returns,
-  ConvexReturns,
-  E,
->(
-  schema: Schema,
-  {
-    args,
-    returns,
-    handler,
-  }: {
-    args: Schema.Schema<Args, ConvexArgs>;
-    returns: Schema.Schema<Returns, ConvexReturns>;
-    handler: (a: Args) => Effect.Effect<Returns, E, MutationServices<Schema>>;
-  },
-) => ({
-  args: SchemaToValidator.compileArgsSchema(args),
-  returns: SchemaToValidator.compileReturnsSchema(returns),
-  handler: (
-    ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,
-    actualArgs: ConvexArgs,
-  ): Promise<ConvexReturns> =>
-    pipe(
-      actualArgs,
-      Schema.decode(args),
-      Effect.orDie,
-      Effect.andThen((decodedArgs) =>
-        handler(decodedArgs).pipe(Effect.provide(mutationLayer(schema, ctx))),
-      ),
-      Effect.andThen((convexReturns) =>
-        Schema.encodeUnknown(returns)(convexReturns),
-      ),
-      Effect.runPromise,
-    ),
-});
-
-const actionFunction = <
-  Schema extends DatabaseSchema.AnyWithProps,
-  Args,
-  ConvexArgs extends DefaultFunctionArgs,
-  Returns,
-  ConvexReturns,
-  E,
->({
-  args,
-  returns,
-  handler,
-}: {
-  args: Schema.Schema<Args, ConvexArgs>;
-  returns: Schema.Schema<Returns, ConvexReturns>;
-  handler: (
-    a: Args,
-  ) => Effect.Effect<
-    Returns,
-    E,
-    | Scheduler.Scheduler
-    | Auth.Auth
-    | StorageReader
-    | StorageWriter
-    | StorageActionWriter
-    | QueryRunner.QueryRunner
-    | MutationRunner.MutationRunner
-    | ActionRunner.ActionRunner
-    | VectorSearch.VectorSearch<DataModel.FromSchema<Schema>>
-    | ActionCtx.ActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>
-  >;
-}) => ({
-  args: SchemaToValidator.compileArgsSchema(args),
-  returns: SchemaToValidator.compileReturnsSchema(returns),
-  handler: (
-    ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,
-    actualArgs: ConvexArgs,
-  ): Promise<ConvexReturns> =>
-    pipe(
-      actualArgs,
-      Schema.decode(args),
-      Effect.orDie,
-      Effect.andThen((decodedArgs) =>
-        pipe(
-          handler(decodedArgs),
-          Effect.provide(
-            Layer.mergeAll(
-              Scheduler.layer(ctx.scheduler),
-              Auth.layer(ctx.auth),
-              StorageReader.layer(ctx.storage),
-              StorageWriter.layer(ctx.storage),
-              StorageActionWriter.layer(ctx.storage),
-              QueryRunner.layer(ctx.runQuery),
-              MutationRunner.layer(ctx.runMutation),
-              ActionRunner.layer(ctx.runAction),
-              VectorSearch.layer(ctx.vectorSearch),
-              Layer.succeed(
-                ActionCtx.ActionCtx<
-                  DataModel.ToConvex<DataModel.FromSchema<Schema>>
-                >(),
-                ctx,
-              ),
-            ),
-          ),
-        ),
-      ),
-      Effect.andThen((convexReturns) =>
-        Schema.encodeUnknown(returns)(convexReturns),
-      ),
-      Effect.runPromise,
-    ),
-});

package/src/RegisteredNodeFunction.ts

@@ -0,0 +1,68 @@
+import { NodeContext } from "@effect/platform-node";
+import {
+  actionGeneric,
+  type DefaultFunctionArgs,
+  internalActionGeneric,
+} 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 * as RegisteredFunction from "./RegisteredFunction";
+import type * as RegistryItem from "./RegistryItem";
+
+export const make = <Api_ extends Api.AnyWithPropsWithRuntime<"Node">>(
+  api: Api_,
+  { function_, handler }: RegistryItem.AnyWithProps,
+): RegisteredFunction.RegisteredFunction => {
+  const genericFunction = Match.value(function_.functionVisibility).pipe(
+    Match.when("public", () => actionGeneric),
+    Match.when("internal", () => internalActionGeneric),
+    Match.exhaustive,
+  );
+
+  return genericFunction(
+    nodeActionFunction(api.databaseSchema, {
+      args: function_.args,
+      returns: function_.returns,
+      handler,
+    }),
+  );
+};
+
+const nodeActionFunction = <
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
+  Args,
+  ConvexArgs extends DefaultFunctionArgs,
+  Returns,
+  ConvexReturns,
+  E,
+>(
+  databaseSchema: DatabaseSchema_,
+  {
+    args,
+    returns,
+    handler,
+  }: {
+    args: Schema.Schema<Args, ConvexArgs>;
+    returns: Schema.Schema<Returns, ConvexReturns>;
+    handler: (
+      a: Args,
+    ) => Effect.Effect<
+      Returns,
+      E,
+      | RegisteredFunction.ActionServices<DatabaseSchema_>
+      | NodeContext.NodeContext
+    >;
+  },
+) =>
+  RegisteredFunction.actionFunctionBase({
+    args,
+    returns,
+    handler,
+    createLayer: (ctx) =>
+      Layer.mergeAll(
+        RegisteredFunction.actionLayer(databaseSchema, ctx),
+        NodeContext.layer,
+      ),
+  });

package/src/index.ts

@@ -18,6 +18,8 @@ export * as OrderedQuery from "./OrderedQuery";
 export * as QueryCtx from "./QueryCtx";
 export * as QueryInitializer from "./QueryInitializer";
 export * as QueryRunner from "./QueryRunner";
+export * as RegisteredConvexFunction from "./RegisteredConvexFunction";
+export * as RegisteredFunction from "./RegisteredFunction";
 export * as RegisteredFunctions from "./RegisteredFunctions";
 export * as Registry from "./Registry";
 export * as RegistryItem from "./RegistryItem";

package/src/node.ts

@@ -0,0 +1 @@
+export * as RegisteredNodeFunction from "./RegisteredNodeFunction";