@confect/server 2.0.0 → 4.0.0

package/src/CronJobs.ts

@@ -0,0 +1,161 @@
+import { Ref } from "@confect/core";
+import type {
+  CronJob as ConvexCronJob,
+  SchedulableFunctionReference,
+} from "convex/server";
+import { cronJobs as makeConvexCrons, type Crons } from "convex/server";
+import {
+  Array,
+  Cron,
+  Duration,
+  Match,
+  Order,
+  pipe,
+  Predicate,
+  Record,
+  Schema,
+} from "effect";
+import type * as CronJob from "./CronJob";
+
+export const TypeId = "@confect/server/CronJobs";
+export type TypeId = typeof TypeId;
+
+export interface CronJobs {
+  readonly [TypeId]: TypeId;
+  readonly cronJobs: Record<string, CronJob.CronJob>;
+  readonly convexCronJobs: Crons;
+
+  add(cron: CronJob.CronJob): CronJobs;
+}
+
+export const isCronJobs = (u: unknown): u is CronJobs =>
+  Predicate.hasProperty(u, TypeId);
+
+const Proto = {
+  [TypeId]: TypeId,
+
+  add(this: CronJobs, cronJob: CronJob.CronJob) {
+    const newConvexCrons = Object.assign(makeConvexCrons(), {
+      crons: { ...this.convexCronJobs.crons },
+    });
+
+    const schedulableFunctionReference = Ref.getConvexFunctionName(
+      cronJob.ref,
+    ) as unknown as SchedulableFunctionReference;
+
+    const functionSpec = Ref.getFunctionSpec(cronJob.ref);
+    const encodedArgs = Match.value(functionSpec.functionProvenance).pipe(
+      Match.tag("Confect", (confect) =>
+        Schema.encodeSync(confect.args)(cronJob.args),
+      ),
+      Match.tag("Convex", () => cronJob.args),
+      Match.exhaustive,
+    );
+
+    Match.value(cronJob.schedule).pipe(
+      Match.when(Cron.isCron, (cron) => {
+        newConvexCrons.cron(
+          cronJob.identifier,
+          cronToConvexCronString(cron),
+          schedulableFunctionReference,
+          encodedArgs,
+        );
+      }),
+      Match.when(Duration.isDuration, (duration) => {
+        newConvexCrons.interval(
+          cronJob.identifier,
+          durationToConvexIntervalSchedule(duration),
+          schedulableFunctionReference,
+          encodedArgs,
+        );
+      }),
+      Match.exhaustive,
+    );
+
+    return makeProto(
+      Record.set(this.cronJobs, cronJob.identifier, cronJob),
+      newConvexCrons,
+    );
+  },
+};
+
+const makeProto = (
+  cronJobs: Record<string, CronJob.CronJob>,
+  convexCronJobs: Crons,
+): CronJobs =>
+  Object.assign(Object.create(Proto), {
+    cronJobs,
+    convexCronJobs,
+  });
+
+export const make = (): CronJobs => makeProto({}, makeConvexCrons());
+
+/** @internal */
+export const cronToConvexCronString = (cron: Cron.Cron): string => {
+  const hasNonDefaultSeconds = cron.seconds.size !== 1 || !cron.seconds.has(0);
+  if (hasNonDefaultSeconds) {
+    throw new Error(
+      "Convex cron expressions do not support a seconds field. " +
+        "The seconds field must be the default {0}. " +
+        "Sub-minute scheduling is supported only by interval schedules defined using a Duration.",
+    );
+  }
+
+  return Array.join(
+    [
+      setToField(cron.minutes),
+      setToField(cron.hours),
+      setToField(cron.days),
+      setToField(cron.months),
+      setToField(cron.weekdays),
+    ],
+    " ",
+  );
+};
+
+const setToField = (set: ReadonlySet<number>): string => {
+  if (set.size === 0) return "*";
+  return pipe(
+    set,
+    Array.sort(Order.number),
+    Array.map((n) => n.toString()),
+    Array.join(","),
+  );
+};
+
+/** @internal */
+export const durationToConvexIntervalSchedule = (
+  duration: Duration.Duration,
+): IntervalSchedule => {
+  const millis = Duration.toMillis(duration);
+  if (millis <= 0) {
+    throw new Error("Interval must be a positive duration.");
+  }
+
+  const oneHourInMillis = Duration.hours(1).pipe(Duration.toMillis);
+  const hours = millis / oneHourInMillis;
+  if (Number.isInteger(hours)) {
+    return { type: "interval", hours };
+  }
+
+  const oneMinuteInMillis = Duration.minutes(1).pipe(Duration.toMillis);
+  const minutes = millis / oneMinuteInMillis;
+  if (Number.isInteger(minutes)) {
+    return { type: "interval", minutes };
+  }
+
+  const oneSecondInMillis = Duration.seconds(1).pipe(Duration.toMillis);
+  const seconds = millis / oneSecondInMillis;
+  if (Number.isInteger(seconds)) {
+    return { type: "interval", seconds };
+  }
+
+  throw new Error(
+    "Interval must be a whole number of seconds, minutes, or hours.",
+  );
+};
+
+type IntervalSchedule = Extract<
+  ConvexCronJob["schedule"],
+  { type: "interval" }
+>;

package/src/FunctionImpl.ts

@@ -56,7 +56,7 @@ export const make = <
       currentGroup.groups[groupPathPart],
   );
 
-  const function_ = group_.functions[functionName]!;
+  const functionSpec = group_.functions[functionName]!;
 
   return Layer.effect(
     FunctionImpl<GroupPath_, FunctionName>({
@@ -71,8 +71,8 @@ export const make = <
           registryItems,
           [...groupPathParts, functionName],
           RegistryItem.make({
-            function_,
-            handler: handler as Handler.AnyWithProps,
+            functionSpec,
+            handler,
           }),
         ),
       );

package/src/Handler.ts

@@ -1,4 +1,5 @@
 import type { FunctionSpec, RuntimeAndFunctionType } from "@confect/core";
+import type * as FunctionProvenance from "@confect/core/FunctionProvenance";
 import type { NodeContext } from "@effect/platform-node";
 import type { Effect } from "effect";
 import type * as ActionCtx from "./ActionCtx";
@@ -12,38 +13,59 @@ import type * as MutationCtx from "./MutationCtx";
 import type * as MutationRunner from "./MutationRunner";
 import type * as QueryCtx from "./QueryCtx";
 import type * as QueryRunner from "./QueryRunner";
+import type * as RegisteredFunction from "./RegisteredFunction";
 import type * as Scheduler from "./Scheduler";
-import type {
-  StorageActionWriter,
-  StorageReader,
-  StorageWriter,
-} from "./Storage";
+import type { StorageActionWriter } from "./StorageActionWriter";
+import type { StorageReader } from "./StorageReader";
+import type { StorageWriter } from "./StorageWriter";
 import type * as VectorSearch from "./VectorSearch";
 
 export type Handler<
   DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
   FunctionSpec_ extends FunctionSpec.AnyWithProps,
+> =
+  FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<
+    FunctionSpec_,
+    FunctionProvenance.AnyConvex
+  >
+    ? ConvexProvenanceHandler<FunctionSpec_>
+    : FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<
+          FunctionSpec_,
+          FunctionProvenance.AnyConfect
+        >
+      ? ConfectProvenanceHandler<DatabaseSchema_, FunctionSpec_>
+      : never;
+
+type ConvexProvenanceHandler<
+  FunctionSpec_ extends
+    FunctionSpec.AnyWithPropsWithFunctionProvenance<FunctionProvenance.AnyConvex>,
+> = RegisteredFunction.ConvexRegisteredFunction<FunctionSpec_>;
+
+type ConfectProvenanceHandler<
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
+  FunctionSpec_ extends
+    FunctionSpec.AnyWithPropsWithFunctionProvenance<FunctionProvenance.AnyConfect>,
 > =
   FunctionSpec_ extends FunctionSpec.WithFunctionType<FunctionSpec_, "query">
-    ? Query<DatabaseSchema_, FunctionSpec_>
+    ? ConfectProvenanceQuery<DatabaseSchema_, FunctionSpec_>
     : FunctionSpec_ extends FunctionSpec.WithFunctionType<
           FunctionSpec_,
           "mutation"
         >
-      ? Mutation<DatabaseSchema_, FunctionSpec_>
+      ? ConfectProvenanceMutation<DatabaseSchema_, FunctionSpec_>
       : FunctionSpec_ extends FunctionSpec.WithRuntimeAndFunctionType<
             FunctionSpec_,
             RuntimeAndFunctionType.ConvexAction
           >
-        ? ConvexAction<DatabaseSchema_, FunctionSpec_>
+        ? ConvexRuntimeAction<DatabaseSchema_, FunctionSpec_>
         : FunctionSpec_ extends FunctionSpec.WithRuntimeAndFunctionType<
               FunctionSpec_,
               RuntimeAndFunctionType.NodeAction
             >
-          ? NodeAction<DatabaseSchema_, FunctionSpec_>
+          ? NodeRuntimeAction<DatabaseSchema_, FunctionSpec_>
           : never;
 
-export type Query<
+export type ConfectProvenanceQuery<
   DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
   FunctionSpec_ extends
     FunctionSpec.AnyWithPropsWithFunctionType<RuntimeAndFunctionType.AnyQuery>,
@@ -56,7 +78,7 @@ export type Query<
   | QueryCtx.QueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>>
 >;
 
-export type Mutation<
+export type ConfectProvenanceMutation<
   DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
   FunctionSpec_ extends
     FunctionSpec.AnyWithPropsWithFunctionType<RuntimeAndFunctionType.AnyMutation>,
@@ -89,13 +111,13 @@ type ActionServices<DatabaseSchema_ extends DatabaseSchema.AnyWithProps> =
       DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>
     >;
 
-export type ConvexAction<
+export type ConvexRuntimeAction<
   DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
   FunctionSpec_ extends
     FunctionSpec.AnyWithPropsWithFunctionType<RuntimeAndFunctionType.AnyAction>,
 > = Base<FunctionSpec_, ActionServices<DatabaseSchema_>>;
 
-export type NodeAction<
+export type NodeRuntimeAction<
   DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
   FunctionSpec_ extends
     FunctionSpec.AnyWithPropsWithFunctionType<RuntimeAndFunctionType.NodeAction>,
@@ -105,13 +127,14 @@ export type NodeAction<
 >;
 
 type Base<FunctionSpec_ extends FunctionSpec.AnyWithProps, R> = (
-  args: FunctionSpec.Args<FunctionSpec_>["Type"],
-) => Effect.Effect<FunctionSpec.Returns<FunctionSpec_>["Type"], never, R>;
+  args: FunctionSpec.Args<FunctionSpec_>,
+) => Effect.Effect<FunctionSpec.Returns<FunctionSpec_>, never, R>;
 
-export type AnyWithProps = Handler<
-  DatabaseSchema.AnyWithProps,
-  FunctionSpec.AnyWithProps
->;
+export type Any = AnyConfectProvenance | AnyConvexProvenance;
+
+export type AnyConfectProvenance = Base<FunctionSpec.AnyConfect, any>;
+
+export type AnyConvexProvenance = RegisteredFunction.Any;
 
 export type WithName<
   DatabaseSchema_ extends DatabaseSchema.AnyWithProps,

package/src/HttpApi.ts

@@ -23,7 +23,9 @@ import * as ConvexConfigProvider from "./ConvexConfigProvider";
 import * as MutationRunner from "./MutationRunner";
 import * as QueryRunner from "./QueryRunner";
 import * as Scheduler from "./Scheduler";
-import { StorageActionWriter, StorageReader, StorageWriter } from "./Storage";
+import { StorageActionWriter } from "./StorageActionWriter";
+import { StorageReader } from "./StorageReader";
+import { StorageWriter } from "./StorageWriter";
 
 type Middleware = (
   httpApp: HttpApp.Default,

package/src/MutationRunner.ts

@@ -1,32 +1,46 @@
 import * as Ref from "@confect/core/Ref";
 import { type GenericMutationCtx } from "convex/server";
 import type { ParseResult } from "effect";
-import { Context, Effect, Layer, Schema } from "effect";
+import { Context, Effect, Layer, Match, Schema } from "effect";
 
-const makeMutationRunner =
+const make =
   (runMutation: GenericMutationCtx<any>["runMutation"]) =>
   <Mutation extends Ref.AnyMutation>(
     mutation: Mutation,
-    args: Ref.Args<Mutation>["Type"],
-  ): Effect.Effect<Ref.Returns<Mutation>["Type"], ParseResult.ParseError> =>
+    args: Ref.Args<Mutation>,
+  ): Effect.Effect<Ref.Returns<Mutation>, ParseResult.ParseError> =>
     Effect.gen(function* () {
-      const function_ = Ref.getFunction(mutation);
+      const functionSpec = Ref.getFunctionSpec(mutation);
       const functionName = Ref.getConvexFunctionName(mutation);
 
-      const encodedArgs = yield* Schema.encode(function_.args)(args);
-      const encodedReturns = yield* Effect.promise(() =>
-        runMutation(functionName as any, encodedArgs),
+      return yield* Match.value(functionSpec.functionProvenance).pipe(
+        Match.tag("Confect", (confectFunctionSpec) =>
+          Effect.gen(function* () {
+            const encodedArgs = yield* Schema.encode(confectFunctionSpec.args)(
+              args,
+            );
+            const encodedReturns = yield* Effect.promise(() =>
+              runMutation(functionName as any, encodedArgs),
+            );
+            return yield* Schema.decode(confectFunctionSpec.returns)(
+              encodedReturns,
+            );
+          }),
+        ),
+        Match.tag("Convex", () =>
+          Effect.promise(() => runMutation(functionName as any, args as any)),
+        ),
+        Match.exhaustive,
       );
-      return yield* Schema.decode(function_.returns)(encodedReturns);
     });
 
-export const MutationRunner = Context.GenericTag<
-  ReturnType<typeof makeMutationRunner>
->("@confect/server/MutationRunner");
+export const MutationRunner = Context.GenericTag<ReturnType<typeof make>>(
+  "@confect/server/MutationRunner",
+);
 export type MutationRunner = typeof MutationRunner.Identifier;
 
 export const layer = (runMutation: GenericMutationCtx<any>["runMutation"]) =>
-  Layer.succeed(MutationRunner, makeMutationRunner(runMutation));
+  Layer.succeed(MutationRunner, make(runMutation));
 
 export class MutationRollback extends Schema.TaggedError<MutationRollback>()(
   "MutationRollback",

package/src/OrderedQuery.ts

@@ -1,4 +1,6 @@
 import type {
+  ExpressionOrValue,
+  FilterBuilder,
   OrderedQuery as ConvexOrderedQuery,
   PaginationResult,
 } from "convex/server";
@@ -28,10 +30,15 @@ export type OrderedQuery<
     TableInfo_["document"],
     Document.DocumentDecodeError
   >;
-  readonly paginate: (options: {
-    cursor: string | null;
-    numItems: number;
-  }) => Effect.Effect<
+  readonly paginate: (
+    options: {
+      cursor: string | null;
+      numItems: number;
+    },
+    filter?: (
+      q: FilterBuilder<TableInfo.ConvexTableInfo<TableInfo_>>,
+    ) => ExpressionOrValue<boolean>,
+  ) => Effect.Effect<
     PaginationResult<TableInfo_["document"]>,
     Document.DocumentDecodeError
   >;
@@ -73,10 +80,12 @@ export const make = <
   const collect: OrderedQueryFunction<"collect"> = () =>
     pipe(stream(), Stream.runCollect, Effect.map(Chunk.toReadonlyArray));
 
-  const paginate: OrderedQueryFunction<"paginate"> = (options) =>
+  const paginate: OrderedQueryFunction<"paginate"> = (options, filter) =>
     Effect.gen(function* () {
+      const filteredQuery = filter !== undefined ? query.filter(filter) : query;
+
       const paginationResult = yield* Effect.promise(() =>
-        query.paginate(options),
+        filteredQuery.paginate(options),
       );
 
       const parsedPage = yield* Effect.forEach(

package/src/QueryRunner.ts

@@ -1,23 +1,37 @@
 import * as Ref from "@confect/core/Ref";
 import { type GenericQueryCtx } from "convex/server";
 import type { ParseResult } from "effect";
-import { Context, Effect, Layer, Schema } from "effect";
+import { Context, Effect, Layer, Match, Schema } from "effect";
 
 const make =
   (runQuery: GenericQueryCtx<any>["runQuery"]) =>
   <Query extends Ref.AnyQuery>(
     query: Query,
-    args: Ref.Args<Query>["Type"],
-  ): Effect.Effect<Ref.Returns<Query>["Type"], ParseResult.ParseError> =>
+    args: Ref.Args<Query>,
+  ): Effect.Effect<Ref.Returns<Query>, ParseResult.ParseError> =>
     Effect.gen(function* () {
-      const function_ = Ref.getFunction(query);
+      const functionSpec = Ref.getFunctionSpec(query);
       const functionName = Ref.getConvexFunctionName(query);
 
-      const encodedArgs = yield* Schema.encode(function_.args)(args);
-      const encodedReturns = yield* Effect.promise(() =>
-        runQuery(functionName as any, encodedArgs),
+      return yield* Match.value(functionSpec.functionProvenance).pipe(
+        Match.tag("Confect", (confectFunctionSpec) =>
+          Effect.gen(function* () {
+            const encodedArgs = yield* Schema.encode(confectFunctionSpec.args)(
+              args,
+            );
+            const encodedReturns = yield* Effect.promise(() =>
+              runQuery(functionName as any, encodedArgs),
+            );
+            return yield* Schema.decode(confectFunctionSpec.returns)(
+              encodedReturns,
+            );
+          }),
+        ),
+        Match.tag("Convex", () =>
+          Effect.promise(() => runQuery(functionName as any, args as any)),
+        ),
+        Match.exhaustive,
       );
-      return yield* Schema.decode(function_.returns)(encodedReturns);
     });
 
 export const QueryRunner = Context.GenericTag<ReturnType<typeof make>>(

package/src/RegisteredConvexFunction.ts

@@ -1,3 +1,4 @@
+import type * as FunctionSpec from "@confect/core/FunctionSpec";
 import {
   actionGeneric,
   type DefaultFunctionArgs,
@@ -12,10 +13,12 @@ import {
 import { Effect, Layer, Match, pipe, Schema } from "effect";
 import type * as Api from "./Api";
 import * as Auth from "./Auth";
+import * as ConvexConfigProvider from "./ConvexConfigProvider";
 import * as DatabaseReader from "./DatabaseReader";
 import type * as DatabaseSchema from "./DatabaseSchema";
 import * as DatabaseWriter from "./DatabaseWriter";
 import type * as DataModel from "./DataModel";
+import type * as Handler from "./Handler";
 import * as MutationCtx from "./MutationCtx";
 import * as MutationRunner from "./MutationRunner";
 import * as QueryCtx from "./QueryCtx";
@@ -24,57 +27,66 @@ import * as RegisteredFunction from "./RegisteredFunction";
 import type * as RegistryItem from "./RegistryItem";
 import * as Scheduler from "./Scheduler";
 import * as SchemaToValidator from "./SchemaToValidator";
-import * as ConvexConfigProvider from "./ConvexConfigProvider";
-import { StorageReader, StorageWriter } from "./Storage";
+import { StorageReader } from "./StorageReader";
+import { StorageWriter } from "./StorageWriter";
 
 export const make = <Api_ extends Api.AnyWithPropsWithRuntime<"Convex">>(
   api: Api_,
-  { function_, handler }: RegistryItem.AnyWithProps,
-): RegisteredFunction.RegisteredFunction =>
-  Match.value(function_.runtimeAndFunctionType.functionType).pipe(
-    Match.when("query", () => {
-      const genericFunction = Match.value(function_.functionVisibility).pipe(
-        Match.when("public", () => queryGeneric),
-        Match.when("internal", () => internalQueryGeneric),
-        Match.exhaustive,
-      );
+  { functionSpec, handler }: RegistryItem.AnyWithProps,
+): RegisteredFunction.Any =>
+  Match.value(functionSpec.functionProvenance).pipe(
+    Match.tag("Convex", () => handler as RegisteredFunction.Any),
+    Match.tag("Confect", () => {
+      const { functionVisibility, functionProvenance } =
+        functionSpec as FunctionSpec.AnyConfect;
 
-      return genericFunction(
-        queryFunction(api.databaseSchema, {
-          args: function_.args,
-          returns: function_.returns,
-          handler,
+      return Match.value(functionSpec.runtimeAndFunctionType.functionType).pipe(
+        Match.when("query", () => {
+          const genericFunction = Match.value(functionVisibility).pipe(
+            Match.when("public", () => queryGeneric),
+            Match.when("internal", () => internalQueryGeneric),
+            Match.exhaustive,
+          );
+
+          return genericFunction(
+            queryFunction(api.databaseSchema, {
+              args: functionProvenance.args,
+              returns: functionProvenance.returns,
+              handler: handler as Handler.AnyConfectProvenance,
+            }),
+          );
         }),
-      );
-    }),
-    Match.when("mutation", () => {
-      const genericFunction = Match.value(function_.functionVisibility).pipe(
-        Match.when("public", () => mutationGeneric),
-        Match.when("internal", () => internalMutationGeneric),
-        Match.exhaustive,
-      );
+        Match.when("mutation", () => {
+          const genericFunction = Match.value(functionVisibility).pipe(
+            Match.when("public", () => mutationGeneric),
+            Match.when("internal", () => internalMutationGeneric),
+            Match.exhaustive,
+          );
 
-      return genericFunction(
-        mutationFunction(api.databaseSchema, {
-          args: function_.args,
-          returns: function_.returns,
-          handler,
+          return genericFunction(
+            mutationFunction(api.databaseSchema, {
+              args: functionProvenance.args,
+              returns: functionProvenance.returns,
+              handler: handler as Handler.AnyConfectProvenance,
+            }),
+          );
         }),
-      );
-    }),
-    Match.when("action", () => {
-      const genericFunction = Match.value(function_.functionVisibility).pipe(
-        Match.when("public", () => actionGeneric),
-        Match.when("internal", () => internalActionGeneric),
-        Match.exhaustive,
-      );
+        Match.when("action", () => {
+          const genericFunction = Match.value(functionVisibility).pipe(
+            Match.when("public", () => actionGeneric),
+            Match.when("internal", () => internalActionGeneric),
+            Match.exhaustive,
+          );
 
-      return genericFunction(
-        convexActionFunction(api.databaseSchema, {
-          args: function_.args,
-          returns: function_.returns,
-          handler,
+          return genericFunction(
+            convexActionFunction(api.databaseSchema, {
+              args: functionProvenance.args,
+              returns: functionProvenance.returns,
+              handler: handler as Handler.AnyConfectProvenance,
+            }),
+          );
         }),
+        Match.exhaustive,
       );
     }),
     Match.exhaustive,