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

package/src/ResolvedMiddleware.ts

@@ -0,0 +1,70 @@
+import * as MiddlewareAttachment from "@confect/core/MiddlewareAttachment";
+import type * as MiddlewareSpec from "@confect/core/MiddlewareSpec";
+import * as Result from "effect/Result";
+import type * as FunctionRegistryItem from "./FunctionRegistryItem.js";
+import type * as MiddlewareRegistryItem from "./MiddlewareRegistryItem.js";
+
+/**
+ * A middleware spec paired with its implementation for one function's type—the
+ * resolved form consumed by runtime-specific function preparation.
+ */
+export interface ResolvedMiddleware {
+  readonly middlewareSpec: MiddlewareSpec.AnyMiddlewareSpec;
+  readonly middlewareImpl: MiddlewareSpec.AnyMiddlewareImpl;
+  readonly options?: unknown;
+}
+
+/**
+ * Pair each middleware spec attached to a function with its registered
+ * implementation for the function's type. Both misses are ruled out by the type
+ * system (`GroupImpl.finalize` demands every attached middleware's
+ * `MiddlewareImpl` service; `MiddlewareImpl.make`/`makeByFunctionType` cover
+ * exactly the declared functionTypes, which `GroupSpec.middleware` requires to
+ * cover every function). Spec identity is checked separately because
+ * implementation services are keyed by string, so the type system cannot
+ * distinguish same-key specs.
+ */
+export const resolve = (
+  functionRegistryItem: FunctionRegistryItem.ConfectFunctionRegistryItem,
+  middlewareRegistryItems: ReadonlyMap<
+    string,
+    MiddlewareRegistryItem.MiddlewareRegistryItem
+  >,
+): ReadonlyArray<ResolvedMiddleware> => {
+  Result.getOrThrowWith(
+    MiddlewareAttachment.validateAll(
+      functionRegistryItem.middlewareAttachments,
+      `function "${functionRegistryItem.name}"`,
+    ),
+    (error) => new Error(MiddlewareAttachment.formatValidationError(error)),
+  );
+  return functionRegistryItem.middlewareAttachments.map(
+    ({ spec: middlewareSpec, options }) => {
+      const registered = middlewareRegistryItems.get(middlewareSpec.key);
+      if (registered === undefined) {
+        throw new Error(
+          `Middleware "${middlewareSpec.key}" is attached to this group's spec, but no implementation was provided—pipe the group's impl through \`Layer.provide(MiddlewareImpl.make(...))\` (or \`makeByFunctionType\`/\`provides\`).`,
+        );
+      }
+      if (registered.middlewareSpec !== middlewareSpec) {
+        throw new Error(
+          `Middleware "${middlewareSpec.key}" attached to function "${functionRegistryItem.name}" has an implementation registered for a different spec with the same key. Register the implementation using the attached middleware spec.`,
+        );
+      }
+
+      const middlewareImpl =
+        registered.impls[functionRegistryItem.functionType];
+      if (middlewareImpl === undefined) {
+        throw new Error(
+          `Middleware "${middlewareSpec.key}" has no implementation for function type "${functionRegistryItem.functionType}", the type of function "${functionRegistryItem.name}". Declare the function type in the middleware's \`functionTypes\` and cover it in \`MiddlewareImpl.makeByFunctionType\`.`,
+        );
+      }
+
+      return {
+        middlewareImpl,
+        middlewareSpec,
+        options,
+      };
+    },
+  );
+};

package/src/Scheduler.ts

@@ -0,0 +1,85 @@
+import type * as IdScope from "@confect/core/IdScope";
+import { Ref } from "@confect/core";
+import type { GenericId } from "@confect/core/GenericId";
+import type { Scheduler as ConvexScheduler } from "convex/server";
+import type { GenericId as ConvexGenericId } from "convex/values";
+import * as Context from "effect/Context";
+import * as DateTime from "effect/DateTime";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+const make = (scheduler: ConvexScheduler) => ({
+  cancel: (id: ConvexGenericId<"_scheduled_functions">) =>
+    Effect.promise(() => scheduler.cancel(id)),
+  runAfter: <Ref_ extends Ref.AnyMutation | Ref.AnyAction>(
+    delay: Duration.Duration,
+    ref: Ref_,
+    ...args: Ref.OptionalArgs<Ref_>
+  ) => {
+    const delayMs = Duration.toMillis(delay);
+    const functionReference = Ref.getFunctionReference(ref);
+    const encodedArgs = Ref.encodeArgsSync(
+      ref,
+      (args[0] ?? {}) as Ref.Args<Ref_>,
+    );
+
+    return Effect.promise(() =>
+      scheduler.runAfter(delayMs, functionReference, encodedArgs),
+    );
+  },
+  runAt: <Ref_ extends Ref.AnyMutation | Ref.AnyAction>(
+    dateTime: DateTime.DateTime,
+    ref: Ref_,
+    ...args: Ref.OptionalArgs<Ref_>
+  ) => {
+    const timestamp = DateTime.toEpochMillis(dateTime);
+    const functionReference = Ref.getFunctionReference(ref);
+    const encodedArgs = Ref.encodeArgsSync(
+      ref,
+      (args[0] ?? {}) as Ref.Args<Ref_>,
+    );
+
+    return Effect.promise(() =>
+      scheduler.runAt(timestamp, functionReference, encodedArgs),
+    );
+  },
+});
+
+export const Scheduler = Context.Service<ReturnType<typeof make>>(
+  "@confect/server/Scheduler",
+);
+export type Scheduler = typeof Scheduler.Identifier;
+
+export interface Service<Scope extends IdScope.IdScope = IdScope.App> {
+  cancel(id: GenericId<"_scheduled_functions", Scope>): Effect.Effect<void>;
+  runAfter<Ref_ extends Ref.AnyMutation | Ref.AnyAction>(
+    delay: Duration.Duration,
+    ref: Ref_,
+    ...args: Ref.OptionalArgs<Ref_>
+  ): Effect.Effect<GenericId<"_scheduled_functions", Scope>>;
+  runAt<Ref_ extends Ref.AnyMutation | Ref.AnyAction>(
+    dateTime: DateTime.DateTime,
+    ref: Ref_,
+    ...args: Ref.OptionalArgs<Ref_>
+  ): Effect.Effect<GenericId<"_scheduled_functions", Scope>>;
+}
+
+export type ForScope<Scope extends IdScope.IdScope> = Scope extends IdScope.App
+  ? Scheduler
+  : { readonly "~ScopedScheduler": Scope };
+
+export const forScope = <
+  Scope extends IdScope.IdScope = IdScope.App,
+>(): Context.Service<ForScope<Scope>, Service<Scope>> =>
+  Context.Service("@confect/server/Scheduler");
+
+export const layer = <Scope extends IdScope.IdScope = IdScope.App>(
+  scheduler: ConvexScheduler,
+  _scope?: Scope,
+) =>
+  // Scopes are phantom: Convex still receives and returns the same ID strings.
+  Layer.succeed(
+    forScope<Scope>(),
+    make(scheduler) as unknown as Service<Scope>,
+  );

package/src/Storage.ts

@@ -0,0 +1,37 @@
+import type { StorageReader as ConvexStorageReader } from "convex/server";
+import type { GenericId } from "convex/values";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { StorageActionWriter } from "./StorageActionWriter.js";
+import { StorageReader } from "./StorageReader.js";
+import { StorageWriter } from "./StorageWriter.js";
+
+const make = Effect.gen(function* () {
+  const reader = yield* StorageReader;
+  return {
+    getUrl: reader.getUrl,
+    generateUploadUrl: Effect.flatMap(
+      StorageWriter,
+      (writer) => writer.generateUploadUrl,
+    ),
+    delete: (storageId: GenericId<"_storage">) =>
+      Effect.flatMap(StorageWriter, (writer) => writer.delete(storageId)),
+    get: (storageId: GenericId<"_storage">) =>
+      Effect.flatMap(StorageActionWriter, (writer) => writer.get(storageId)),
+    store: (blob: Blob, options?: { sha256?: string }) =>
+      Effect.flatMap(StorageActionWriter, (writer) =>
+        writer.store(blob, options),
+      ),
+  };
+});
+
+export class Storage extends Context.Service<
+  Storage,
+  Effect.Success<typeof make>
+>()("@confect/server/Storage") {}
+
+export const layer = (storageReader: ConvexStorageReader) =>
+  Layer.effect(Storage, make).pipe(
+    Layer.provideMerge(StorageReader.layer(storageReader)),
+  );

package/src/StorageActionWriter.ts

@@ -0,0 +1,59 @@
+import type * as IdScope from "@confect/core/IdScope";
+import type { StorageActionWriter as ConvexStorageActionWriter } from "convex/server";
+import type { GenericId } from "convex/values";
+import * as Context from "effect/Context";
+import { flow } from "effect/Function";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import { BlobNotFoundError } from "./BlobNotFoundError.js";
+import type * as ScopedId from "@confect/core/GenericId";
+
+export type Service<Scope extends IdScope.IdScope = IdScope.App> = {
+  get: (
+    id: ScopedId.GenericId<"_storage", Scope>,
+  ) => ReturnType<ReturnType<typeof make>["get"]>;
+  store: (
+    blob: Blob,
+    options?: { sha256?: string },
+  ) => Effect.Effect<ScopedId.GenericId<"_storage", Scope>>;
+};
+export type ForScope<Scope extends IdScope.IdScope> = Scope extends IdScope.App
+  ? StorageActionWriter
+  : { readonly "~ScopedStorageActionWriter": Scope };
+
+const make = (storageActionWriter: ConvexStorageActionWriter) => ({
+  get: (storageId: GenericId<"_storage">) =>
+    Effect.promise(() => storageActionWriter.get(storageId)).pipe(
+      Effect.andThen(
+        flow(
+          Option.fromNullishOr,
+          Option.match({
+            onNone: () => Effect.fail(new BlobNotFoundError({ id: storageId })),
+            onSome: Effect.succeed,
+          }),
+        ),
+      ),
+    ),
+  store: (blob: Blob, options?: { sha256?: string }) =>
+    Effect.promise(() => storageActionWriter.store(blob, options)),
+});
+
+export class StorageActionWriter extends Context.Service<
+  StorageActionWriter,
+  ReturnType<typeof make>
+>()("@confect/server/StorageActionWriter") {
+  static readonly forScope = <
+    Scope extends IdScope.IdScope = IdScope.App,
+  >(): Context.Service<ForScope<Scope>, Service<Scope>> =>
+    Context.Service("@confect/server/StorageActionWriter");
+
+  static readonly layer = <Scope extends IdScope.IdScope = IdScope.App>(
+    storageActionWriter: ConvexStorageActionWriter,
+    _scope?: Scope,
+  ) =>
+    Layer.succeed(
+      this.forScope<Scope>(),
+      make(storageActionWriter) as unknown as Service<Scope>,
+    );
+}

package/src/StorageReader.ts

@@ -0,0 +1,59 @@
+import type * as IdScope from "@confect/core/IdScope";
+import type { StorageReader as ConvexStorageReader } from "convex/server";
+import type { GenericId } from "convex/values";
+import * as Context from "effect/Context";
+import { flow, pipe } from "effect/Function";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { BlobNotFoundError } from "./BlobNotFoundError.js";
+import type * as ScopedId from "@confect/core/GenericId";
+
+export type Service<Scope extends IdScope.IdScope = IdScope.App> = {
+  getUrl: (
+    id: ScopedId.GenericId<"_storage", Scope>,
+  ) => ReturnType<ReturnType<typeof make>["getUrl"]>;
+};
+export type ForScope<Scope extends IdScope.IdScope> = Scope extends IdScope.App
+  ? StorageReader
+  : { readonly "~ScopedStorageReader": Scope };
+
+const make = (storageReader: ConvexStorageReader) => ({
+  getUrl: (storageId: GenericId<"_storage">) =>
+    Effect.promise(() => storageReader.getUrl(storageId)).pipe(
+      Effect.andThen(
+        flow(
+          Option.fromNullishOr,
+          Option.match({
+            onNone: () => Effect.fail(new BlobNotFoundError({ id: storageId })),
+            onSome: (doc) =>
+              pipe(
+                doc,
+                Schema.decodeEffect(Schema.URLFromString),
+                Effect.catchTag("SchemaError", Effect.die),
+              ),
+          }),
+        ),
+      ),
+    ),
+});
+
+export class StorageReader extends Context.Service<
+  StorageReader,
+  ReturnType<typeof make>
+>()("@confect/server/StorageReader") {
+  static readonly forScope = <
+    Scope extends IdScope.IdScope = IdScope.App,
+  >(): Context.Service<ForScope<Scope>, Service<Scope>> =>
+    Context.Service("@confect/server/StorageReader");
+
+  static readonly layer = <Scope extends IdScope.IdScope = IdScope.App>(
+    storageReader: ConvexStorageReader,
+    _scope?: Scope,
+  ) =>
+    Layer.succeed(
+      this.forScope<Scope>(),
+      make(storageReader) as unknown as Service<Scope>,
+    );
+}

package/src/StorageWriter.ts

@@ -0,0 +1,58 @@
+import type * as IdScope from "@confect/core/IdScope";
+import type { StorageWriter as ConvexStorageWriter } from "convex/server";
+import type { GenericId } from "convex/values";
+import * as Context from "effect/Context";
+import { pipe } from "effect/Function";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import { BlobNotFoundError } from "./BlobNotFoundError.js";
+import type * as ScopedId from "@confect/core/GenericId";
+
+export type Service<Scope extends IdScope.IdScope = IdScope.App> = {
+  generateUploadUrl: ReturnType<typeof make>["generateUploadUrl"];
+  delete: (
+    id: ScopedId.GenericId<"_storage", Scope>,
+  ) => ReturnType<ReturnType<typeof make>["delete"]>;
+};
+export type ForScope<Scope extends IdScope.IdScope> = Scope extends IdScope.App
+  ? StorageWriter
+  : { readonly "~ScopedStorageWriter": Scope };
+
+const make = (storageWriter: ConvexStorageWriter) => ({
+  generateUploadUrl: Effect.promise(() =>
+    storageWriter.generateUploadUrl(),
+  ).pipe(
+    Effect.andThen((url) =>
+      pipe(
+        url,
+        Schema.decodeEffect(Schema.URLFromString),
+        Effect.catchTag("SchemaError", Effect.die),
+      ),
+    ),
+  ),
+  delete: (storageId: GenericId<"_storage">) =>
+    Effect.tryPromise({
+      try: () => storageWriter.delete(storageId),
+      catch: () => new BlobNotFoundError({ id: storageId }),
+    }),
+});
+
+export class StorageWriter extends Context.Service<
+  StorageWriter,
+  ReturnType<typeof make>
+>()("@confect/server/StorageWriter") {
+  static readonly forScope = <
+    Scope extends IdScope.IdScope = IdScope.App,
+  >(): Context.Service<ForScope<Scope>, Service<Scope>> =>
+    Context.Service("@confect/server/StorageWriter");
+
+  static readonly layer = <Scope extends IdScope.IdScope = IdScope.App>(
+    storageWriter: ConvexStorageWriter,
+    _scope?: Scope,
+  ) =>
+    Layer.succeed(
+      this.forScope<Scope>(),
+      make(storageWriter) as unknown as Service<Scope>,
+    );
+}

package/src/Table.ts

@@ -0,0 +1,156 @@
+import type * as IdScope from "@confect/core/IdScope";
+import { compileTableSchema } from "@confect/core/SchemaToValidator";
+import * as Table_ from "@confect/core/Table";
+import * as Schema from "effect/Schema";
+import { defineTable, type TableDefinition } from "convex/server";
+
+export {
+  TypeId,
+  isTable,
+  isUnnamedTable,
+  make,
+  type Table,
+  type Any,
+  type AnyWithProps,
+  type UnnamedTable,
+  type UnnamedAny,
+  type UnnamedAnyWithProps,
+  type Name,
+  type TableSchema,
+  type TableValidator,
+  type Indexes,
+  type SearchIndexes,
+  type VectorIndexes,
+  type Doc,
+  type Fields,
+  type Scope,
+  type WithName,
+  type TablesRecord,
+} from "@confect/core/Table";
+
+// -----------------------------------------------------------------------------
+// tableDefinition
+// -----------------------------------------------------------------------------
+//
+// The deploy-time Convex `TableDefinition` is the part of a table that
+// belongs on the server: it value-imports `defineTable` from `convex/server`.
+// Specs and generated refs reach `Fields`/`Doc` through `@confect/core`,
+// so this helper is only called from `_generated/convexSchema.ts`.
+
+const tableDefinitionCache = new WeakMap<
+  Table_.AnyWithProps,
+  TableDefinition<any, any, any, any>
+>();
+
+export const tableDefinition = <Table extends Table_.AnyWithProps>(
+  table: Table,
+): TableDefinition<
+  Table_.TableValidator<Table>,
+  Table_.Indexes<Table>,
+  Table_.SearchIndexes<Table>,
+  Table_.VectorIndexes<Table>
+> => {
+  const cached = tableDefinitionCache.get(table);
+  if (cached !== undefined) {
+    return cached as TableDefinition<
+      Table_.TableValidator<Table>,
+      Table_.Indexes<Table>,
+      Table_.SearchIndexes<Table>,
+      Table_.VectorIndexes<Table>
+    >;
+  }
+
+  let definition: TableDefinition<any, any, any, any> = defineTable(
+    compileTableSchema(table.Fields, table.scope),
+  );
+  for (const [name, indexFields] of Object.entries(
+    table.indexes as Record<string, any>,
+  )) {
+    definition = definition.index(name, indexFields);
+  }
+  for (const [name, config] of Object.entries(
+    table.searchIndexes as Record<string, any>,
+  )) {
+    definition = definition.searchIndex(name, config);
+  }
+  for (const [name, config] of Object.entries(
+    table.vectorIndexes as Record<string, any>,
+  )) {
+    definition = definition.vectorIndex(name, config);
+  }
+
+  tableDefinitionCache.set(table, definition);
+  return definition as TableDefinition<
+    Table_.TableValidator<Table>,
+    Table_.Indexes<Table>,
+    Table_.SearchIndexes<Table>,
+    Table_.VectorIndexes<Table>
+  >;
+};
+
+// -----------------------------------------------------------------------------
+// System tables
+// -----------------------------------------------------------------------------
+
+export const scheduledFunctionsTable = Table_.make(() =>
+  Schema.Struct({
+    name: Schema.String,
+    args: Schema.Array(Schema.Any),
+    scheduledTime: Schema.Finite,
+    completedTime: Schema.optionalKey(Schema.Finite),
+    state: Schema.Union([
+      Schema.Struct({ kind: Schema.Literal("pending") }),
+      Schema.Struct({ kind: Schema.Literal("inProgress") }),
+      Schema.Struct({ kind: Schema.Literal("success") }),
+      Schema.Struct({
+        kind: Schema.Literal("failed"),
+        error: Schema.String,
+      }),
+      Schema.Struct({ kind: Schema.Literal("canceled") }),
+    ]),
+  }),
+)("_scheduled_functions");
+
+export const storageTable = Table_.make(() =>
+  Schema.Struct({
+    sha256: Schema.String,
+    size: Schema.Finite,
+    contentType: Schema.optionalKey(Schema.String),
+  }),
+)("_storage");
+
+export const systemTables = {
+  _scheduled_functions: scheduledFunctionsTable,
+  _storage: storageTable,
+} as const;
+
+const makeSystemTables = <const Scope_ extends IdScope.IdScope>(
+  scope: Scope_,
+) => ({
+  _scheduled_functions: Table_.make(() => scheduledFunctionsTable.Fields)(
+    "_scheduled_functions",
+    scope,
+  ),
+  _storage: Table_.make(() => storageTable.Fields)("_storage", scope),
+});
+
+const systemTablesByScope = new Map<
+  IdScope.IdScope,
+  Record<keyof typeof systemTables, Table_.AnyWithProps>
+>();
+
+export const systemTablesForScope = <const Scope_ extends IdScope.IdScope>(
+  scope: Scope_,
+): ReturnType<typeof makeSystemTables<Scope_>> => {
+  const cached = systemTablesByScope.get(scope);
+  if (cached !== undefined) {
+    // Each cache key is the scope used to construct both tables.
+    return cached as ReturnType<typeof makeSystemTables<Scope_>>;
+  }
+  const tables = makeSystemTables(scope);
+  systemTablesByScope.set(scope, tables);
+  return tables;
+};
+
+export type SystemTables<Scope_ extends IdScope.IdScope = IdScope.App> =
+  ReturnType<typeof systemTablesForScope<Scope_>>[keyof typeof systemTables];

package/src/TableInfo.ts

@@ -0,0 +1,106 @@
+import type * as IdScope from "@confect/core/IdScope";
+import type {
+  GenericDocument,
+  GenericFieldPaths,
+  GenericTableIndexes,
+  GenericTableSearchIndexes,
+  GenericTableVectorIndexes,
+  IdField,
+  SystemFields,
+  SystemIndexes,
+} from "convex/server";
+import type { GenericValidator } from "convex/values";
+import type { Schema, Types } from "effect";
+import type { WithSystemFields } from "@confect/core/SystemFields";
+import type * as Document_ from "./Document.js";
+import type * as Table from "./Table.js";
+
+export declare const TypeId: "~@confect/server/TableInfo";
+export type TypeId = typeof TypeId;
+
+export type TableInfo<Table_ extends Table.AnyWithProps> =
+  Table_ extends Table.Table<
+    infer TableName,
+    infer TableSchema_,
+    infer TableValidator,
+    infer Indexes,
+    infer SearchIndexes,
+    infer VectorIndexes,
+    infer Scope
+  >
+    ? {
+        readonly [TypeId]: TypeId;
+        readonly document: WithSystemFields<
+          TableName,
+          Schema.Schema.Type<TableSchema_>,
+          Scope
+        >;
+        readonly encodedDocument: WithSystemFields<
+          TableName,
+          Schema.Codec.Encoded<TableSchema_>,
+          Scope
+        >;
+        readonly convexDocument: ExtractConvexDocument<
+          TableName,
+          TableValidator,
+          Scope
+        >;
+        readonly fieldPaths:
+          | keyof IdField<TableName>
+          | ExtractFieldPaths<TableValidator>;
+        readonly indexes: Types.Simplify<Indexes & SystemIndexes>;
+        readonly searchIndexes: SearchIndexes;
+        readonly vectorIndexes: VectorIndexes;
+      }
+    : never;
+
+export interface Any {
+  readonly [TypeId]: TypeId;
+}
+
+export interface AnyWithProps extends Any {
+  readonly document: Document_.Any;
+  readonly encodedDocument: Document_.AnyEncoded;
+  readonly convexDocument: GenericDocument;
+  readonly fieldPaths: GenericFieldPaths;
+  readonly indexes: GenericTableIndexes;
+  readonly searchIndexes: GenericTableSearchIndexes;
+  readonly vectorIndexes: GenericTableVectorIndexes;
+}
+
+export type ConvexTableInfo<TableInfo_ extends AnyWithProps> = {
+  document: TableInfo_["convexDocument"];
+  fieldPaths: TableInfo_["fieldPaths"];
+  indexes: TableInfo_["indexes"];
+  searchIndexes: TableInfo_["searchIndexes"];
+  vectorIndexes: TableInfo_["vectorIndexes"];
+};
+
+export type TableSchema<TableInfo_ extends AnyWithProps> = Schema.Codec<
+  TableInfo_["document"],
+  TableInfo_["encodedDocument"]
+>;
+
+export type Document<TableInfo_ extends AnyWithProps> = TableInfo_["document"];
+
+// Vendored types from convex-js, partially modified.
+// See https://github.com/get-convex/convex-js/pull/14
+
+type ExtractFieldPaths<TableValidator extends GenericValidator> =
+  | TableValidator["fieldPaths"]
+  | keyof SystemFields;
+
+type ExtractConvexDocument<
+  TableName extends string,
+  TableValidator extends GenericValidator,
+  Scope extends IdScope.IdScope = IdScope.App,
+> =
+  WithSystemFields<
+    TableName,
+    TableValidator["type"],
+    Scope
+  > extends GenericDocument
+    ? WithSystemFields<TableName, TableValidator["type"], Scope>
+    : never;
+
+// End of vendored types from convex-js, partially modified.

package/src/TransactionMetadata.ts

@@ -0,0 +1,20 @@
+import type { QueryMeta } from "convex/server";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+export type { TransactionMetric, TransactionMetrics } from "convex/server";
+
+const make = (meta: Pick<QueryMeta, "getTransactionMetrics">) => ({
+  getMetrics: Effect.fn("TransactionMetadata.getMetrics")(() =>
+    Effect.promise(() => meta.getTransactionMetrics()),
+  ),
+});
+
+export class TransactionMetadata extends Context.Service<
+  TransactionMetadata,
+  ReturnType<typeof make>
+>()("@confect/server/TransactionMetadata") {}
+
+export const layer = (meta: Pick<QueryMeta, "getTransactionMetrics">) =>
+  Layer.succeed(TransactionMetadata, make(meta));