@confect/server 1.0.0-next.0

package/dist/RegisteredFunctions.d.ts

@@ -0,0 +1,66 @@
+import { Name, WithName } from "./Table.js";
+import { AnyWithProps as AnyWithProps$1, IncludeSystemTables, Tables } from "./DatabaseSchema.js";
+import { AnyWithProps as AnyWithProps$2 } from "./Api.js";
+import { Auth as Auth$1 } from "./Auth.js";
+import { DocumentDecodeError, DocumentEncodeError, WithoutSystemFields as WithoutSystemFields$1 } from "./Document.js";
+import { TableInfo } from "./TableInfo.js";
+import { DataModel, DocumentByName, FromSchema, TableInfoWithName, TableNames, ToConvex } from "./DataModel.js";
+import { OrderedQuery as OrderedQuery$1 } from "./OrderedQuery.js";
+import { GetByIdFailure, GetByIndexFailure } from "./QueryInitializer.js";
+import { DatabaseReader } from "./DatabaseReader.js";
+import { DatabaseWriter } from "./DatabaseWriter.js";
+import { MutationCtx } from "./MutationCtx.js";
+import { MutationRunner } from "./MutationRunner.js";
+import { QueryRunner } from "./QueryRunner.js";
+import { Scheduler as Scheduler$1 } from "./Scheduler.js";
+import { StorageReader as StorageReader$1, StorageWriter as StorageWriter$1 } from "./Storage.js";
+import { Impl } from "./Impl.js";
+import { Effect, Layer, Types } from "effect";
+import * as _confect_core_Ref0 from "@confect/core/Ref";
+import * as convex_server23 from "convex/server";
+import { DefaultFunctionArgs, FunctionVisibility, GenericMutationCtx, RegisteredAction, RegisteredMutation, RegisteredQuery } from "convex/server";
+import * as convex_values3 from "convex/values";
+import * as effect_ParseResult5 from "effect/ParseResult";
+import * as Spec from "@confect/core/Spec";
+import * as _confect_core_Types3 from "@confect/core/Types";
+import * as FunctionSpec from "@confect/core/FunctionSpec";
+import * as GroupSpec from "@confect/core/GroupSpec";
+import * as effect_Duration0 from "effect/Duration";
+import * as effect_DateTime0 from "effect/DateTime";
+
+//#region src/RegisteredFunctions.d.ts
+declare namespace RegisteredFunctions_d_exports {
+  export { AnyWithProps, MutationServices, RegisteredFunction, RegisteredFunctions, make, mutationLayer };
+}
+type RegisteredFunction = RegisteredQuery<FunctionVisibility, DefaultFunctionArgs, any> | RegisteredMutation<FunctionVisibility, DefaultFunctionArgs, any> | RegisteredAction<FunctionVisibility, DefaultFunctionArgs, any>;
+type RegisteredFunctions<Spec_ extends Spec.AnyWithProps> = Types.Simplify<RegisteredFunctionsHelper<Spec.Groups<Spec_>>>;
+type RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = { [GroupName in GroupSpec.Name<Groups>]: GroupSpec.WithName<Groups, GroupName> extends infer Group extends GroupSpec.AnyWithProps ? GroupSpec.Groups<Group> extends infer SubGroups extends GroupSpec.AnyWithProps ? Types.Simplify<RegisteredFunctionsHelper<SubGroups> & { [FunctionName in FunctionSpec.Name<GroupSpec.Functions<Group>>]: FunctionSpec.WithName<GroupSpec.Functions<Group>, FunctionName> extends infer Function extends FunctionSpec.AnyWithProps ? FunctionSpec.RegisteredFunction<Function> : never }> : { [FunctionName in FunctionSpec.Name<GroupSpec.Functions<Group>>]: FunctionSpec.WithName<GroupSpec.Functions<Group>, FunctionName> extends infer Function extends FunctionSpec.AnyWithProps ? FunctionSpec.RegisteredFunction<Function> : never } : never };
+interface AnyWithProps {
+  readonly [key: string]: RegisteredFunction | AnyWithProps;
+}
+declare const make: <Api_ extends AnyWithProps$2>(impl: Layer.Layer<Impl<Api_, "Finalized">>) => Types.Simplify<RegisteredFunctionsHelper<Spec.Groups<Api_["spec"]>>>;
+declare const mutationLayer: <Schema$1 extends AnyWithProps$1>(schema: Schema$1, ctx: GenericMutationCtx<ToConvex<FromSchema<Schema$1>>>) => Layer.Layer<(<Mutation extends _confect_core_Ref0.AnyMutation>(mutation: Mutation, args: _confect_core_Ref0.Args<Mutation>["Type"]) => Effect.Effect<any, effect_ParseResult5.ParseError, never>) | (<Query extends _confect_core_Ref0.AnyQuery>(query: Query, args: _confect_core_Ref0.Args<Query>["Type"]) => Effect.Effect<_confect_core_Ref0.Returns<Query>["Type"], effect_ParseResult5.ParseError>) | GenericMutationCtx<ToConvex<FromSchema<Schema$1>>> | {
+  table: <const TableName extends Name<IncludeSystemTables<Tables<Schema$1>>>>(tableName: TableName) => {
+    readonly get: {
+      (id: convex_values3.GenericId<TableName>): Effect.Effect<TableInfo<WithName<IncludeSystemTables<Tables<Schema$1>>, TableName>>["document"], GetByIdFailure | DocumentDecodeError, never>;
+      <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<Schema$1>>, TableName>>["indexes"]>(indexName: IndexName, ...indexFieldValues: _confect_core_Types3.IndexFieldTypesForEq<ToConvex<DataModel<IncludeSystemTables<Tables<Schema$1>>>>, TableName, TableInfo<WithName<IncludeSystemTables<Tables<Schema$1>>, TableName>>["indexes"][IndexName]>): Effect.Effect<TableInfo<WithName<IncludeSystemTables<Tables<Schema$1>>, TableName>>["document"], DocumentDecodeError | GetByIndexFailure, never>;
+    };
+    readonly index: {
+      <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<Schema$1>>, TableName>>["indexes"]>(indexName: IndexName, indexRange?: ((q: convex_server23.IndexRangeBuilder<TableInfo<WithName<IncludeSystemTables<Tables<Schema$1>>, TableName>>["convexDocument"], convex_server23.NamedIndex<TableInfoWithName<DataModel<IncludeSystemTables<Tables<Schema$1>>>, TableName>, IndexName>, 0>) => convex_server23.IndexRange) | undefined, order?: "asc" | "desc"): OrderedQuery$1<TableInfo<WithName<IncludeSystemTables<Tables<Schema$1>>, TableName>>, TableName>;
+      <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<Schema$1>>, TableName>>["indexes"]>(indexName: IndexName, order?: "asc" | "desc"): OrderedQuery$1<TableInfo<WithName<IncludeSystemTables<Tables<Schema$1>>, TableName>>, TableName>;
+    };
+    readonly search: <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<Schema$1>>, TableName>>["searchIndexes"]>(indexName: IndexName, searchFilter: (q: convex_server23.SearchFilterBuilder<TableInfo<WithName<IncludeSystemTables<Tables<Schema$1>>, TableName>>["convexDocument"], convex_server23.NamedSearchIndex<TableInfoWithName<DataModel<IncludeSystemTables<Tables<Schema$1>>>, TableName>, IndexName>>) => convex_server23.SearchFilter) => OrderedQuery$1<TableInfo<WithName<IncludeSystemTables<Tables<Schema$1>>, TableName>>, TableName>;
+  };
+} | {
+  insert: <TableName extends TableNames<FromSchema<Schema$1>>>(tableName: TableName, document: WithoutSystemFields$1<DocumentByName<FromSchema<Schema$1>, TableName>>) => Effect.Effect<convex_values3.GenericId<TableName>, DocumentEncodeError, never>;
+  patch: <TableName extends TableNames<FromSchema<Schema$1>>>(tableName: TableName, id: convex_values3.GenericId<TableName>, patchedValues: Partial<convex_server23.Expand<convex_server23.BetterOmit<DocumentByName<FromSchema<Schema$1>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, DocumentEncodeError | GetByIdFailure | DocumentDecodeError, never>;
+  replace: <TableName extends TableNames<FromSchema<Schema$1>>>(tableName: TableName, id: convex_values3.GenericId<TableName>, value: convex_server23.Expand<convex_server23.BetterOmit<DocumentByName<FromSchema<Schema$1>, TableName>, "_id" | "_creationTime">>) => Effect.Effect<void, DocumentEncodeError, never>;
+  delete: <TableName extends TableNames<FromSchema<Schema$1>>>(_tableName: TableName, id: convex_values3.GenericId<TableName>) => Effect.Effect<void, never, never>;
+} | Auth$1 | {
+  runAfter: <FuncRef extends convex_server23.SchedulableFunctionReference>(delay: effect_Duration0.Duration, functionReference: FuncRef, ...args: convex_server23.OptionalRestArgs<FuncRef>) => Effect.Effect<convex_values3.GenericId<"_scheduled_functions">, never, never>;
+  runAt: <FuncRef extends convex_server23.SchedulableFunctionReference>(dateTime: effect_DateTime0.DateTime, functionReference: FuncRef, ...args: convex_server23.OptionalRestArgs<FuncRef>) => Effect.Effect<convex_values3.GenericId<"_scheduled_functions">, never, never>;
+} | StorageReader$1 | StorageWriter$1, never, never>;
+type MutationServices<Schema$1 extends AnyWithProps$1> = DatabaseReader<Schema$1> | DatabaseWriter<Schema$1> | Auth$1 | Scheduler$1 | StorageReader$1 | StorageWriter$1 | QueryRunner | MutationRunner | MutationCtx<ToConvex<FromSchema<Schema$1>>>;
+//#endregion
+export { AnyWithProps, MutationServices, RegisteredFunction, RegisteredFunctions, RegisteredFunctions_d_exports, make, mutationLayer };
+//# sourceMappingURL=RegisteredFunctions.d.ts.map

package/dist/RegisteredFunctions.d.ts.map

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

package/dist/RegisteredFunctions.js

@@ -0,0 +1,71 @@
+import { __export } from "./_virtual/rolldown_runtime.js";
+import { ActionCtx } from "./ActionCtx.js";
+import { layer } from "./ActionRunner.js";
+import { layer as layer$1 } from "./Auth.js";
+import { compileArgsSchema, compileReturnsSchema } from "./SchemaToValidator.js";
+import { layer as layer$2 } from "./DatabaseReader.js";
+import { layer as layer$3 } from "./DatabaseWriter.js";
+import { mapLeaves } from "./internal/utils.js";
+import { Registry } from "./Registry.js";
+import { isRegistryItem } from "./RegistryItem.js";
+import { layer as layer$4 } from "./MutationRunner.js";
+import { layer as layer$5 } from "./QueryRunner.js";
+import { layer as layer$6 } from "./Scheduler.js";
+import { StorageActionWriter as StorageActionWriter$1, StorageReader as StorageReader$1, StorageWriter as StorageWriter$1 } from "./Storage.js";
+import { Impl } from "./Impl.js";
+import { MutationCtx } from "./MutationCtx.js";
+import { QueryCtx } from "./QueryCtx.js";
+import { layer as layer$7 } from "./VectorSearch.js";
+import { Effect, Layer, Match, Ref, Schema, pipe } from "effect";
+import { actionGeneric, internalActionGeneric, internalMutationGeneric, internalQueryGeneric, mutationGeneric, queryGeneric } from "convex/server";
+
+//#region src/RegisteredFunctions.ts
+var RegisteredFunctions_exports = /* @__PURE__ */ __export({
+	make: () => make,
+	mutationLayer: () => mutationLayer
+});
+const make = (impl) => Effect.gen(function* () {
+	const registry = yield* Registry;
+	const functionImplItems = yield* Ref.get(registry);
+	const { api, finalizationStatus } = yield* Impl();
+	return yield* Match.value(finalizationStatus).pipe(Match.withReturnType(), Match.when("Unfinalized", () => Effect.dieMessage("Impl is not finalized")), Match.when("Finalized", () => Effect.succeed(mapLeaves(functionImplItems, isRegistryItem, (registryItem) => makeRegisteredFunction(api, registryItem)))), Match.exhaustive);
+}).pipe(Effect.provide(impl), Effect.runSync);
+const makeRegisteredFunction = (api, { function_, handler }) => Match.value(function_.functionType).pipe(Match.when("query", () => {
+	return Match.value(function_.functionVisibility).pipe(Match.when("public", () => queryGeneric), Match.when("internal", () => internalQueryGeneric), Match.exhaustive)(queryFunction(api.databaseSchema, {
+		args: function_.args,
+		returns: function_.returns,
+		handler
+	}));
+}), Match.when("mutation", () => {
+	return Match.value(function_.functionVisibility).pipe(Match.when("public", () => mutationGeneric), Match.when("internal", () => internalMutationGeneric), Match.exhaustive)(mutationFunction(api.databaseSchema, {
+		args: function_.args,
+		returns: function_.returns,
+		handler
+	}));
+}), Match.when("action", () => {
+	return Match.value(function_.functionVisibility).pipe(Match.when("public", () => actionGeneric), Match.when("internal", () => internalActionGeneric), Match.exhaustive)(actionFunction({
+		args: function_.args,
+		returns: function_.returns,
+		handler
+	}));
+}), Match.exhaustive);
+const queryFunction = (schema, { args, returns, handler }) => ({
+	args: compileArgsSchema(args),
+	returns: compileReturnsSchema(returns),
+	handler: (ctx, actualArgs) => pipe(actualArgs, Schema.decode(args), Effect.orDie, Effect.andThen((decodedArgs) => pipe(handler(decodedArgs), Effect.provide(Layer.mergeAll(layer$2(schema, ctx.db), layer$1(ctx.auth), StorageReader$1.layer(ctx.storage), layer$5(ctx.runQuery), Layer.succeed(QueryCtx(), ctx))))), Effect.andThen((convexReturns) => Schema.encodeUnknown(returns)(convexReturns)), Effect.runPromise)
+});
+const mutationLayer = (schema, ctx) => Layer.mergeAll(layer$2(schema, ctx.db), layer$3(schema, ctx.db), layer$1(ctx.auth), layer$6(ctx.scheduler), StorageReader$1.layer(ctx.storage), StorageWriter$1.layer(ctx.storage), layer$5(ctx.runQuery), layer$4(ctx.runMutation), Layer.succeed(MutationCtx(), ctx));
+const mutationFunction = (schema, { args, returns, handler }) => ({
+	args: compileArgsSchema(args),
+	returns: compileReturnsSchema(returns),
+	handler: (ctx, actualArgs) => 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 = ({ args, returns, handler }) => ({
+	args: compileArgsSchema(args),
+	returns: compileReturnsSchema(returns),
+	handler: (ctx, actualArgs) => pipe(actualArgs, Schema.decode(args), Effect.orDie, Effect.andThen((decodedArgs) => pipe(handler(decodedArgs), Effect.provide(Layer.mergeAll(layer$6(ctx.scheduler), layer$1(ctx.auth), StorageReader$1.layer(ctx.storage), StorageWriter$1.layer(ctx.storage), StorageActionWriter$1.layer(ctx.storage), layer$5(ctx.runQuery), layer$4(ctx.runMutation), layer(ctx.runAction), layer$7(ctx.vectorSearch), Layer.succeed(ActionCtx(), ctx))))), Effect.andThen((convexReturns) => Schema.encodeUnknown(returns)(convexReturns)), Effect.runPromise)
+});
+
+//#endregion
+export { RegisteredFunctions_exports, make, mutationLayer };
+//# sourceMappingURL=RegisteredFunctions.js.map

package/dist/RegisteredFunctions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RegisteredFunctions.js","names":["Registry.Registry","Impl.Impl","RegistryItem.isRegistryItem","SchemaToValidator.compileArgsSchema","SchemaToValidator.compileReturnsSchema","DatabaseReader.layer","Auth.layer","StorageReader","QueryRunner.layer","QueryCtx.QueryCtx","DatabaseWriter.layer","Scheduler.layer","StorageWriter","MutationRunner.layer","MutationCtx.MutationCtx","StorageActionWriter","ActionRunner.layer","VectorSearch.layer","ActionCtx.ActionCtx"],"sources":["../src/RegisteredFunctions.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport type * as GroupSpec from \"@confect/core/GroupSpec\";\nimport type * as Spec from \"@confect/core/Spec\";\nimport {\n  actionGeneric,\n  type DefaultFunctionArgs,\n  type FunctionVisibility,\n  type GenericActionCtx,\n  type GenericMutationCtx,\n  type GenericQueryCtx,\n  internalActionGeneric,\n  internalMutationGeneric,\n  internalQueryGeneric,\n  mutationGeneric,\n  queryGeneric,\n  type RegisteredAction,\n  type RegisteredMutation,\n  type RegisteredQuery,\n} from \"convex/server\";\nimport {\n  Effect,\n  Layer,\n  Match,\n  pipe,\n  Ref,\n  Schema,\n  type Types,\n} from \"effect\";\nimport * as ActionCtx from \"./ActionCtx\";\nimport * as ActionRunner from \"./ActionRunner\";\nimport type * as Api from \"./Api\";\nimport * as Auth from \"./Auth\";\nimport * as DatabaseReader from \"./DatabaseReader\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport * as DatabaseWriter from \"./DatabaseWriter\";\nimport type * as DataModel from \"./DataModel\";\nimport * as Impl from \"./Impl\";\nimport { mapLeaves } from \"./internal/utils\";\nimport * as MutationCtx from \"./MutationCtx\";\nimport * as MutationRunner from \"./MutationRunner\";\nimport * as QueryCtx from \"./QueryCtx\";\nimport * as QueryRunner from \"./QueryRunner\";\nimport * as Registry from \"./Registry\";\nimport * as RegistryItem from \"./RegistryItem\";\nimport * as Scheduler from \"./Scheduler\";\nimport * as SchemaToValidator from \"./SchemaToValidator\";\nimport { StorageActionWriter, StorageReader, StorageWriter } from \"./Storage\";\nimport * as VectorSearch from \"./VectorSearch\";\n\nexport type RegisteredFunction =\n  | RegisteredQuery<FunctionVisibility, DefaultFunctionArgs, any>\n  | RegisteredMutation<FunctionVisibility, DefaultFunctionArgs, any>\n  | RegisteredAction<FunctionVisibility, DefaultFunctionArgs, any>;\n\nexport type RegisteredFunctions<Spec_ extends Spec.AnyWithProps> =\n  Types.Simplify<RegisteredFunctionsHelper<Spec.Groups<Spec_>>>;\n\ntype RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = {\n  [GroupName in GroupSpec.Name<Groups>]: GroupSpec.WithName<\n    Groups,\n    GroupName\n  > extends infer Group extends GroupSpec.AnyWithProps\n    ? GroupSpec.Groups<Group> extends infer SubGroups extends\n        GroupSpec.AnyWithProps\n      ? Types.Simplify<\n          RegisteredFunctionsHelper<SubGroups> & {\n            [FunctionName in FunctionSpec.Name<\n              GroupSpec.Functions<Group>\n            >]: FunctionSpec.WithName<\n              GroupSpec.Functions<Group>,\n              FunctionName\n            > extends infer Function extends FunctionSpec.AnyWithProps\n              ? FunctionSpec.RegisteredFunction<Function>\n              : never;\n          }\n        >\n      : {\n          [FunctionName in FunctionSpec.Name<\n            GroupSpec.Functions<Group>\n          >]: FunctionSpec.WithName<\n            GroupSpec.Functions<Group>,\n            FunctionName\n          > extends infer Function extends FunctionSpec.AnyWithProps\n            ? FunctionSpec.RegisteredFunction<Function>\n            : never;\n        }\n    : never;\n};\n\nexport interface AnyWithProps {\n  readonly [key: string]: RegisteredFunction | AnyWithProps;\n}\n\nexport const make = <Api_ extends Api.AnyWithProps>(\n  impl: Layer.Layer<Impl.Impl<Api_, \"Finalized\">>,\n) =>\n  Effect.gen(function* () {\n    const registry = yield* Registry.Registry;\n    const functionImplItems = yield* Ref.get(registry);\n    const { api, finalizationStatus } = yield* Impl.Impl<Api_, \"Finalized\">();\n\n    return yield* Match.value(\n      finalizationStatus as Impl.FinalizationStatus,\n    ).pipe(\n      Match.withReturnType<Effect.Effect<RegisteredFunctions<Api_[\"spec\"]>>>(),\n      Match.when(\"Unfinalized\", () =>\n        Effect.dieMessage(\"Impl is not finalized\"),\n      ),\n      Match.when(\"Finalized\", () =>\n        Effect.succeed(\n          mapLeaves<RegistryItem.AnyWithProps, RegisteredFunction>(\n            functionImplItems,\n            RegistryItem.isRegistryItem,\n            (registryItem) => makeRegisteredFunction(api, registryItem),\n          ) as RegisteredFunctions<Api_[\"spec\"]>,\n        ),\n      ),\n      Match.exhaustive,\n    );\n  }).pipe(Effect.provide(impl), Effect.runSync);\n\nconst makeRegisteredFunction = <Api_ extends Api.AnyWithProps>(\n  api: Api_,\n  { function_, handler }: RegistryItem.AnyWithProps,\n): RegisteredFunction =>\n  Match.value(function_.functionType).pipe(\n    Match.when(\"query\", () => {\n      const genericFunction = Match.value(function_.functionVisibility).pipe(\n        Match.when(\"public\", () => queryGeneric),\n        Match.when(\"internal\", () => internalQueryGeneric),\n        Match.exhaustive,\n      );\n\n      return genericFunction(\n        queryFunction(api.databaseSchema, {\n          args: function_.args,\n          returns: function_.returns,\n          handler,\n        }),\n      );\n    }),\n    Match.when(\"mutation\", () => {\n      const genericFunction = Match.value(function_.functionVisibility).pipe(\n        Match.when(\"public\", () => mutationGeneric),\n        Match.when(\"internal\", () => internalMutationGeneric),\n        Match.exhaustive,\n      );\n\n      return genericFunction(\n        mutationFunction(api.databaseSchema, {\n          args: function_.args,\n          returns: function_.returns,\n          handler,\n        }),\n      );\n    }),\n    Match.when(\"action\", () => {\n      const genericFunction = Match.value(function_.functionVisibility).pipe(\n        Match.when(\"public\", () => actionGeneric),\n        Match.when(\"internal\", () => internalActionGeneric),\n        Match.exhaustive,\n      );\n\n      return genericFunction(\n        actionFunction({\n          args: function_.args,\n          returns: function_.returns,\n          handler,\n        }),\n      );\n    }),\n    Match.exhaustive,\n  );\n\nconst queryFunction = <\n  Schema extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>(\n  schema: Schema,\n  {\n    args,\n    returns,\n    handler,\n  }: {\n    args: Schema.Schema<Args, ConvexArgs>;\n    returns: Schema.Schema<Returns, ConvexReturns>;\n    handler: (\n      a: Args,\n    ) => Effect.Effect<\n      Returns,\n      E,\n      | DatabaseReader.DatabaseReader<Schema>\n      | Auth.Auth\n      | StorageReader\n      | QueryRunner.QueryRunner\n      | QueryCtx.QueryCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>\n    >;\n  },\n) => ({\n  args: SchemaToValidator.compileArgsSchema(args),\n  returns: SchemaToValidator.compileReturnsSchema(returns),\n  handler: (\n    ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n    actualArgs: ConvexArgs,\n  ): Promise<ConvexReturns> =>\n    pipe(\n      actualArgs,\n      Schema.decode(args),\n      Effect.orDie,\n      Effect.andThen((decodedArgs) =>\n        pipe(\n          handler(decodedArgs),\n          Effect.provide(\n            Layer.mergeAll(\n              DatabaseReader.layer(schema, ctx.db),\n              Auth.layer(ctx.auth),\n              StorageReader.layer(ctx.storage),\n              QueryRunner.layer(ctx.runQuery),\n              Layer.succeed(\n                QueryCtx.QueryCtx<\n                  DataModel.ToConvex<DataModel.FromSchema<Schema>>\n                >(),\n                ctx,\n              ),\n            ),\n          ),\n        ),\n      ),\n      Effect.andThen((convexReturns) =>\n        Schema.encodeUnknown(returns)(convexReturns),\n      ),\n      Effect.runPromise,\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    Auth.layer(ctx.auth),\n    Scheduler.layer(ctx.scheduler),\n    StorageReader.layer(ctx.storage),\n    StorageWriter.layer(ctx.storage),\n    QueryRunner.layer(ctx.runQuery),\n    MutationRunner.layer(ctx.runMutation),\n    Layer.succeed(\n      MutationCtx.MutationCtx<\n        DataModel.ToConvex<DataModel.FromSchema<Schema>>\n      >(),\n      ctx,\n    ),\n  );\n\nexport type MutationServices<Schema extends DatabaseSchema.AnyWithProps> =\n  | DatabaseReader.DatabaseReader<Schema>\n  | DatabaseWriter.DatabaseWriter<Schema>\n  | Auth.Auth\n  | Scheduler.Scheduler\n  | StorageReader\n  | StorageWriter\n  | QueryRunner.QueryRunner\n  | MutationRunner.MutationRunner\n  | MutationCtx.MutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>;\n\nconst mutationFunction = <\n  Schema extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>(\n  schema: Schema,\n  {\n    args,\n    returns,\n    handler,\n  }: {\n    args: Schema.Schema<Args, ConvexArgs>;\n    returns: Schema.Schema<Returns, ConvexReturns>;\n    handler: (a: Args) => Effect.Effect<Returns, E, MutationServices<Schema>>;\n  },\n) => ({\n  args: SchemaToValidator.compileArgsSchema(args),\n  returns: SchemaToValidator.compileReturnsSchema(returns),\n  handler: (\n    ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n    actualArgs: ConvexArgs,\n  ): Promise<ConvexReturns> =>\n    pipe(\n      actualArgs,\n      Schema.decode(args),\n      Effect.orDie,\n      Effect.andThen((decodedArgs) =>\n        handler(decodedArgs).pipe(Effect.provide(mutationLayer(schema, ctx))),\n      ),\n      Effect.andThen((convexReturns) =>\n        Schema.encodeUnknown(returns)(convexReturns),\n      ),\n      Effect.runPromise,\n    ),\n});\n\nconst actionFunction = <\n  Schema extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>({\n  args,\n  returns,\n  handler,\n}: {\n  args: Schema.Schema<Args, ConvexArgs>;\n  returns: Schema.Schema<Returns, ConvexReturns>;\n  handler: (\n    a: Args,\n  ) => Effect.Effect<\n    Returns,\n    E,\n    | Scheduler.Scheduler\n    | Auth.Auth\n    | StorageReader\n    | StorageWriter\n    | StorageActionWriter\n    | QueryRunner.QueryRunner\n    | MutationRunner.MutationRunner\n    | ActionRunner.ActionRunner\n    | VectorSearch.VectorSearch<DataModel.FromSchema<Schema>>\n    | ActionCtx.ActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>\n  >;\n}) => ({\n  args: SchemaToValidator.compileArgsSchema(args),\n  returns: SchemaToValidator.compileReturnsSchema(returns),\n  handler: (\n    ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n    actualArgs: ConvexArgs,\n  ): Promise<ConvexReturns> =>\n    pipe(\n      actualArgs,\n      Schema.decode(args),\n      Effect.orDie,\n      Effect.andThen((decodedArgs) =>\n        pipe(\n          handler(decodedArgs),\n          Effect.provide(\n            Layer.mergeAll(\n              Scheduler.layer(ctx.scheduler),\n              Auth.layer(ctx.auth),\n              StorageReader.layer(ctx.storage),\n              StorageWriter.layer(ctx.storage),\n              StorageActionWriter.layer(ctx.storage),\n              QueryRunner.layer(ctx.runQuery),\n              MutationRunner.layer(ctx.runMutation),\n              ActionRunner.layer(ctx.runAction),\n              VectorSearch.layer(ctx.vectorSearch),\n              Layer.succeed(\n                ActionCtx.ActionCtx<\n                  DataModel.ToConvex<DataModel.FromSchema<Schema>>\n                >(),\n                ctx,\n              ),\n            ),\n          ),\n        ),\n      ),\n      Effect.andThen((convexReturns) =>\n        Schema.encodeUnknown(returns)(convexReturns),\n      ),\n      Effect.runPromise,\n    ),\n});\n"],"mappings":"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"}

package/dist/Registry.d.ts

@@ -0,0 +1,15 @@
+import { AnyWithProps } from "./RegistryItem.js";
+import { Context, Ref } from "effect";
+
+//#region src/Registry.d.ts
+declare namespace Registry_d_exports {
+  export { Registry, RegistryItems };
+}
+interface RegistryItems {
+  readonly [key: string]: AnyWithProps | RegistryItems;
+}
+declare const Registry_base: Context.ReferenceClass<Registry, "@confect/server/Registry", Ref.Ref<RegistryItems>>;
+declare class Registry extends Registry_base {}
+//#endregion
+export { Registry, RegistryItems, Registry_d_exports };
+//# sourceMappingURL=Registry.d.ts.map

package/dist/Registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Registry.d.ts","names":[],"sources":["../src/Registry.ts"],"sourcesContent":[],"mappings":";;;;;;;UAGiB,aAAA;0BACS,eAA4B;;cACrD;cAEY,QAAA,SAAiB,aAAA"}

package/dist/Registry.js

@@ -0,0 +1,10 @@
+import { __export } from "./_virtual/rolldown_runtime.js";
+import { Context, Ref } from "effect";
+
+//#region src/Registry.ts
+var Registry_exports = /* @__PURE__ */ __export({ Registry: () => Registry });
+var Registry = class extends Context.Reference()("@confect/server/Registry", { defaultValue: () => Ref.unsafeMake({}) }) {};
+
+//#endregion
+export { Registry, Registry_exports };
+//# sourceMappingURL=Registry.js.map

package/dist/Registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Registry.js","names":[],"sources":["../src/Registry.ts"],"sourcesContent":["import { Context, Ref } from \"effect\";\nimport type * as RegistryItem from \"./RegistryItem\";\n\nexport interface RegistryItems {\n  readonly [key: string]: RegistryItem.AnyWithProps | RegistryItems;\n}\n\nexport class Registry extends Context.Reference<Registry>()(\n  \"@confect/server/Registry\",\n  {\n    defaultValue: () => Ref.unsafeMake<RegistryItems>({}),\n  },\n) {}\n"],"mappings":";;;;;AAOA,IAAa,WAAb,cAA8B,QAAQ,WAAqB,CACzD,4BACA,EACE,oBAAoB,IAAI,WAA0B,EAAE,CAAC,EACtD,CACF,CAAC"}

package/dist/RegistryItem.d.ts

@@ -0,0 +1,31 @@
+import { AnyWithProps as AnyWithProps$1 } from "./DatabaseSchema.js";
+import { AnyWithProps as AnyWithProps$2, Handler } from "./Handler.js";
+import * as FunctionSpec from "@confect/core/FunctionSpec";
+
+//#region src/RegistryItem.d.ts
+declare namespace RegistryItem_d_exports {
+  export { AnyWithProps, RegistryItem, TypeId, isRegistryItem, make };
+}
+declare const TypeId = "@confect/server/RegistryItem";
+type TypeId = typeof TypeId;
+declare const isRegistryItem: (value: unknown) => value is AnyWithProps;
+interface RegistryItem<DatabaseSchema_ extends AnyWithProps$1, FunctionSpec_ extends FunctionSpec.AnyWithProps> {
+  readonly [TypeId]: TypeId;
+  readonly function_: FunctionSpec_;
+  readonly handler: Handler<DatabaseSchema_, FunctionSpec_>;
+}
+interface AnyWithProps {
+  readonly [TypeId]: TypeId;
+  readonly function_: FunctionSpec.AnyWithProps;
+  readonly handler: AnyWithProps$2;
+}
+declare const make: <DatabaseSchema_ extends AnyWithProps$1, FunctionSpec_ extends FunctionSpec.AnyWithProps>({
+  function_,
+  handler
+}: {
+  function_: FunctionSpec_;
+  handler: Handler<DatabaseSchema_, FunctionSpec_>;
+}) => RegistryItem<DatabaseSchema_, FunctionSpec_>;
+//#endregion
+export { AnyWithProps, RegistryItem, RegistryItem_d_exports, TypeId, isRegistryItem, make };
+//# sourceMappingURL=RegistryItem.d.ts.map

package/dist/RegistryItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RegistryItem.d.ts","names":[],"sources":["../src/RegistryItem.ts"],"sourcesContent":[],"mappings":";;;;;;;;cAKa,MAAA;KACD,MAAA,UAAgB;cAEf,6CAA4C;UAOxC,qCACS,sCACF,YAAA,CAAa;YAEzB,MAAA,GAAS;sBACC;oBACF,QAAgB,iBAAiB;;UAGpC,YAAA;YACL,MAAA,GAAS;EApBR,SAAM,SAAA,EAqBG,YAAA,CAAa,YArBhB;EACP,SAAM,OAAA,EAqBE,cArBc;AAElC;AAOiB,cAeJ,IAfgB,EAAA,CAAA,wBAgBH,cAhBG,EAAA,sBAiBL,YAAA,CAAa,YAjBR,CAAA,CAAA;EAAA,SAAA;EAAA;CAAA,EAAA;EACH,SAAA,EAqBb,aArBa;EACF,OAAA,EAqBb,OArB0B,CAqBV,eArBU,EAqBO,aArBP,CAAA;CAEhB,EAAA,GAoBjB,YApBiB,CAoBJ,eApBI,EAoBa,aApBb,CAAA"}

package/dist/RegistryItem.js

@@ -0,0 +1,20 @@
+import { __export } from "./_virtual/rolldown_runtime.js";
+import { Predicate } from "effect";
+
+//#region src/RegistryItem.ts
+var RegistryItem_exports = /* @__PURE__ */ __export({
+	TypeId: () => TypeId,
+	isRegistryItem: () => isRegistryItem,
+	make: () => make
+});
+const TypeId = "@confect/server/RegistryItem";
+const isRegistryItem = (value) => Predicate.hasProperty(value, TypeId);
+const RegistryItemProto = { [TypeId]: TypeId };
+const make = ({ function_, handler }) => Object.assign(Object.create(RegistryItemProto), {
+	function_,
+	handler
+});
+
+//#endregion
+export { RegistryItem_exports, TypeId, isRegistryItem, make };
+//# sourceMappingURL=RegistryItem.js.map

package/dist/RegistryItem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RegistryItem.js","names":[],"sources":["../src/RegistryItem.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport { Predicate } from \"effect\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as Handler from \"./Handler\";\n\nexport const TypeId = \"@confect/server/RegistryItem\";\nexport type TypeId = typeof TypeId;\n\nexport const isRegistryItem = (value: unknown): value is AnyWithProps =>\n  Predicate.hasProperty(value, TypeId);\n\nconst RegistryItemProto = {\n  [TypeId]: TypeId,\n};\n\nexport interface RegistryItem<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n> {\n  readonly [TypeId]: TypeId;\n  readonly function_: FunctionSpec_;\n  readonly handler: Handler.Handler<DatabaseSchema_, FunctionSpec_>;\n}\n\nexport interface AnyWithProps {\n  readonly [TypeId]: TypeId;\n  readonly function_: FunctionSpec.AnyWithProps;\n  readonly handler: Handler.AnyWithProps;\n}\n\nexport const make = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n>({\n  function_,\n  handler,\n}: {\n  function_: FunctionSpec_;\n  handler: Handler.Handler<DatabaseSchema_, FunctionSpec_>;\n}): RegistryItem<DatabaseSchema_, FunctionSpec_> =>\n  Object.assign(Object.create(RegistryItemProto), {\n    function_,\n    handler,\n  });\n"],"mappings":";;;;;;;;;AAKA,MAAa,SAAS;AAGtB,MAAa,kBAAkB,UAC7B,UAAU,YAAY,OAAO,OAAO;AAEtC,MAAM,oBAAoB,GACvB,SAAS,QACX;AAiBD,MAAa,QAGX,EACA,WACA,cAKA,OAAO,OAAO,OAAO,OAAO,kBAAkB,EAAE;CAC9C;CACA;CACD,CAAC"}

package/dist/Scheduler.d.ts

@@ -0,0 +1,23 @@
+import { Context, DateTime, Duration, Effect, Layer } from "effect";
+import { OptionalRestArgs, SchedulableFunctionReference, Scheduler as Scheduler$1 } from "convex/server";
+import * as convex_values10 from "convex/values";
+
+//#region src/Scheduler.d.ts
+declare namespace Scheduler_d_exports {
+  export { Scheduler, layer };
+}
+declare const Scheduler: Context.Tag<{
+  runAfter: <FuncRef extends SchedulableFunctionReference>(delay: Duration.Duration, functionReference: FuncRef, ...args: OptionalRestArgs<FuncRef>) => Effect.Effect<convex_values10.GenericId<"_scheduled_functions">, never, never>;
+  runAt: <FuncRef extends SchedulableFunctionReference>(dateTime: DateTime.DateTime, functionReference: FuncRef, ...args: OptionalRestArgs<FuncRef>) => Effect.Effect<convex_values10.GenericId<"_scheduled_functions">, never, never>;
+}, {
+  runAfter: <FuncRef extends SchedulableFunctionReference>(delay: Duration.Duration, functionReference: FuncRef, ...args: OptionalRestArgs<FuncRef>) => Effect.Effect<convex_values10.GenericId<"_scheduled_functions">, never, never>;
+  runAt: <FuncRef extends SchedulableFunctionReference>(dateTime: DateTime.DateTime, functionReference: FuncRef, ...args: OptionalRestArgs<FuncRef>) => Effect.Effect<convex_values10.GenericId<"_scheduled_functions">, never, never>;
+}>;
+type Scheduler = typeof Scheduler.Identifier;
+declare const layer: (scheduler: Scheduler$1) => Layer.Layer<{
+  runAfter: <FuncRef extends SchedulableFunctionReference>(delay: Duration.Duration, functionReference: FuncRef, ...args: OptionalRestArgs<FuncRef>) => Effect.Effect<convex_values10.GenericId<"_scheduled_functions">, never, never>;
+  runAt: <FuncRef extends SchedulableFunctionReference>(dateTime: DateTime.DateTime, functionReference: FuncRef, ...args: OptionalRestArgs<FuncRef>) => Effect.Effect<convex_values10.GenericId<"_scheduled_functions">, never, never>;
+}, never, never>;
+//#endregion
+export { Scheduler, Scheduler_d_exports, layer };
+//# sourceMappingURL=Scheduler.d.ts.map

package/dist/Scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Scheduler.d.ts","names":[],"sources":["../src/Scheduler.ts"],"sourcesContent":[],"mappings":";;;;;;;;cAgCa,WAAS,OAAA,CAAA;6BAxBO,qCAClB,QAAA,CAAS,6BACG,kBACV,iBAAiB,aAAQ,MAAA,CAAA,OAAT,eAAA,CAAS;0BAQZ,wCACZ,QAAA,CAAS,6BACA,kBACV,iBAAiB,aAAQ,MAAA,CAAA,OAAT,eAAA,CAAS;;6BAdT,qCAClB,QAAA,CAAS,6BACG,kBACV,iBAAiB,aAAQ,MAAA,CAAA,OAAT,eAAA,CAAS;0BAQZ,wCACZ,QAAA,CAAS,6BACA,kBACV,iBAAiB,aAAQ,MAAA,CAAA,OAAT,eAAA,CAAS;;KAa1B,SAAA,UAAmB,SAAA,CAAU;AAH5B,cAKA,KAHZ,EAAA,CAAA,SAAA,EAGgC,WAHhC,EAAA,GAG+C,KAAA,CAAA,KAH/C,CAAA;EA1B4B,QAAA,EAAA,CAAA,gBAAA,4BAAA,CAAA,CAAA,KAAA,EAClB,QAAA,CAAS,QADS,EAAA,iBAAA,EAEN,OAFM,EAAA,GAAA,IAAA,EAGhB,gBAHgB,CAGC,OAHD,CAAA,EAAA,GAGS,MAAA,CAAA,MAHT,CAGA,eAAA,CAAS,SAHT,CAAA,sBAAA,CAAA,EAAA,KAAA,EAAA,KAAA,CAAA;EAClB,KAAA,EAAS,CAAA,gBAUM,4BAVN,CAAA,CAAA,QAAA,EAWN,QAAA,CAAS,QAXH,EAAA,iBAAA,EAYG,OAZH,EAAA,GAAA,IAAA,EAaP,gBAbO,CAaU,OAbV,CAAA,EAAA,GAakB,MAAA,CAAA,MAblB,CAaS,eAAA,CAAS,SAblB,CAAA,sBAAA,CAAA,EAAA,KAAA,EAAA,KAAA,CAAA;CACG,EAAA,KAAA,EAAA,KAAA,CAAA"}

package/dist/Scheduler.js

@@ -0,0 +1,24 @@
+import { __export } from "./_virtual/rolldown_runtime.js";
+import { Context, DateTime, Duration, Effect, Layer } from "effect";
+
+//#region src/Scheduler.ts
+var Scheduler_exports = /* @__PURE__ */ __export({
+	Scheduler: () => Scheduler,
+	layer: () => layer
+});
+const make = (scheduler) => ({
+	runAfter: (delay, functionReference, ...args) => {
+		const delayMs = Duration.toMillis(delay);
+		return Effect.promise(() => scheduler.runAfter(delayMs, functionReference, ...args));
+	},
+	runAt: (dateTime, functionReference, ...args) => {
+		const timestamp = DateTime.toEpochMillis(dateTime);
+		return Effect.promise(() => scheduler.runAt(timestamp, functionReference, ...args));
+	}
+});
+const Scheduler = Context.GenericTag("@confect/server/Scheduler");
+const layer = (scheduler) => Layer.succeed(Scheduler, make(scheduler));
+
+//#endregion
+export { Scheduler, Scheduler_exports, layer };
+//# sourceMappingURL=Scheduler.js.map

package/dist/Scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Scheduler.js","names":[],"sources":["../src/Scheduler.ts"],"sourcesContent":["import type {\n  OptionalRestArgs,\n  SchedulableFunctionReference,\n  Scheduler as ConvexScheduler,\n} from \"convex/server\";\nimport { Context, DateTime, Duration, Effect, Layer } from \"effect\";\n\nconst make = (scheduler: ConvexScheduler) => ({\n  runAfter: <FuncRef extends SchedulableFunctionReference>(\n    delay: Duration.Duration,\n    functionReference: FuncRef,\n    ...args: OptionalRestArgs<FuncRef>\n  ) => {\n    const delayMs = Duration.toMillis(delay);\n\n    return Effect.promise(() =>\n      scheduler.runAfter(delayMs, functionReference, ...args),\n    );\n  },\n  runAt: <FuncRef extends SchedulableFunctionReference>(\n    dateTime: DateTime.DateTime,\n    functionReference: FuncRef,\n    ...args: OptionalRestArgs<FuncRef>\n  ) => {\n    const timestamp = DateTime.toEpochMillis(dateTime);\n\n    return Effect.promise(() =>\n      scheduler.runAt(timestamp, functionReference, ...args),\n    );\n  },\n});\n\nexport const Scheduler = Context.GenericTag<ReturnType<typeof make>>(\n  \"@confect/server/Scheduler\",\n);\nexport type Scheduler = typeof Scheduler.Identifier;\n\nexport const layer = (scheduler: ConvexScheduler) =>\n  Layer.succeed(Scheduler, make(scheduler));\n"],"mappings":";;;;;;;;AAOA,MAAM,QAAQ,eAAgC;CAC5C,WACE,OACA,mBACA,GAAG,SACA;EACH,MAAM,UAAU,SAAS,SAAS,MAAM;AAExC,SAAO,OAAO,cACZ,UAAU,SAAS,SAAS,mBAAmB,GAAG,KAAK,CACxD;;CAEH,QACE,UACA,mBACA,GAAG,SACA;EACH,MAAM,YAAY,SAAS,cAAc,SAAS;AAElD,SAAO,OAAO,cACZ,UAAU,MAAM,WAAW,mBAAmB,GAAG,KAAK,CACvD;;CAEJ;AAED,MAAa,YAAY,QAAQ,WAC/B,4BACD;AAGD,MAAa,SAAS,cACpB,MAAM,QAAQ,WAAW,KAAK,UAAU,CAAC"}

package/dist/SchemaToValidator.d.ts

@@ -0,0 +1,88 @@
+import { Cause, Effect, Schema, SchemaAST } from "effect";
+import { PropertyValidators, VAny, VArray, VBoolean, VBytes, VFloat64, VId, VInt64, VLiteral, VNull, VObject, VOptional, VRecord, VString, VUnion, Validator } from "convex/values";
+import * as GenericId$1 from "@confect/core/GenericId";
+import * as effect_Types0 from "effect/Types";
+import { DeepMutable, IsAny, IsOptional, IsRecord, IsRecursive, IsUnion, IsValueLiteral, TypeError, UnionToTuple } from "@confect/core/Types";
+
+//#region src/SchemaToValidator.d.ts
+declare namespace SchemaToValidator_d_exports {
+  export { EmptyTupleIsNotSupportedError, IndexSignaturesAreNotSupportedError, MixedIndexAndPropertySignaturesAreNotSupportedError, OptionalTupleElementsAreNotSupportedError, ReadonlyRecordValue, ReadonlyValue, TableSchemaToTableValidator, TopLevelMustBeObjectError, TopLevelMustBeObjectOrUnionError, UndefinedOrValueToValidator, UnsupportedPropertySignatureKeyTypeError, UnsupportedSchemaTypeError, ValueToValidator, compileArgsSchema, compileAst, compileReturnsSchema, compileSchema, compileTableSchema, isRecursive };
+}
+declare const compileArgsSchema: <ConfectValue, ConvexValue>(argsSchema: Schema.Schema<ConfectValue, ConvexValue>) => PropertyValidators;
+declare const compileReturnsSchema: <ConfectValue, ConvexValue>(schema: Schema.Schema<ConfectValue, ConvexValue>) => Validator<any, any, any>;
+/**
+ * Convert a table `Schema` to a table `Validator`.
+ */
+type TableSchemaToTableValidator<TableSchema extends Schema.Schema.AnyNoContext> = ValueToValidator<TableSchema["Encoded"]> extends infer Vd extends VObject<any, any, any, any> | VUnion<any, any, any, any> ? Vd : never;
+declare const compileTableSchema: <TableSchema extends Schema.Schema.AnyNoContext>(schema: TableSchema) => TableSchemaToTableValidator<TableSchema>;
+type ReadonlyValue = string | number | bigint | boolean | ArrayBuffer | ReadonlyArrayValue | ReadonlyRecordValue | null;
+type ReadonlyArrayValue = readonly ReadonlyValue[];
+type ReadonlyRecordValue = {
+  readonly [key: string]: ReadonlyValue | undefined;
+};
+type ValueToValidator<Vl$1> = IsRecursive<Vl$1> extends true ? VAny : [Vl$1] extends [never] ? never : IsAny<Vl$1> extends true ? VAny : [Vl$1] extends [ReadonlyValue] ? Vl$1 extends {
+  __tableName: infer TableName extends string;
+} ? VId<GenericId$1.GenericId<TableName>> : IsValueLiteral<Vl$1> extends true ? VLiteral<Vl$1> : [Vl$1] extends [null] ? VNull : [Vl$1] extends [boolean] ? VBoolean : IsUnion<Vl$1> extends true ? UnionValueToValidator<Vl$1> : [Vl$1] extends [number] ? VFloat64 : [Vl$1] extends [bigint] ? VInt64 : [Vl$1] extends [string] ? VString : [Vl$1] extends [ArrayBuffer] ? VBytes : Vl$1 extends ReadonlyArray<ReadonlyValue> ? ArrayValueToValidator<Vl$1> : Vl$1 extends ReadonlyRecordValue ? RecordValueToValidator<Vl$1> : TypeError<"Unexpected value", Vl$1> : TypeError<"Provided value is not a valid Convex value", Vl$1>;
+type ArrayValueToValidator<Vl$1 extends ReadonlyArray<ReadonlyValue>> = Vl$1 extends ReadonlyArray<infer El extends ReadonlyValue> ? ValueToValidator<El> extends infer Vd extends Validator<any, any, any> ? VArray<DeepMutable<El[]>, Vd> : never : never;
+type RecordValueToValidator<Vl$1> = Vl$1 extends ReadonlyRecordValue ? { -readonly [K in keyof Vl$1]-?: IsAny<Vl$1[K]> extends true ? IsOptional<Vl$1, K> extends true ? VOptional<VAny> : VAny : UndefinedOrValueToValidator<Vl$1[K]> } extends infer VdRecord extends Record<string, any> ? { -readonly [K in keyof Vl$1]: undefined extends Vl$1[K] ? DeepMutable<Exclude<Vl$1[K], undefined>> : DeepMutable<Vl$1[K]> } extends infer VlRecord extends Record<string, any> ? IsRecord<VlRecord> extends true ? VRecord<VlRecord, VString, VdRecord[keyof VdRecord]> : VObject<VlRecord, VdRecord> : never : never : never;
+type UndefinedOrValueToValidator<Vl$1 extends ReadonlyValue | undefined> = undefined extends Vl$1 ? [Vl$1] extends [(infer Val extends ReadonlyValue) | undefined] ? ValueToValidator<Val> extends infer Vd extends Validator<any, "required", any> ? VOptional<Vd> : never : never : [Vl$1] extends [ReadonlyValue] ? ValueToValidator<Vl$1> : never;
+type UnionValueToValidator<Vl$1 extends ReadonlyValue> = [Vl$1] extends [ReadonlyValue] ? IsUnion<Vl$1> extends true ? UnionToTuple<Vl$1> extends infer VlTuple extends ReadonlyArray<ReadonlyValue> ? ValueTupleToValidatorTuple<VlTuple> extends infer VdTuple extends Validator<any, "required", any>[] ? VUnion<DeepMutable<Vl$1>, VdTuple> : TypeError<"Failed to convert value tuple to validator tuple"> : TypeError<"Failed to convert union to tuple"> : TypeError<"Expected a union of values, but got a single value instead"> : TypeError<"Provided value is not a valid Convex value">;
+type ValueTupleToValidatorTuple<VlTuple$1 extends ReadonlyArray<ReadonlyValue>> = VlTuple$1 extends [true, false, ...infer VlRest extends ReadonlyArray<ReadonlyValue>] | [false, true, ...infer VlRest extends ReadonlyArray<ReadonlyValue>] ? ValueTupleToValidatorTuple<VlRest> extends infer VdRest extends Validator<any, any, any>[] ? [VBoolean<boolean>, ...VdRest] : never : VlTuple$1 extends [infer Vl extends ReadonlyValue, ...infer VlRest extends ReadonlyArray<ReadonlyValue>] ? ValueToValidator<Vl> extends infer Vd extends Validator<any, any, any> ? ValueTupleToValidatorTuple<VlRest> extends infer VdRest extends Validator<any, "required", any>[] ? [Vd, ...VdRest] : never : never : [];
+declare const compileSchema: <T, E>(schema: Schema.Schema<T, E>) => ValueToValidator<(typeof schema)["Encoded"]>;
+declare const isRecursive: (ast: SchemaAST.AST) => boolean;
+declare const compileAst: (ast: SchemaAST.AST, isOptionalPropertyOfTypeLiteral?: boolean) => Effect.Effect<Validator<any, any, any>, UnsupportedSchemaTypeError | UnsupportedPropertySignatureKeyTypeError | IndexSignaturesAreNotSupportedError | MixedIndexAndPropertySignaturesAreNotSupportedError | OptionalTupleElementsAreNotSupportedError | EmptyTupleIsNotSupportedError>;
+declare const TopLevelMustBeObjectError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => Cause.YieldableError & {
+  readonly _tag: "TopLevelMustBeObjectError";
+} & Readonly<A>;
+declare class TopLevelMustBeObjectError extends TopLevelMustBeObjectError_base {
+  get message(): string;
+}
+declare const TopLevelMustBeObjectOrUnionError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => Cause.YieldableError & {
+  readonly _tag: "TopLevelMustBeObjectOrUnionError";
+} & Readonly<A>;
+declare class TopLevelMustBeObjectOrUnionError extends TopLevelMustBeObjectOrUnionError_base {
+  get message(): string;
+}
+declare const UnsupportedPropertySignatureKeyTypeError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => Cause.YieldableError & {
+  readonly _tag: "UnsupportedPropertySignatureKeyTypeError";
+} & Readonly<A>;
+declare class UnsupportedPropertySignatureKeyTypeError extends UnsupportedPropertySignatureKeyTypeError_base<{
+  readonly propertyKey: number | symbol;
+}> {
+  get message(): string;
+}
+declare const EmptyTupleIsNotSupportedError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => Cause.YieldableError & {
+  readonly _tag: "EmptyTupleIsNotSupportedError";
+} & Readonly<A>;
+declare class EmptyTupleIsNotSupportedError extends EmptyTupleIsNotSupportedError_base {
+  get message(): string;
+}
+declare const UnsupportedSchemaTypeError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => Cause.YieldableError & {
+  readonly _tag: "UnsupportedSchemaTypeError";
+} & Readonly<A>;
+declare class UnsupportedSchemaTypeError extends UnsupportedSchemaTypeError_base<{
+  readonly schemaType: SchemaAST.AST["_tag"];
+}> {
+  get message(): string;
+}
+declare const IndexSignaturesAreNotSupportedError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => Cause.YieldableError & {
+  readonly _tag: "IndexSignaturesAreNotSupportedError";
+} & Readonly<A>;
+declare class IndexSignaturesAreNotSupportedError extends IndexSignaturesAreNotSupportedError_base {
+  get message(): string;
+}
+declare const MixedIndexAndPropertySignaturesAreNotSupportedError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => Cause.YieldableError & {
+  readonly _tag: "MixedIndexAndPropertySignaturesAreNotSupportedError";
+} & Readonly<A>;
+declare class MixedIndexAndPropertySignaturesAreNotSupportedError extends MixedIndexAndPropertySignaturesAreNotSupportedError_base {
+  get message(): string;
+}
+declare const OptionalTupleElementsAreNotSupportedError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => Cause.YieldableError & {
+  readonly _tag: "OptionalTupleElementsAreNotSupportedError";
+} & Readonly<A>;
+declare class OptionalTupleElementsAreNotSupportedError extends OptionalTupleElementsAreNotSupportedError_base {
+  get message(): string;
+}
+//#endregion
+export { EmptyTupleIsNotSupportedError, IndexSignaturesAreNotSupportedError, MixedIndexAndPropertySignaturesAreNotSupportedError, OptionalTupleElementsAreNotSupportedError, ReadonlyRecordValue, ReadonlyValue, SchemaToValidator_d_exports, TableSchemaToTableValidator, TopLevelMustBeObjectError, TopLevelMustBeObjectOrUnionError, UndefinedOrValueToValidator, UnsupportedPropertySignatureKeyTypeError, UnsupportedSchemaTypeError, ValueToValidator, compileArgsSchema, compileAst, compileReturnsSchema, compileSchema, compileTableSchema, isRecursive };
+//# sourceMappingURL=SchemaToValidator.d.ts.map

package/dist/SchemaToValidator.d.ts.map

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