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

package/dist/RegisteredConvexFunction.d.ts

@@ -0,0 +1,359 @@
+import { type DefaultFunctionArgs, type FunctionVisibility, type GenericMutationCtx, type GenericQueryCtx } from "convex/server";
+import type { Value } from "convex/values";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+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 ExecutionMetadata from "./ExecutionMetadata";
+import * as RequestMetadata from "./RequestMetadata";
+import * as TransactionMetadata from "./TransactionMetadata";
+import * as MutationCtx from "./MutationCtx";
+import * as MutationRunner from "./MutationRunner";
+import * as MutationTransactionContext from "./MutationTransactionContext";
+import * as QueryRunner from "./QueryRunner";
+import * as QueryTransactionContext from "./QueryTransactionContext";
+import * as RegisteredFunction from "./RegisteredFunction";
+import type * as FunctionRegistryItem from "./FunctionRegistryItem";
+import type * as ResolvedMiddleware from "./ResolvedMiddleware";
+import * as Scheduler from "./Scheduler";
+import type * as Handler from "./Handler";
+export type Definition = Data.TaggedEnum<{
+    PublicQuery: ReturnType<typeof queryFunction>;
+    InternalQuery: ReturnType<typeof queryFunction>;
+    PublicMutation: ReturnType<typeof mutationFunction>;
+    InternalMutation: ReturnType<typeof mutationFunction>;
+    PublicAction: ReturnType<typeof convexActionFunction>;
+    InternalAction: ReturnType<typeof convexActionFunction>;
+    Registered: {
+        readonly handler: RegisteredFunction.Any;
+    };
+}>;
+export declare const Definition: {
+    readonly $is: <Tag extends "InternalAction" | "InternalMutation" | "InternalQuery" | "PublicAction" | "PublicMutation" | "PublicQuery" | "Registered">(tag: Tag) => (u: unknown) => u is Extract<{
+        readonly _tag: "InternalAction";
+        readonly args: import("convex/values").PropertyValidators;
+        readonly returns: import("convex/values").Validator<any, any, any>;
+        readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+    }, {
+        readonly _tag: Tag;
+    }> | Extract<{
+        readonly _tag: "InternalMutation";
+        readonly args: import("convex/values").PropertyValidators;
+        readonly returns: import("convex/values").Validator<any, any, any>;
+        readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+    }, {
+        readonly _tag: Tag;
+    }> | Extract<{
+        readonly _tag: "InternalQuery";
+        readonly args: import("convex/values").PropertyValidators;
+        readonly returns: import("convex/values").Validator<any, any, any>;
+        readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+    }, {
+        readonly _tag: Tag;
+    }> | Extract<{
+        readonly _tag: "PublicAction";
+        readonly args: import("convex/values").PropertyValidators;
+        readonly returns: import("convex/values").Validator<any, any, any>;
+        readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+    }, {
+        readonly _tag: Tag;
+    }> | Extract<{
+        readonly _tag: "PublicMutation";
+        readonly args: import("convex/values").PropertyValidators;
+        readonly returns: import("convex/values").Validator<any, any, any>;
+        readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+    }, {
+        readonly _tag: Tag;
+    }> | Extract<{
+        readonly _tag: "PublicQuery";
+        readonly args: import("convex/values").PropertyValidators;
+        readonly returns: import("convex/values").Validator<any, any, any>;
+        readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+    }, {
+        readonly _tag: Tag;
+    }> | Extract<{
+        readonly _tag: "Registered";
+        readonly handler: RegisteredFunction.Any;
+    }, {
+        readonly _tag: Tag;
+    }>;
+    readonly $match: {
+        <Cases extends { readonly [Tag in "InternalAction" | "InternalMutation" | "InternalQuery" | "PublicAction" | "PublicMutation" | "PublicQuery" | "Registered"]: (args: Extract<{
+            readonly _tag: "InternalAction";
+            readonly args: import("convex/values").PropertyValidators;
+            readonly returns: import("convex/values").Validator<any, any, any>;
+            readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+        } | {
+            readonly _tag: "InternalMutation";
+            readonly args: import("convex/values").PropertyValidators;
+            readonly returns: import("convex/values").Validator<any, any, any>;
+            readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+        } | {
+            readonly _tag: "InternalQuery";
+            readonly args: import("convex/values").PropertyValidators;
+            readonly returns: import("convex/values").Validator<any, any, any>;
+            readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+        } | {
+            readonly _tag: "PublicAction";
+            readonly args: import("convex/values").PropertyValidators;
+            readonly returns: import("convex/values").Validator<any, any, any>;
+            readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+        } | {
+            readonly _tag: "PublicMutation";
+            readonly args: import("convex/values").PropertyValidators;
+            readonly returns: import("convex/values").Validator<any, any, any>;
+            readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+        } | {
+            readonly _tag: "PublicQuery";
+            readonly args: import("convex/values").PropertyValidators;
+            readonly returns: import("convex/values").Validator<any, any, any>;
+            readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+        } | {
+            readonly _tag: "Registered";
+            readonly handler: RegisteredFunction.Any;
+        }, {
+            readonly _tag: Tag;
+        }>) => any; }>(cases: Cases): (value: {
+            readonly _tag: "InternalAction";
+            readonly args: import("convex/values").PropertyValidators;
+            readonly returns: import("convex/values").Validator<any, any, any>;
+            readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+        } | {
+            readonly _tag: "InternalMutation";
+            readonly args: import("convex/values").PropertyValidators;
+            readonly returns: import("convex/values").Validator<any, any, any>;
+            readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+        } | {
+            readonly _tag: "InternalQuery";
+            readonly args: import("convex/values").PropertyValidators;
+            readonly returns: import("convex/values").Validator<any, any, any>;
+            readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+        } | {
+            readonly _tag: "PublicAction";
+            readonly args: import("convex/values").PropertyValidators;
+            readonly returns: import("convex/values").Validator<any, any, any>;
+            readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+        } | {
+            readonly _tag: "PublicMutation";
+            readonly args: import("convex/values").PropertyValidators;
+            readonly returns: import("convex/values").Validator<any, any, any>;
+            readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+        } | {
+            readonly _tag: "PublicQuery";
+            readonly args: import("convex/values").PropertyValidators;
+            readonly returns: import("convex/values").Validator<any, any, any>;
+            readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+        } | {
+            readonly _tag: "Registered";
+            readonly handler: RegisteredFunction.Any;
+        }) => import("effect/Unify").Unify<ReturnType<Cases["InternalAction" | "InternalMutation" | "InternalQuery" | "PublicAction" | "PublicMutation" | "PublicQuery" | "Registered"]>>;
+        <Cases extends { readonly [Tag in "InternalAction" | "InternalMutation" | "InternalQuery" | "PublicAction" | "PublicMutation" | "PublicQuery" | "Registered"]: (args: Extract<{
+            readonly _tag: "InternalAction";
+            readonly args: import("convex/values").PropertyValidators;
+            readonly returns: import("convex/values").Validator<any, any, any>;
+            readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+        } | {
+            readonly _tag: "InternalMutation";
+            readonly args: import("convex/values").PropertyValidators;
+            readonly returns: import("convex/values").Validator<any, any, any>;
+            readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+        } | {
+            readonly _tag: "InternalQuery";
+            readonly args: import("convex/values").PropertyValidators;
+            readonly returns: import("convex/values").Validator<any, any, any>;
+            readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+        } | {
+            readonly _tag: "PublicAction";
+            readonly args: import("convex/values").PropertyValidators;
+            readonly returns: import("convex/values").Validator<any, any, any>;
+            readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+        } | {
+            readonly _tag: "PublicMutation";
+            readonly args: import("convex/values").PropertyValidators;
+            readonly returns: import("convex/values").Validator<any, any, any>;
+            readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+        } | {
+            readonly _tag: "PublicQuery";
+            readonly args: import("convex/values").PropertyValidators;
+            readonly returns: import("convex/values").Validator<any, any, any>;
+            readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+        } | {
+            readonly _tag: "Registered";
+            readonly handler: RegisteredFunction.Any;
+        }, {
+            readonly _tag: Tag;
+        }>) => any; }>(value: {
+            readonly _tag: "InternalAction";
+            readonly args: import("convex/values").PropertyValidators;
+            readonly returns: import("convex/values").Validator<any, any, any>;
+            readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+        } | {
+            readonly _tag: "InternalMutation";
+            readonly args: import("convex/values").PropertyValidators;
+            readonly returns: import("convex/values").Validator<any, any, any>;
+            readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+        } | {
+            readonly _tag: "InternalQuery";
+            readonly args: import("convex/values").PropertyValidators;
+            readonly returns: import("convex/values").Validator<any, any, any>;
+            readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+        } | {
+            readonly _tag: "PublicAction";
+            readonly args: import("convex/values").PropertyValidators;
+            readonly returns: import("convex/values").Validator<any, any, any>;
+            readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+        } | {
+            readonly _tag: "PublicMutation";
+            readonly args: import("convex/values").PropertyValidators;
+            readonly returns: import("convex/values").Validator<any, any, any>;
+            readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+        } | {
+            readonly _tag: "PublicQuery";
+            readonly args: import("convex/values").PropertyValidators;
+            readonly returns: import("convex/values").Validator<any, any, any>;
+            readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+        } | {
+            readonly _tag: "Registered";
+            readonly handler: RegisteredFunction.Any;
+        }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["InternalAction" | "InternalMutation" | "InternalQuery" | "PublicAction" | "PublicMutation" | "PublicQuery" | "Registered"]>>;
+    };
+    readonly InternalAction: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "InternalAction";
+        readonly args: import("convex/values").PropertyValidators;
+        readonly returns: import("convex/values").Validator<any, any, any>;
+        readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+    }, "_tag">;
+    readonly InternalMutation: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "InternalMutation";
+        readonly args: import("convex/values").PropertyValidators;
+        readonly returns: import("convex/values").Validator<any, any, any>;
+        readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+    }, "_tag">;
+    readonly InternalQuery: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "InternalQuery";
+        readonly args: import("convex/values").PropertyValidators;
+        readonly returns: import("convex/values").Validator<any, any, any>;
+        readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+    }, "_tag">;
+    readonly PublicAction: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "PublicAction";
+        readonly args: import("convex/values").PropertyValidators;
+        readonly returns: import("convex/values").Validator<any, any, any>;
+        readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+    }, "_tag">;
+    readonly PublicMutation: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "PublicMutation";
+        readonly args: import("convex/values").PropertyValidators;
+        readonly returns: import("convex/values").Validator<any, any, any>;
+        readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+    }, "_tag">;
+    readonly PublicQuery: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "PublicQuery";
+        readonly args: import("convex/values").PropertyValidators;
+        readonly returns: import("convex/values").Validator<any, any, any>;
+        readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+    }, "_tag">;
+    readonly Registered: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Registered";
+        readonly handler: RegisteredFunction.Any;
+    }, "_tag">;
+};
+export declare const prepare: (databaseSchema: DatabaseSchema.AnyWithProps, item: FunctionRegistryItem.ConfectFunctionRegistryItem, resolvedMiddlewares?: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>) => {
+    readonly _tag: "InternalAction";
+    readonly args: import("convex/values").PropertyValidators;
+    readonly returns: import("convex/values").Validator<any, any, any>;
+    readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+} | {
+    readonly _tag: "InternalMutation";
+    readonly args: import("convex/values").PropertyValidators;
+    readonly returns: import("convex/values").Validator<any, any, any>;
+    readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+} | {
+    readonly _tag: "InternalQuery";
+    readonly args: import("convex/values").PropertyValidators;
+    readonly returns: import("convex/values").Validator<any, any, any>;
+    readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+} | {
+    readonly _tag: "PublicAction";
+    readonly args: import("convex/values").PropertyValidators;
+    readonly returns: import("convex/values").Validator<any, any, any>;
+    readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+} | {
+    readonly _tag: "PublicMutation";
+    readonly args: import("convex/values").PropertyValidators;
+    readonly returns: import("convex/values").Validator<any, any, any>;
+    readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+} | {
+    readonly _tag: "PublicQuery";
+    readonly args: import("convex/values").PropertyValidators;
+    readonly returns: import("convex/values").Validator<any, any, any>;
+    readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
+};
+export declare const make: (databaseSchema: DatabaseSchema.AnyWithProps, item: FunctionRegistryItem.ConfectFunctionRegistryItem, resolvedMiddlewares?: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>) => RegisteredFunction.Any;
+export declare const register: (self: Definition) => RegisteredFunction.Any;
+declare const queryFunction: <DatabaseSchema_ extends DatabaseSchema.AnyWithProps, Args, ConvexArgs extends DefaultFunctionArgs, Returns, ConvexReturns, E>({ databaseSchema, name, functionVisibility, args, returns, error, handler, resolvedMiddlewares, }: {
+    databaseSchema: DatabaseSchema_;
+    name: string;
+    functionVisibility: FunctionVisibility;
+    args: Schema.Codec<Args, ConvexArgs>;
+    returns: Schema.Codec<Returns, ConvexReturns>;
+    error: Schema.Codec<Error, Value> | undefined;
+    handler: (a: Args) => Effect.Effect<Returns, E, Handler.QueryServices<DatabaseSchema_>>;
+    resolvedMiddlewares: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>;
+}) => {
+    args: import("convex/values").PropertyValidators;
+    returns: import("convex/values").Validator<any, any, any>;
+    handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>>, actualArgs: ConvexArgs) => Promise<ConvexReturns>;
+};
+export declare const mutationLayer: <Schema extends DatabaseSchema.AnyWithProps>(schema: Schema, ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>) => Layer.Layer<DatabaseReader.DatabaseReaderService<Schema, {}> | DatabaseWriter.DatabaseWriterService<Schema, {}> | ExecutionMetadata.ExecutionMetadata | MutationTransactionContext.MutationTransactionContext | QueryTransactionContext.QueryTransactionContext | RequestMetadata.RequestMetadata | import("./Storage").Storage | TransactionMetadata.TransactionMetadata | {
+    runMutation: {
+        <Mutation extends import("@confect/core/Ref").AnyMutation>(mutation: Mutation, ...args: [...import("@confect/core/Ref").OptionalArgs<Mutation>, options?: undefined]): Effect.Effect<import("@confect/core/Ref").Returns<Mutation>, import("@confect/core/Ref").Error<Mutation> | Schema.SchemaError>;
+        <Mutation extends import("@confect/core/Ref").AnyMutation>(mutation: Mutation, args: import("@confect/core/Ref").Args<Mutation>, options: MutationRunner.Options | undefined): Effect.Effect<import("@confect/core/Ref").Returns<Mutation>, import("@confect/core/Ref").Error<Mutation> | Schema.SchemaError, MutationTransactionContext.MutationTransactionContext>;
+    };
+} | {
+    runQuery: {
+        <Query extends import("@confect/core/Ref").AnyQuery>(query: Query, ...args: [...import("@confect/core/Ref").OptionalArgs<Query>, options?: undefined]): Effect.Effect<import("@confect/core/Ref").Returns<Query>, import("@confect/core/Ref").Error<Query> | Schema.SchemaError>;
+        <Query extends import("@confect/core/Ref").AnyQuery>(query: Query, args: import("@confect/core/Ref").Args<Query>, options: (QueryTransactionContext.Options & {
+            readonly useStaleSnapshot?: never;
+        }) | undefined): Effect.Effect<import("@confect/core/Ref").Returns<Query>, import("@confect/core/Ref").Error<Query> | Schema.SchemaError, QueryTransactionContext.QueryTransactionContext>;
+        <Query extends import("@confect/core/Ref").AnyQuery>(query: Query, args: import("@confect/core/Ref").Args<Query>, options: QueryRunner.Options & {
+            readonly useStaleSnapshot: boolean;
+        }): Effect.Effect<import("@confect/core/Ref").Returns<Query>, import("@confect/core/Ref").Error<Query> | Schema.SchemaError, MutationTransactionContext.MutationTransactionContext>;
+        <Query extends import("@confect/core/Ref").AnyQuery>(query: Query, args: import("@confect/core/Ref").Args<Query>, options: QueryRunner.Options | undefined): Effect.Effect<import("@confect/core/Ref").Returns<Query>, import("@confect/core/Ref").Error<Query> | Schema.SchemaError, QueryTransactionContext.QueryTransactionContext | MutationTransactionContext.MutationTransactionContext>;
+    };
+} | Scheduler.ForScope<DatabaseSchema.Scope<Schema>> | import("./StorageReader").ForScope<DatabaseSchema.Scope<Schema>> | import("./StorageWriter").ForScope<DatabaseSchema.Scope<Schema>> | Auth.ForTarget<Schema["target"]> | MutationCtx.MutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>, DatabaseSchema.Scope<Schema>>, never, never>;
+export type MutationServices<Schema extends DatabaseSchema.AnyWithProps> = Handler.MutationServices<Schema>;
+declare const mutationFunction: <DatabaseSchema_ extends DatabaseSchema.AnyWithProps, Args, ConvexArgs extends DefaultFunctionArgs, Returns, ConvexReturns, E>({ databaseSchema, name, functionVisibility, args, returns, error, handler, resolvedMiddlewares, }: {
+    databaseSchema: DatabaseSchema_;
+    name: string;
+    functionVisibility: FunctionVisibility;
+    args: Schema.Codec<Args, ConvexArgs>;
+    returns: Schema.Codec<Returns, ConvexReturns>;
+    error: Schema.Codec<Error, Value> | undefined;
+    handler: (a: Args) => Effect.Effect<Returns, E, MutationServices<DatabaseSchema_>>;
+    resolvedMiddlewares: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>;
+}) => {
+    args: import("convex/values").PropertyValidators;
+    returns: import("convex/values").Validator<any, any, any>;
+    handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>>, actualArgs: ConvexArgs) => Promise<ConvexReturns>;
+};
+declare const convexActionFunction: <DatabaseSchema_ extends DatabaseSchema.AnyWithProps, Args, ConvexArgs extends DefaultFunctionArgs, Returns, ConvexReturns, E>(schema: DatabaseSchema_, { name, functionVisibility, args, returns, error, handler, resolvedMiddlewares, }: {
+    name: string;
+    functionVisibility: FunctionVisibility;
+    args: Schema.Codec<Args, ConvexArgs>;
+    returns: Schema.Codec<Returns, ConvexReturns>;
+    error: Schema.Codec<any, any> | undefined;
+    handler: (a: Args) => Effect.Effect<Returns, E, RegisteredFunction.ActionServices<DatabaseSchema_>>;
+    resolvedMiddlewares: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>;
+}) => {
+    args: import("convex/values").PropertyValidators;
+    returns: import("convex/values").Validator<any, any, any>;
+    handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: ConvexArgs) => Promise<ConvexReturns>;
+};
+export {};
+//# sourceMappingURL=RegisteredConvexFunction.d.ts.map

package/dist/RegisteredConvexFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RegisteredConvexFunction.d.ts","sourceRoot":"","sources":["../src/RegisteredConvexFunction.ts"],"names":[],"mappings":"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"}

package/dist/RegisteredConvexFunction.js

@@ -0,0 +1,154 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { layerForTarget } from "./Auth.js";
+import { layer } from "./ConvexConfigProvider.js";
+import { layer as layer$1 } from "./DatabaseReader.js";
+import { layer as layer$2 } from "./DatabaseWriter.js";
+import { layer as layer$3 } from "./ExecutionMetadata.js";
+import { layer as layer$4 } from "./RequestMetadata.js";
+import { layer as layer$5 } from "./TransactionMetadata.js";
+import { layer as layer$6 } from "./MutationCtx.js";
+import { layer as layer$7 } from "./MutationTransactionContext.js";
+import { layer as layer$8 } from "./MutationRunner.js";
+import { layer as layer$9 } from "./QueryCtx.js";
+import { layer as layer$10 } from "./QueryTransactionContext.js";
+import { layer as layer$11 } from "./QueryRunner.js";
+import { layer as layer$12 } from "./Scheduler.js";
+import { StorageWriter } from "./StorageWriter.js";
+import { actionFunctionBase, actionLayer, applyMiddleware, combineErrorSchemas, runHandlerPromise, storageLayer } from "./RegisteredFunction.js";
+import * as Layer from "effect/Layer";
+import * as Effect from "effect/Effect";
+import { actionGeneric, internalActionGeneric, internalMutationGeneric, internalQueryGeneric, mutationGeneric, queryGeneric } from "convex/server";
+import * as Schema from "effect/Schema";
+import { pipe } from "effect/Function";
+import * as Match from "effect/Match";
+import { compileArgsSchema, compileReturnsSchema } from "@confect/core/SchemaToValidator";
+import * as Clock from "effect/Clock";
+import * as Data from "effect/Data";
+import * as Duration from "effect/Duration";
+import * as EffectScheduler from "effect/Scheduler";
+//#region src/RegisteredConvexFunction.ts
+var RegisteredConvexFunction_exports = /* @__PURE__ */ __exportAll({
+	Definition: () => Definition,
+	make: () => make,
+	mutationLayer: () => mutationLayer,
+	prepare: () => prepare,
+	register: () => register
+});
+const Definition = Data.taggedEnum();
+const prepare = (databaseSchema, item, resolvedMiddlewares = []) => Match.value(item.functionType).pipe(Match.when("query", () => {
+	const definition = queryFunction({
+		databaseSchema,
+		name: item.name,
+		functionVisibility: item.functionVisibility,
+		args: item.args,
+		returns: item.returns,
+		error: item.error,
+		handler: item.handler,
+		resolvedMiddlewares
+	});
+	return Match.value(item.functionVisibility).pipe(Match.when("public", () => Definition.PublicQuery(definition)), Match.when("internal", () => Definition.InternalQuery(definition)), Match.exhaustive);
+}), Match.when("mutation", () => {
+	const definition = mutationFunction({
+		databaseSchema,
+		name: item.name,
+		functionVisibility: item.functionVisibility,
+		args: item.args,
+		returns: item.returns,
+		error: item.error,
+		handler: item.handler,
+		resolvedMiddlewares
+	});
+	return Match.value(item.functionVisibility).pipe(Match.when("public", () => Definition.PublicMutation(definition)), Match.when("internal", () => Definition.InternalMutation(definition)), Match.exhaustive);
+}), Match.when("action", () => {
+	const definition = convexActionFunction(databaseSchema, {
+		name: item.name,
+		functionVisibility: item.functionVisibility,
+		args: item.args,
+		returns: item.returns,
+		error: item.error,
+		handler: item.handler,
+		resolvedMiddlewares
+	});
+	return Match.value(item.functionVisibility).pipe(Match.when("public", () => Definition.PublicAction(definition)), Match.when("internal", () => Definition.InternalAction(definition)), Match.exhaustive);
+}), Match.exhaustive);
+const make = (databaseSchema, item, resolvedMiddlewares = []) => register(prepare(databaseSchema, item, resolvedMiddlewares));
+const register = (self) => Definition.$match(self, {
+	PublicQuery: (definition) => queryGeneric(definition),
+	InternalQuery: (definition) => internalQueryGeneric(definition),
+	PublicMutation: (definition) => mutationGeneric(definition),
+	InternalMutation: (definition) => internalMutationGeneric(definition),
+	PublicAction: (definition) => actionGeneric(definition),
+	InternalAction: (definition) => internalActionGeneric(definition),
+	Registered: ({ handler }) => handler
+});
+/**
+* Convex evicts a query from its cache once the execution observes the current
+* time (every `Date.now()` read is tracked). Effect's logging, span, and
+* elapsed-time machinery reads timestamps through the ambient `Clock`'s unsafe
+* accessors, which would silently opt any logging or timing query out of the
+* cache—and there is no untracked time source in the isolate to serve them
+* from, since Effect's own live clock falls back to `Date.now()` for monotonic
+* time when neither `process.hrtime` nor `performance.now` exists. Queries
+* therefore run with a `Clock` whose unsafe accessors all return constants, so
+* logging and spans never touch the tracker and `Effect.timed` and duration
+* metrics report a zero elapsed time, while the effectful accessors
+* (`Clock.currentTimeMillis`/`currentTimeNanos`/`monotonicTimeNanos`) read the
+* real time, making them an explicit opt-in to cache eviction. Raw `Date.now()`
+* calls in handler code likewise opt out honestly.
+*/
+const queryClock = {
+	currentTimeMillisUnsafe: () => 0,
+	currentTimeNanosUnsafe: () => 0n,
+	monotonicTimeNanosUnsafe: () => 0n,
+	currentTimeMillis: Effect.sync(() => Date.now()),
+	currentTimeNanos: Effect.sync(() => BigInt(Date.now()) * 1000000n),
+	monotonicTimeNanos: Effect.sync(() => BigInt(Date.now()) * 1000000n),
+	sleep: (duration) => Effect.callback((resume) => {
+		const handle = setTimeout(() => resume(Effect.void), Duration.toMillis(duration));
+		return Effect.sync(() => clearTimeout(handle));
+	})
+};
+const queryFunction = ({ databaseSchema, name, functionVisibility, args, returns, error, handler, resolvedMiddlewares }) => ({
+	args: compileArgsSchema(args, databaseSchema.target.scope),
+	returns: compileReturnsSchema(returns, databaseSchema.target.scope),
+	handler: (ctx, actualArgs) => Effect.gen(function* () {
+		const decodedArgs = yield* pipe(actualArgs, Schema.decodeUnknownEffect(args), Effect.catchTag("SchemaError", Effect.die));
+		const decodedReturns = yield* applyMiddleware(handler(decodedArgs), resolvedMiddlewares, {
+			name,
+			functionType: "query",
+			functionVisibility,
+			args: decodedArgs
+		}).pipe(Effect.provide(Layer.mergeAll(layer$1(databaseSchema, ctx.db), layer$3(ctx.meta), layer$5(ctx.meta), layer$10(ctx), layerForTarget(databaseSchema.target, ctx.auth), storageLayer(ctx.storage), layer$11(ctx.runQuery), layer$9(ctx, databaseSchema.target.scope), layer)));
+		return yield* pipe(decodedReturns, Schema.encodeEffect(returns), Effect.catchTag("SchemaError", Effect.die));
+	}).pipe(Effect.provideService(Clock.Clock, queryClock), runHandlerPromise(combineErrorSchemas(error, resolvedMiddlewares), { scheduler: new EffectScheduler.MixedScheduler("sync") }))
+});
+const mutationLayer = (schema, ctx) => Layer.mergeAll(layer$1(schema, ctx.db), layer$2(schema, ctx.db), layer$3(ctx.meta), layer$4(ctx.meta), layer$5(ctx.meta), layerForTarget(schema.target, ctx.auth), layer$12(ctx.scheduler, schema.target.scope), storageLayer(ctx.storage), StorageWriter.layer(ctx.storage, schema.target.scope), layer$11(ctx.runQuery), layer$8(ctx.runMutation), layer$10(ctx), layer$7(ctx), layer$6(ctx, schema.target.scope), layer);
+const mutationFunction = ({ databaseSchema, name, functionVisibility, args, returns, error, handler, resolvedMiddlewares }) => ({
+	args: compileArgsSchema(args, databaseSchema.target.scope),
+	returns: compileReturnsSchema(returns, databaseSchema.target.scope),
+	handler: (ctx, actualArgs) => Effect.gen(function* () {
+		const decodedArgs = yield* pipe(actualArgs, Schema.decodeUnknownEffect(args), Effect.catchTag("SchemaError", Effect.die));
+		const decodedReturns = yield* applyMiddleware(handler(decodedArgs), resolvedMiddlewares, {
+			name,
+			functionType: "mutation",
+			functionVisibility,
+			args: decodedArgs
+		}).pipe(Effect.provide(mutationLayer(databaseSchema, ctx)));
+		return yield* pipe(decodedReturns, Schema.encodeEffect(returns), Effect.catchTag("SchemaError", Effect.die));
+	}).pipe(runHandlerPromise(combineErrorSchemas(error, resolvedMiddlewares), { scheduler: new EffectScheduler.MixedScheduler("sync") }))
+});
+const convexActionFunction = (schema, { name, functionVisibility, args, returns, error, handler, resolvedMiddlewares }) => actionFunctionBase({
+	scope: schema.target.scope,
+	name,
+	functionVisibility,
+	args,
+	returns,
+	error,
+	handler,
+	resolvedMiddlewares,
+	createLayer: (ctx) => Layer.mergeAll(actionLayer(schema, ctx), layer)
+});
+//#endregion
+export { Definition, RegisteredConvexFunction_exports, make, mutationLayer, prepare, register };
+
+//# sourceMappingURL=RegisteredConvexFunction.js.map

package/dist/RegisteredConvexFunction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RegisteredConvexFunction.js","names":["RegisteredFunction.applyMiddleware","DatabaseReader.layer","ExecutionMetadata.layer","TransactionMetadata.layer","QueryTransactionContext.layer","Auth.layerForTarget","RegisteredFunction.storageLayer","QueryRunner.layer","QueryCtx.layer","ConvexConfigProvider.layer","RegisteredFunction.runHandlerPromise","RegisteredFunction.combineErrorSchemas","DatabaseWriter.layer","RequestMetadata.layer","Scheduler.layer","MutationRunner.layer","MutationTransactionContext.layer","MutationCtx.layer","RegisteredFunction.actionFunctionBase","RegisteredFunction.actionLayer"],"sources":["../src/RegisteredConvexFunction.ts"],"sourcesContent":["import {\n  compileArgsSchema,\n  compileReturnsSchema,\n} from \"@confect/core/SchemaToValidator\";\nimport {\n  actionGeneric,\n  type DefaultFunctionArgs,\n  type FunctionVisibility,\n  type GenericMutationCtx,\n  type GenericQueryCtx,\n  internalActionGeneric,\n  internalMutationGeneric,\n  internalQueryGeneric,\n  mutationGeneric,\n  queryGeneric,\n} from \"convex/server\";\nimport type { Value } from \"convex/values\";\nimport { pipe } from \"effect/Function\";\nimport * as Clock from \"effect/Clock\";\nimport * as Data from \"effect/Data\";\nimport * as Duration from \"effect/Duration\";\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\nimport * as Match from \"effect/Match\";\nimport * as Schema from \"effect/Schema\";\nimport * as EffectScheduler from \"effect/Scheduler\";\nimport * as Auth from \"./Auth\";\nimport * as ConvexConfigProvider from \"./ConvexConfigProvider\";\nimport * as DatabaseReader from \"./DatabaseReader\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport * as DatabaseWriter from \"./DatabaseWriter\";\nimport type * as DataModel from \"./DataModel\";\nimport * as ExecutionMetadata from \"./ExecutionMetadata\";\nimport * as RequestMetadata from \"./RequestMetadata\";\nimport * as TransactionMetadata from \"./TransactionMetadata\";\nimport * as MutationCtx from \"./MutationCtx\";\nimport * as MutationRunner from \"./MutationRunner\";\nimport * as MutationTransactionContext from \"./MutationTransactionContext\";\nimport * as QueryCtx from \"./QueryCtx\";\nimport * as QueryRunner from \"./QueryRunner\";\nimport * as QueryTransactionContext from \"./QueryTransactionContext\";\nimport * as RegisteredFunction from \"./RegisteredFunction\";\nimport type * as FunctionRegistryItem from \"./FunctionRegistryItem\";\nimport type * as ResolvedMiddleware from \"./ResolvedMiddleware\";\nimport * as Scheduler from \"./Scheduler\";\nimport { StorageWriter } from \"./StorageWriter\";\nimport type * as Handler from \"./Handler\";\n\nexport type Definition = Data.TaggedEnum<{\n  PublicQuery: ReturnType<typeof queryFunction>;\n  InternalQuery: ReturnType<typeof queryFunction>;\n  PublicMutation: ReturnType<typeof mutationFunction>;\n  InternalMutation: ReturnType<typeof mutationFunction>;\n  PublicAction: ReturnType<typeof convexActionFunction>;\n  InternalAction: ReturnType<typeof convexActionFunction>;\n  Registered: { readonly handler: RegisteredFunction.Any };\n}>;\nexport const Definition = Data.taggedEnum<Definition>();\n\nexport const prepare = (\n  databaseSchema: DatabaseSchema.AnyWithProps,\n  item: FunctionRegistryItem.ConfectFunctionRegistryItem,\n  resolvedMiddlewares: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware> = [],\n) =>\n  Match.value(item.functionType).pipe(\n    Match.when(\"query\", () => {\n      const definition = queryFunction({\n        databaseSchema,\n        name: item.name,\n        functionVisibility: item.functionVisibility,\n        args: item.args,\n        returns: item.returns,\n        error: item.error,\n        handler: item.handler,\n        resolvedMiddlewares,\n      });\n      return Match.value(item.functionVisibility).pipe(\n        Match.when(\"public\", () => Definition.PublicQuery(definition)),\n        Match.when(\"internal\", () => Definition.InternalQuery(definition)),\n        Match.exhaustive,\n      );\n    }),\n    Match.when(\"mutation\", () => {\n      const definition = mutationFunction({\n        databaseSchema,\n        name: item.name,\n        functionVisibility: item.functionVisibility,\n        args: item.args,\n        returns: item.returns,\n        error: item.error,\n        handler: item.handler,\n        resolvedMiddlewares,\n      });\n      return Match.value(item.functionVisibility).pipe(\n        Match.when(\"public\", () => Definition.PublicMutation(definition)),\n        Match.when(\"internal\", () => Definition.InternalMutation(definition)),\n        Match.exhaustive,\n      );\n    }),\n    Match.when(\"action\", () => {\n      const definition = convexActionFunction(databaseSchema, {\n        name: item.name,\n        functionVisibility: item.functionVisibility,\n        args: item.args,\n        returns: item.returns,\n        error: item.error,\n        handler: item.handler,\n        resolvedMiddlewares,\n      });\n      return Match.value(item.functionVisibility).pipe(\n        Match.when(\"public\", () => Definition.PublicAction(definition)),\n        Match.when(\"internal\", () => Definition.InternalAction(definition)),\n        Match.exhaustive,\n      );\n    }),\n    Match.exhaustive,\n  );\n\nexport const make = (\n  databaseSchema: DatabaseSchema.AnyWithProps,\n  item: FunctionRegistryItem.ConfectFunctionRegistryItem,\n  resolvedMiddlewares: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware> = [],\n): RegisteredFunction.Any =>\n  register(prepare(databaseSchema, item, resolvedMiddlewares));\n\nexport const register = (self: Definition): RegisteredFunction.Any =>\n  Definition.$match(self, {\n    PublicQuery: (definition) => queryGeneric(definition),\n    InternalQuery: (definition) => internalQueryGeneric(definition),\n    PublicMutation: (definition) => mutationGeneric(definition),\n    InternalMutation: (definition) => internalMutationGeneric(definition),\n    PublicAction: (definition) => actionGeneric(definition),\n    InternalAction: (definition) => internalActionGeneric(definition),\n    Registered: ({ handler }) => handler,\n  });\n\n/**\n * Convex evicts a query from its cache once the execution observes the current\n * time (every `Date.now()` read is tracked). Effect's logging, span, and\n * elapsed-time machinery reads timestamps through the ambient `Clock`'s unsafe\n * accessors, which would silently opt any logging or timing query out of the\n * cache—and there is no untracked time source in the isolate to serve them\n * from, since Effect's own live clock falls back to `Date.now()` for monotonic\n * time when neither `process.hrtime` nor `performance.now` exists. Queries\n * therefore run with a `Clock` whose unsafe accessors all return constants, so\n * logging and spans never touch the tracker and `Effect.timed` and duration\n * metrics report a zero elapsed time, while the effectful accessors\n * (`Clock.currentTimeMillis`/`currentTimeNanos`/`monotonicTimeNanos`) read the\n * real time, making them an explicit opt-in to cache eviction. Raw `Date.now()`\n * calls in handler code likewise opt out honestly.\n */\nconst queryClock: Clock.Clock = {\n  currentTimeMillisUnsafe: () => 0,\n  currentTimeNanosUnsafe: () => 0n,\n  monotonicTimeNanosUnsafe: () => 0n,\n  // oxlint-disable-next-line effecttsgo/global-date-in-effect -- This access intentionally notifies Convex's query-cache tracker.\n  currentTimeMillis: Effect.sync(() => Date.now()),\n  // oxlint-disable-next-line effecttsgo/global-date-in-effect -- This access intentionally notifies Convex's query-cache tracker.\n  currentTimeNanos: Effect.sync(() => BigInt(Date.now()) * 1_000_000n),\n  // oxlint-disable-next-line effecttsgo/global-date-in-effect -- This access intentionally notifies Convex's query-cache tracker.\n  monotonicTimeNanos: Effect.sync(() => BigInt(Date.now()) * 1_000_000n),\n  // `Effect.sleep` resolves the ambient clock, so it cannot be used here—it\n  // would recurse straight back into this `sleep`.\n  sleep: (duration) =>\n    Effect.callback<void>((resume) => {\n      // oxlint-disable-next-line effecttsgo/global-timers-in-effect -- Effect.sleep would resolve this Clock and recurse.\n      const handle = setTimeout(\n        () => resume(Effect.void),\n        Duration.toMillis(duration),\n      );\n      return Effect.sync(() => clearTimeout(handle));\n    }),\n};\n\nconst queryFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>({\n  databaseSchema,\n  name,\n  functionVisibility,\n  args,\n  returns,\n  error,\n  handler,\n  resolvedMiddlewares,\n}: {\n  databaseSchema: DatabaseSchema_;\n  name: string;\n  functionVisibility: FunctionVisibility;\n  args: Schema.Codec<Args, ConvexArgs>;\n  returns: Schema.Codec<Returns, ConvexReturns>;\n  error: Schema.Codec<Error, Value> | undefined;\n  handler: (\n    a: Args,\n  ) => Effect.Effect<Returns, E, Handler.QueryServices<DatabaseSchema_>>;\n  resolvedMiddlewares: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>;\n}) => ({\n  args: compileArgsSchema(args, databaseSchema.target.scope),\n  returns: compileReturnsSchema(returns, databaseSchema.target.scope),\n  handler: (\n    ctx: GenericQueryCtx<\n      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n    >,\n    actualArgs: ConvexArgs,\n  ): Promise<ConvexReturns> =>\n    Effect.gen(function* () {\n      const decodedArgs = yield* pipe(\n        actualArgs,\n        Schema.decodeUnknownEffect(args),\n        Effect.catchTag(\"SchemaError\", Effect.die),\n      );\n      // oxlint-disable-next-line effecttsgo/any-unknown-in-error-context -- Middleware errors are intentionally erased here and validated by runHandlerPromise against the combined error schema below.\n      const decodedReturns = yield* RegisteredFunction.applyMiddleware(\n        handler(decodedArgs),\n        resolvedMiddlewares,\n        {\n          name,\n          functionType: \"query\",\n          functionVisibility,\n          args: decodedArgs,\n        },\n      ).pipe(\n        Effect.provide(\n          Layer.mergeAll(\n            DatabaseReader.layer(databaseSchema, ctx.db),\n            ExecutionMetadata.layer(ctx.meta),\n            TransactionMetadata.layer(ctx.meta),\n            QueryTransactionContext.layer(ctx),\n            Auth.layerForTarget<DatabaseSchema_[\"target\"]>(\n              databaseSchema.target,\n              ctx.auth,\n            ),\n            RegisteredFunction.storageLayer<\n              DatabaseSchema.Scope<DatabaseSchema_>\n            >(ctx.storage),\n            QueryRunner.layer(ctx.runQuery),\n            QueryCtx.layer<\n              DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>,\n              DatabaseSchema.Scope<DatabaseSchema_>\n            >(ctx, databaseSchema.target.scope),\n            ConvexConfigProvider.layer,\n          ),\n        ),\n      );\n      return yield* pipe(\n        decodedReturns,\n        Schema.encodeEffect(returns),\n        Effect.catchTag(\"SchemaError\", Effect.die),\n      );\n    }).pipe(\n      Effect.provideService(Clock.Clock, queryClock),\n      RegisteredFunction.runHandlerPromise(\n        RegisteredFunction.combineErrorSchemas(error, resolvedMiddlewares),\n        {\n          scheduler: new EffectScheduler.MixedScheduler(\"sync\"),\n        },\n      ),\n    ),\n});\n\nexport const mutationLayer = <Schema extends DatabaseSchema.AnyWithProps>(\n  schema: Schema,\n  ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n) =>\n  Layer.mergeAll(\n    DatabaseReader.layer(schema, ctx.db),\n    DatabaseWriter.layer(schema, ctx.db),\n    ExecutionMetadata.layer(ctx.meta),\n    RequestMetadata.layer(ctx.meta),\n    TransactionMetadata.layer(ctx.meta),\n    Auth.layerForTarget<Schema[\"target\"]>(schema.target, ctx.auth),\n    Scheduler.layer<DatabaseSchema.Scope<Schema>>(\n      ctx.scheduler,\n      schema.target.scope,\n    ),\n    RegisteredFunction.storageLayer<DatabaseSchema.Scope<Schema>>(ctx.storage),\n    StorageWriter.layer<DatabaseSchema.Scope<Schema>>(\n      ctx.storage,\n      schema.target.scope,\n    ),\n    QueryRunner.layer(ctx.runQuery),\n    MutationRunner.layer(ctx.runMutation),\n    QueryTransactionContext.layer(ctx),\n    MutationTransactionContext.layer(ctx),\n    MutationCtx.layer<\n      DataModel.ToConvex<DataModel.FromSchema<Schema>>,\n      DatabaseSchema.Scope<Schema>\n    >(ctx, schema.target.scope),\n    ConvexConfigProvider.layer,\n  );\n\nexport type MutationServices<Schema extends DatabaseSchema.AnyWithProps> =\n  Handler.MutationServices<Schema>;\n\nconst mutationFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>({\n  databaseSchema,\n  name,\n  functionVisibility,\n  args,\n  returns,\n  error,\n  handler,\n  resolvedMiddlewares,\n}: {\n  databaseSchema: DatabaseSchema_;\n  name: string;\n  functionVisibility: FunctionVisibility;\n  args: Schema.Codec<Args, ConvexArgs>;\n  returns: Schema.Codec<Returns, ConvexReturns>;\n  error: Schema.Codec<Error, Value> | undefined;\n  handler: (\n    a: Args,\n  ) => Effect.Effect<Returns, E, MutationServices<DatabaseSchema_>>;\n  resolvedMiddlewares: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>;\n}) => ({\n  args: compileArgsSchema(args, databaseSchema.target.scope),\n  returns: compileReturnsSchema(returns, databaseSchema.target.scope),\n  handler: (\n    ctx: GenericMutationCtx<\n      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n    >,\n    actualArgs: ConvexArgs,\n  ): Promise<ConvexReturns> =>\n    Effect.gen(function* () {\n      const decodedArgs = yield* pipe(\n        actualArgs,\n        Schema.decodeUnknownEffect(args),\n        Effect.catchTag(\"SchemaError\", Effect.die),\n      );\n      // oxlint-disable-next-line effecttsgo/any-unknown-in-error-context -- Middleware errors are intentionally erased here and validated by runHandlerPromise against the combined error schema below.\n      const decodedReturns = yield* RegisteredFunction.applyMiddleware(\n        handler(decodedArgs),\n        resolvedMiddlewares,\n        {\n          name,\n          functionType: \"mutation\",\n          functionVisibility,\n          args: decodedArgs,\n        },\n      ).pipe(Effect.provide(mutationLayer(databaseSchema, ctx)));\n      return yield* pipe(\n        decodedReturns,\n        Schema.encodeEffect(returns),\n        Effect.catchTag(\"SchemaError\", Effect.die),\n      );\n    }).pipe(\n      RegisteredFunction.runHandlerPromise(\n        RegisteredFunction.combineErrorSchemas(error, resolvedMiddlewares),\n        {\n          scheduler: new EffectScheduler.MixedScheduler(\"sync\"),\n        },\n      ),\n    ),\n});\n\nconst convexActionFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>(\n  schema: DatabaseSchema_,\n  {\n    name,\n    functionVisibility,\n    args,\n    returns,\n    error,\n    handler,\n    resolvedMiddlewares,\n  }: {\n    name: string;\n    functionVisibility: FunctionVisibility;\n    args: Schema.Codec<Args, ConvexArgs>;\n    returns: Schema.Codec<Returns, ConvexReturns>;\n    error: Schema.Codec<any, any> | undefined;\n    handler: (\n      a: Args,\n    ) => Effect.Effect<\n      Returns,\n      E,\n      RegisteredFunction.ActionServices<DatabaseSchema_>\n    >;\n    resolvedMiddlewares: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>;\n  },\n) =>\n  RegisteredFunction.actionFunctionBase({\n    scope: schema.target.scope,\n    name,\n    functionVisibility,\n    args,\n    returns,\n    error,\n    handler,\n    resolvedMiddlewares,\n    createLayer: (ctx) =>\n      Layer.mergeAll(\n        RegisteredFunction.actionLayer(schema, ctx),\n        ConvexConfigProvider.layer,\n      ),\n  });\n"],"mappings":"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"}