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

package/src/MutationCtx.ts

@@ -0,0 +1,45 @@
+import type * as IdScope from "@confect/core/IdScope";
+import type { GenericDataModel, GenericMutationCtx } from "convex/server";
+import * as Context from "effect/Context";
+import type * as ComponentCtx from "./ComponentCtx";
+import * as Layer from "effect/Layer";
+
+export type MutationCtxTag<
+  DataModel extends GenericDataModel,
+  Scope extends IdScope.IdScope = IdScope.App,
+> = Context.Service<
+  MutationCtx<DataModel, Scope>,
+  Scope extends IdScope.App
+    ? GenericMutationCtx<DataModel>
+    : ComponentCtx.Mutation<DataModel, Scope>
+>;
+
+export const MutationCtx = <
+  DataModel extends GenericDataModel,
+  Scope extends IdScope.IdScope = IdScope.App,
+>(): MutationCtxTag<DataModel, Scope> =>
+  Context.Service("@confect/server/MutationCtx");
+
+export type MutationCtx<
+  DataModel extends GenericDataModel,
+  Scope extends IdScope.IdScope = IdScope.App,
+> = Scope extends IdScope.App
+  ? GenericMutationCtx<DataModel>
+  : ComponentCtx.Identifier<"mutation", DataModel, Scope>;
+
+export const layer = <
+  DataModel extends GenericDataModel,
+  Scope extends IdScope.IdScope,
+>(
+  ctx: GenericMutationCtx<DataModel>,
+  scope: Scope,
+) => {
+  const tag = MutationCtx<DataModel, Scope>();
+  const { auth: _auth, ...componentCtx } = ctx;
+  return Layer.succeed(
+    tag,
+    (scope === "" ? ctx : componentCtx) as unknown as Context.Service.Shape<
+      typeof tag
+    >,
+  );
+};

package/src/MutationRunner.ts

@@ -0,0 +1,66 @@
+import * as Ref from "@confect/core/Ref";
+import type { GenericActionCtx } from "convex/server";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type * as Schema from "effect/Schema";
+import * as MutationTransactionContext from "./MutationTransactionContext";
+
+export type Options = MutationTransactionContext.MutationOptions;
+
+const run = Effect.fn("MutationRunner.runMutation")(
+  <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> => effect,
+);
+
+const make = (nativeRunMutation: GenericActionCtx<any>["runMutation"]) => {
+  function runMutation<Mutation extends Ref.AnyMutation>(
+    mutation: Mutation,
+    ...args: [...Ref.OptionalArgs<Mutation>, options?: undefined]
+  ): Effect.Effect<
+    Ref.Returns<Mutation>,
+    Ref.Error<Mutation> | Schema.SchemaError
+  >;
+  function runMutation<Mutation extends Ref.AnyMutation>(
+    mutation: Mutation,
+    args: Ref.Args<Mutation>,
+    options: Options | undefined,
+  ): Effect.Effect<
+    Ref.Returns<Mutation>,
+    Ref.Error<Mutation> | Schema.SchemaError,
+    MutationTransactionContext.MutationTransactionContext
+  >;
+  function runMutation<Mutation extends Ref.AnyMutation>(
+    mutation: Mutation,
+    args?: Ref.Args<Mutation>,
+    options?: Options,
+  ): Effect.Effect<
+    Ref.Returns<Mutation>,
+    Ref.Error<Mutation> | Schema.SchemaError,
+    MutationTransactionContext.MutationTransactionContext
+  > {
+    return run(
+      Effect.gen(function* () {
+        const actualArgs = (args ?? {}) as Ref.Args<Mutation>;
+        if (options !== undefined) {
+          const controls =
+            yield* MutationTransactionContext.MutationTransactionContext;
+          return yield* controls.runMutation(mutation, actualArgs, options);
+        }
+        return yield* Ref.runWithCodec(
+          mutation,
+          actualArgs,
+          (ref, encodedArgs) => nativeRunMutation(ref, encodedArgs),
+        );
+      }),
+    );
+  }
+  return { runMutation };
+};
+
+export const MutationRunner = Context.Service<ReturnType<typeof make>>(
+  "@confect/server/MutationRunner",
+);
+export type MutationRunner = typeof MutationRunner.Identifier;
+
+export const layer = (runMutation: GenericActionCtx<any>["runMutation"]) =>
+  Layer.succeed(MutationRunner, make(runMutation));

package/src/MutationTransactionContext.ts

@@ -0,0 +1,48 @@
+import * as Ref from "@confect/core/Ref";
+import type {
+  AdvancedRunQueryOptions,
+  GenericDataModel,
+  GenericMutationCtx,
+} from "convex/server";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type { Options as MutationOptions } from "./QueryTransactionContext";
+
+export type { TransactionLimits } from "convex/server";
+export type { Options as MutationOptions } from "./QueryTransactionContext";
+export type QueryOptions = AdvancedRunQueryOptions;
+
+const make = (
+  ctx: Pick<GenericMutationCtx<GenericDataModel>, "runQuery" | "runMutation">,
+) => ({
+  runQuery: Effect.fn("MutationTransactionContext.runQuery")(
+    <Query extends Ref.AnyQuery>(
+      query: Query,
+      args: Ref.Args<Query>,
+      options: QueryOptions,
+    ) =>
+      Ref.runWithCodec(query, args, (ref, encodedArgs) =>
+        ctx.runQuery(ref, encodedArgs, options),
+      ),
+  ),
+  runMutation: Effect.fn("MutationTransactionContext.runMutation")(
+    <Mutation extends Ref.AnyMutation>(
+      mutation: Mutation,
+      args: Ref.Args<Mutation>,
+      options: MutationOptions,
+    ) =>
+      Ref.runWithCodec(mutation, args, (ref, encodedArgs) =>
+        ctx.runMutation(ref, encodedArgs, options),
+      ),
+  ),
+});
+
+export class MutationTransactionContext extends Context.Service<
+  MutationTransactionContext,
+  ReturnType<typeof make>
+>()("@confect/server/MutationTransactionContext") {}
+
+export const layer = (
+  ctx: Pick<GenericMutationCtx<GenericDataModel>, "runQuery" | "runMutation">,
+) => Layer.succeed(MutationTransactionContext, make(ctx));

package/src/OrderedQuery.ts

@@ -0,0 +1,136 @@
+import type * as IdScope from "@confect/core/IdScope";
+import type {
+  ExpressionOrValue,
+  FilterBuilder,
+  OrderedQuery as ConvexOrderedQuery,
+  PaginationOptions,
+  PaginationResult,
+} from "convex/server";
+import { identity, pipe } from "effect/Function";
+import type { Option } from "effect";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import type * as DatabaseSchema from "./DatabaseSchema";
+import * as Document from "./Document";
+import type * as TableInfo from "./TableInfo";
+import type * as Table from "./Table";
+
+type NativePaginate<TableInfo_ extends TableInfo.AnyWithProps, Doc> = (
+  options: PaginationOptions,
+  filter?: (
+    q: FilterBuilder<TableInfo.ConvexTableInfo<TableInfo_>>,
+  ) => ExpressionOrValue<boolean>,
+) => Effect.Effect<PaginationResult<Doc>, Document.DocumentDecodeError>;
+
+export type OrderedQuery<
+  TableInfo_ extends TableInfo.AnyWithProps,
+  Doc = TableInfo_["document"],
+  TargetKind extends DatabaseSchema.Target["kind"] = "app",
+> = {
+  readonly first: () => Effect.Effect<
+    Option.Option<Doc>,
+    Document.DocumentDecodeError
+  >;
+  readonly take: (
+    n: number,
+  ) => Effect.Effect<ReadonlyArray<Doc>, Document.DocumentDecodeError>;
+  readonly collect: () => Effect.Effect<
+    ReadonlyArray<Doc>,
+    Document.DocumentDecodeError
+  >;
+  readonly stream: () => Stream.Stream<Doc, Document.DocumentDecodeError>;
+  /**
+   * Native pagination is application-only. Use `QueryStream.paginate` for
+   * component index queries.
+   */
+  readonly paginate: {
+    readonly app: NativePaginate<TableInfo_, Doc>;
+    readonly component: {
+      readonly "Native pagination is unavailable in components. Use QueryStream.paginate for index queries.": never;
+    };
+  }[TargetKind];
+};
+
+export function make<Table_ extends Table.AnyWithProps>(
+  query: ConvexOrderedQuery<
+    TableInfo.ConvexTableInfo<TableInfo.TableInfo<Table_>>
+  >,
+  table: Table_ & { readonly scope: IdScope.App },
+): OrderedQuery<TableInfo.TableInfo<Table_>>;
+export function make<Table_ extends Table.AnyWithProps>(
+  query: ConvexOrderedQuery<
+    TableInfo.ConvexTableInfo<TableInfo.TableInfo<Table_>>
+  >,
+  table: Table_,
+): OrderedQuery<
+  TableInfo.TableInfo<Table_>,
+  TableInfo.TableInfo<Table_>["document"],
+  Table.Scope<Table_> extends IdScope.App ? "app" : "component"
+>;
+export function make<Table_ extends Table.AnyWithProps>(
+  query: ConvexOrderedQuery<
+    TableInfo.ConvexTableInfo<TableInfo.TableInfo<Table_>>
+  >,
+  table: Table_,
+): OrderedQuery<
+  TableInfo.TableInfo<Table_>,
+  TableInfo.TableInfo<Table_>["document"],
+  DatabaseSchema.Target["kind"]
+> {
+  type TableInfo_ = TableInfo.TableInfo<Table_>;
+  type OrderedQueryFunction<
+    FunctionName extends keyof OrderedQuery<TableInfo_>,
+  > = OrderedQuery<TableInfo_>[FunctionName];
+
+  const streamEncoded = Stream.fromAsyncIterable(query, identity).pipe(
+    Stream.orDie,
+  );
+
+  const stream: OrderedQueryFunction<"stream"> = () =>
+    pipe(streamEncoded, Stream.mapEffect(Document.decode(table)));
+
+  const first: OrderedQueryFunction<"first"> = () =>
+    pipe(stream(), Stream.take(1), Stream.runHead);
+
+  const take: OrderedQueryFunction<"take"> = (n: number) =>
+    pipe(stream(), Stream.take(n), Stream.runCollect);
+
+  const collect: OrderedQueryFunction<"collect"> = () =>
+    pipe(stream(), Stream.runCollect);
+
+  const paginate: NativePaginate<TableInfo_, TableInfo_["document"]> =
+    Effect.fn("OrderedQuery.paginate")(function* (options, filter) {
+      const filteredQuery = filter !== undefined ? query.filter(filter) : query;
+
+      const paginationResult = yield* Effect.promise(() =>
+        filteredQuery.paginate(options),
+      );
+
+      const parsedPage = yield* Effect.forEach(
+        paginationResult.page,
+        Document.decode(table),
+      );
+
+      return {
+        page: parsedPage,
+        isDone: paginationResult.isDone,
+        continueCursor: paginationResult.continueCursor,
+        /* v8 ignore start */
+        ...(paginationResult.splitCursor
+          ? { splitCursor: paginationResult.splitCursor }
+          : {}),
+        ...(paginationResult.pageStatus
+          ? { pageStatus: paginationResult.pageStatus }
+          : {}),
+        /* v8 ignore stop */
+      };
+    });
+
+  return {
+    first,
+    take,
+    collect,
+    paginate,
+    stream,
+  };
+}

package/src/QueryCtx.ts

@@ -0,0 +1,45 @@
+import type * as IdScope from "@confect/core/IdScope";
+import type { GenericDataModel, GenericQueryCtx } from "convex/server";
+import * as Context from "effect/Context";
+import type * as ComponentCtx from "./ComponentCtx";
+import * as Layer from "effect/Layer";
+
+export type QueryCtxTag<
+  DataModel extends GenericDataModel,
+  Scope extends IdScope.IdScope = IdScope.App,
+> = Context.Service<
+  QueryCtx<DataModel, Scope>,
+  Scope extends IdScope.App
+    ? GenericQueryCtx<DataModel>
+    : ComponentCtx.Query<DataModel, Scope>
+>;
+
+export const QueryCtx = <
+  DataModel extends GenericDataModel,
+  Scope extends IdScope.IdScope = IdScope.App,
+>(): QueryCtxTag<DataModel, Scope> =>
+  Context.Service("@confect/server/QueryCtx");
+
+export type QueryCtx<
+  DataModel extends GenericDataModel,
+  Scope extends IdScope.IdScope = IdScope.App,
+> = Scope extends IdScope.App
+  ? GenericQueryCtx<DataModel>
+  : ComponentCtx.Identifier<"query", DataModel, Scope>;
+
+export const layer = <
+  DataModel extends GenericDataModel,
+  Scope extends IdScope.IdScope,
+>(
+  ctx: GenericQueryCtx<DataModel>,
+  scope: Scope,
+) => {
+  const tag = QueryCtx<DataModel, Scope>();
+  const { auth: _auth, ...componentCtx } = ctx;
+  return Layer.succeed(
+    tag,
+    (scope === "" ? ctx : componentCtx) as unknown as Context.Service.Shape<
+      typeof tag
+    >,
+  );
+};