@confect/server 2.0.0 → 4.0.0

package/src/RegisteredFunction.ts

@@ -1,3 +1,5 @@
+import type { FunctionSpec, RuntimeAndFunctionType } from "@confect/core";
+import type * as FunctionProvenance from "@confect/core/FunctionProvenance";
 import {
   type DefaultFunctionArgs,
   type FunctionVisibility,
@@ -16,14 +18,99 @@ import * as MutationRunner from "./MutationRunner";
 import * as QueryRunner from "./QueryRunner";
 import * as Scheduler from "./Scheduler";
 import * as SchemaToValidator from "./SchemaToValidator";
-import { StorageActionWriter, StorageReader, StorageWriter } from "./Storage";
+import { StorageActionWriter } from "./StorageActionWriter";
+import { StorageReader } from "./StorageReader";
+import { StorageWriter } from "./StorageWriter";
 import * as VectorSearch from "./VectorSearch";
 
-export type RegisteredFunction =
+export type Any =
   | RegisteredQuery<FunctionVisibility, DefaultFunctionArgs, any>
   | RegisteredMutation<FunctionVisibility, DefaultFunctionArgs, any>
   | RegisteredAction<FunctionVisibility, DefaultFunctionArgs, any>;
 
+type ConfectRegisteredFunction<
+  FunctionSpec_ extends FunctionSpec.AnyWithProps,
+> =
+  FunctionSpec.EncodedArgs<FunctionSpec_> extends infer Args_ extends
+    DefaultFunctionArgs
+    ? RuntimeAndFunctionType.GetFunctionType<
+        FunctionSpec_["runtimeAndFunctionType"]
+      > extends "query"
+      ? RegisteredQuery<
+          FunctionSpec.GetFunctionVisibility<FunctionSpec_>,
+          Args_,
+          Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>
+        >
+      : RuntimeAndFunctionType.GetFunctionType<
+            FunctionSpec_["runtimeAndFunctionType"]
+          > extends "mutation"
+        ? RegisteredMutation<
+            FunctionSpec.GetFunctionVisibility<FunctionSpec_>,
+            Args_,
+            Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>
+          >
+        : RuntimeAndFunctionType.GetFunctionType<
+              FunctionSpec_["runtimeAndFunctionType"]
+            > extends "action"
+          ? RegisteredAction<
+              FunctionSpec.GetFunctionVisibility<FunctionSpec_>,
+              Args_,
+              Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>
+            >
+          : never
+    : never;
+
+export type ConvexRegisteredFunction<
+  FunctionSpec_ extends FunctionSpec.AnyWithProps,
+> = FunctionSpec_ extends {
+  functionProvenance: {
+    _tag: "Convex";
+    _args: infer Args_ extends DefaultFunctionArgs;
+    _returns: infer Returns_;
+  };
+}
+  ? RuntimeAndFunctionType.GetFunctionType<
+      FunctionSpec_["runtimeAndFunctionType"]
+    > extends "query"
+    ? RegisteredQuery<
+        FunctionSpec.GetFunctionVisibility<FunctionSpec_>,
+        Args_,
+        Returns_
+      >
+    : RuntimeAndFunctionType.GetFunctionType<
+          FunctionSpec_["runtimeAndFunctionType"]
+        > extends "mutation"
+      ? RegisteredMutation<
+          FunctionSpec.GetFunctionVisibility<FunctionSpec_>,
+          Args_,
+          Returns_
+        >
+      : RuntimeAndFunctionType.GetFunctionType<
+            FunctionSpec_["runtimeAndFunctionType"]
+          > extends "action"
+        ? RegisteredAction<
+            FunctionSpec.GetFunctionVisibility<FunctionSpec_>,
+            Args_,
+            Returns_
+          >
+        : never
+  : never;
+
+export type RegisteredFunction<
+  FunctionSpec_ extends FunctionSpec.AnyWithProps,
+> =
+  FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<
+    FunctionSpec_,
+    FunctionProvenance.AnyConvex
+  >
+    ? ConvexRegisteredFunction<FunctionSpec_>
+    : FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<
+          FunctionSpec_,
+          FunctionProvenance.AnyConfect
+        >
+      ? ConfectRegisteredFunction<FunctionSpec_>
+      : never;
+
 export const actionFunctionBase = <
   Schema extends DatabaseSchema.AnyWithProps,
   Args,

package/src/RegisteredFunctions.ts

@@ -27,8 +27,8 @@ type RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = {
             >]: FunctionSpec.WithName<
               GroupSpec.Functions<Group>,
               FunctionName
-            > extends infer Function extends FunctionSpec.AnyWithProps
-              ? FunctionSpec.RegisteredFunction<Function>
+            > extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps
+              ? RegisteredFunction.RegisteredFunction<FunctionSpec_>
               : never;
           }
         >
@@ -38,15 +38,15 @@ type RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = {
           >]: FunctionSpec.WithName<
             GroupSpec.Functions<Group>,
             FunctionName
-          > extends infer Function extends FunctionSpec.AnyWithProps
-            ? FunctionSpec.RegisteredFunction<Function>
+          > extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps
+            ? RegisteredFunction.RegisteredFunction<FunctionSpec_>
             : never;
         }
     : never;
 };
 
 export interface AnyWithProps {
-  readonly [key: string]: RegisteredFunction.RegisteredFunction | AnyWithProps;
+  readonly [key: string]: RegisteredFunction.Any | AnyWithProps;
 }
 
 export const make = <Api_ extends Api.AnyWithProps>(
@@ -54,7 +54,7 @@ export const make = <Api_ extends Api.AnyWithProps>(
   makeRegisteredFunction: (
     api: Api_,
     registryItem: RegistryItem.AnyWithProps,
-  ) => RegisteredFunction.RegisteredFunction,
+  ) => RegisteredFunction.Any,
 ) =>
   Effect.gen(function* () {
     const registry = yield* Registry.Registry;
@@ -70,11 +70,10 @@ export const make = <Api_ extends Api.AnyWithProps>(
       ),
       Match.when("Finalized", () =>
         Effect.succeed(
-          mapLeaves<
-            RegistryItem.AnyWithProps,
-            RegisteredFunction.RegisteredFunction
-          >(functionImplItems, RegistryItem.isRegistryItem, (registryItem) =>
-            makeRegisteredFunction(api, registryItem),
+          mapLeaves<RegistryItem.AnyWithProps, RegisteredFunction.Any>(
+            functionImplItems,
+            RegistryItem.isRegistryItem,
+            (registryItem) => makeRegisteredFunction(api, registryItem),
           ) as RegisteredFunctions<Api_["spec"]>,
         ),
       ),

package/src/RegisteredNodeFunction.ts

@@ -1,3 +1,4 @@
+import type * as FunctionSpec from "@confect/core/FunctionSpec";
 import { NodeContext } from "@effect/platform-node";
 import {
   actionGeneric,
@@ -8,27 +9,36 @@ import type { Effect } from "effect";
 import { Layer, Match, type Schema } from "effect";
 import type * as Api from "./Api";
 import type * as DatabaseSchema from "./DatabaseSchema";
+import type * as Handler from "./Handler";
 import * as RegisteredFunction from "./RegisteredFunction";
 import type * as RegistryItem from "./RegistryItem";
 
 export const make = <Api_ extends Api.AnyWithPropsWithRuntime<"Node">>(
   api: Api_,
-  { function_, handler }: RegistryItem.AnyWithProps,
-): RegisteredFunction.RegisteredFunction => {
-  const genericFunction = Match.value(function_.functionVisibility).pipe(
-    Match.when("public", () => actionGeneric),
-    Match.when("internal", () => internalActionGeneric),
-    Match.exhaustive,
-  );
+  { functionSpec, handler }: RegistryItem.AnyWithProps,
+): RegisteredFunction.Any =>
+  Match.value(functionSpec.functionProvenance).pipe(
+    Match.tag("Convex", () => handler as RegisteredFunction.Any),
+    Match.tag("Confect", () => {
+      const { functionVisibility, functionProvenance } =
+        functionSpec as FunctionSpec.AnyConfect;
 
-  return genericFunction(
-    nodeActionFunction(api.databaseSchema, {
-      args: function_.args,
-      returns: function_.returns,
-      handler,
+      const genericFunction = Match.value(functionVisibility).pipe(
+        Match.when("public", () => actionGeneric),
+        Match.when("internal", () => internalActionGeneric),
+        Match.exhaustive,
+      );
+
+      return genericFunction(
+        nodeActionFunction(api.databaseSchema, {
+          args: functionProvenance.args,
+          returns: functionProvenance.returns,
+          handler: handler as Handler.AnyConfectProvenance,
+        }),
+      );
     }),
+    Match.exhaustive,
   );
-};
 
 const nodeActionFunction = <
   DatabaseSchema_ extends DatabaseSchema.AnyWithProps,

package/src/RegistryItem.ts

@@ -18,27 +18,24 @@ export interface RegistryItem<
   FunctionSpec_ extends FunctionSpec.AnyWithProps,
 > {
   readonly [TypeId]: TypeId;
-  readonly function_: FunctionSpec_;
+  readonly functionSpec: FunctionSpec_;
   readonly handler: Handler.Handler<DatabaseSchema_, FunctionSpec_>;
 }
 
 export interface AnyWithProps {
   readonly [TypeId]: TypeId;
-  readonly function_: FunctionSpec.AnyWithProps;
-  readonly handler: Handler.AnyWithProps;
+  readonly functionSpec: FunctionSpec.AnyWithProps;
+  readonly handler: Handler.Any;
 }
 
-export const make = <
-  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
-  FunctionSpec_ extends FunctionSpec.AnyWithProps,
->({
-  function_,
+export const make = ({
+  functionSpec,
   handler,
 }: {
-  function_: FunctionSpec_;
-  handler: Handler.Handler<DatabaseSchema_, FunctionSpec_>;
-}): RegistryItem<DatabaseSchema_, FunctionSpec_> =>
+  functionSpec: FunctionSpec.AnyWithProps;
+  handler: AnyWithProps["handler"];
+}): AnyWithProps =>
   Object.assign(Object.create(RegistryItemProto), {
-    function_,
+    functionSpec,
     handler,
   });

package/src/StorageActionWriter.ts

@@ -0,0 +1,28 @@
+import type { StorageActionWriter as ConvexStorageActionWriter } from "convex/server";
+import type { GenericId } from "convex/values";
+import { Effect, flow, Layer, Option } from "effect";
+import { BlobNotFoundError } from "./BlobNotFoundError";
+
+const make = (storageActionWriter: ConvexStorageActionWriter) => ({
+  get: (storageId: GenericId<"_storage">) =>
+    Effect.promise(() => storageActionWriter.get(storageId)).pipe(
+      Effect.andThen(
+        flow(
+          Option.fromNullable,
+          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 Effect.Tag(
+  "@confect/server/StorageActionWriter",
+)<StorageActionWriter, ReturnType<typeof make>>() {
+  static readonly layer = (storageActionWriter: ConvexStorageActionWriter) =>
+    Layer.succeed(this, make(storageActionWriter));
+}

package/src/StorageReader.ts

@@ -0,0 +1,27 @@
+import type { StorageReader as ConvexStorageReader } from "convex/server";
+import type { GenericId } from "convex/values";
+import { Effect, flow, Layer, Option, pipe, Schema } from "effect";
+import { BlobNotFoundError } from "./BlobNotFoundError";
+
+const make = (storageReader: ConvexStorageReader) => ({
+  getUrl: (storageId: GenericId<"_storage">) =>
+    Effect.promise(() => storageReader.getUrl(storageId)).pipe(
+      Effect.andThen(
+        flow(
+          Option.fromNullable,
+          Option.match({
+            onNone: () => Effect.fail(new BlobNotFoundError({ id: storageId })),
+            onSome: (doc) => pipe(doc, Schema.decode(Schema.URL), Effect.orDie),
+          }),
+        ),
+      ),
+    ),
+});
+
+export class StorageReader extends Effect.Tag("@confect/server/StorageReader")<
+  StorageReader,
+  ReturnType<typeof make>
+>() {
+  static readonly layer = (storageReader: ConvexStorageReader) =>
+    Layer.succeed(this, make(storageReader));
+}

package/src/StorageWriter.ts

@@ -0,0 +1,26 @@
+import type { StorageWriter as ConvexStorageWriter } from "convex/server";
+import type { GenericId } from "convex/values";
+import { Effect, Layer, pipe, Schema } from "effect";
+import { BlobNotFoundError } from "./BlobNotFoundError";
+
+const make = (storageWriter: ConvexStorageWriter) => ({
+  generateUploadUrl: () =>
+    Effect.promise(() => storageWriter.generateUploadUrl()).pipe(
+      Effect.andThen((url) =>
+        pipe(url, Schema.decode(Schema.URL), Effect.orDie),
+      ),
+    ),
+  delete: (storageId: GenericId<"_storage">) =>
+    Effect.tryPromise({
+      try: () => storageWriter.delete(storageId),
+      catch: () => new BlobNotFoundError({ id: storageId }),
+    }),
+});
+
+export class StorageWriter extends Effect.Tag("@confect/server/StorageWriter")<
+  StorageWriter,
+  ReturnType<typeof make>
+>() {
+  static readonly layer = (storageWriter: ConvexStorageWriter) =>
+    Layer.succeed(this, make(storageWriter));
+}

package/src/index.ts

@@ -2,12 +2,15 @@ export * as ActionCtx from "./ActionCtx";
 export * as ActionRunner from "./ActionRunner";
 export * as Api from "./Api";
 export * as Auth from "./Auth";
+export * as BlobNotFoundError from "./BlobNotFoundError";
+export * as ConvexConfigProvider from "./ConvexConfigProvider";
+export * as CronJob from "./CronJob";
+export * as CronJobs from "./CronJobs";
 export * as DatabaseReader from "./DatabaseReader";
 export * as DatabaseSchema from "./DatabaseSchema";
 export * as DatabaseWriter from "./DatabaseWriter";
 export * as DataModel from "./DataModel";
 export * as Document from "./Document";
-export * as ConvexConfigProvider from "./ConvexConfigProvider";
 export * as FunctionImpl from "./FunctionImpl";
 export * as GroupImpl from "./GroupImpl";
 export * as Handler from "./Handler";
@@ -26,7 +29,9 @@ export * as Registry from "./Registry";
 export * as RegistryItem from "./RegistryItem";
 export * as Scheduler from "./Scheduler";
 export * as SchemaToValidator from "./SchemaToValidator";
-export * as Storage from "./Storage";
+export * as StorageActionWriter from "./StorageActionWriter";
+export * as StorageReader from "./StorageReader";
+export * as StorageWriter from "./StorageWriter";
 export * as Table from "./Table";
 export * as TableInfo from "./TableInfo";
 export * as VectorSearch from "./VectorSearch";

package/dist/Storage.d.ts

@@ -1,69 +0,0 @@
-import { Effect, Layer, Schema } from "effect";
-import { StorageActionWriter as StorageActionWriter$1, StorageReader as StorageReader$1, StorageWriter as StorageWriter$1 } from "convex/server";
-import { GenericId } from "convex/values";
-import * as effect_Context0 from "effect/Context";
-import * as effect_Cause0 from "effect/Cause";
-
-//#region src/Storage.d.ts
-declare namespace Storage_d_exports {
-  export { BlobNotFoundError, StorageActionWriter, StorageReader, StorageWriter };
-}
-declare const StorageReader_base: effect_Context0.TagClass<StorageReader, "@confect/server/Storage/StorageReader", {
-  getUrl: (storageId: GenericId<"_storage">) => Effect.Effect<URL, BlobNotFoundError, never>;
-}> & Effect.Tag.Proxy<StorageReader, {
-  getUrl: (storageId: GenericId<"_storage">) => Effect.Effect<URL, BlobNotFoundError, never>;
-}> & {
-  use: <X>(body: (_: {
-    getUrl: (storageId: GenericId<"_storage">) => Effect.Effect<URL, BlobNotFoundError, never>;
-  }) => X) => [X] extends [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E, R | StorageReader> : [X] extends [PromiseLike<infer A_1>] ? Effect.Effect<A_1, effect_Cause0.UnknownException, StorageReader> : Effect.Effect<X, never, StorageReader>;
-};
-declare class StorageReader extends StorageReader_base {
-  static readonly layer: (storageReader: StorageReader$1) => Layer.Layer<StorageReader, never, never>;
-}
-declare const StorageWriter_base: effect_Context0.TagClass<StorageWriter, "@confect/server/Storage/StorageWriter", {
-  generateUploadUrl: () => Effect.Effect<URL, never, never>;
-  delete: (storageId: GenericId<"_storage">) => Effect.Effect<void, BlobNotFoundError, never>;
-}> & Effect.Tag.Proxy<StorageWriter, {
-  generateUploadUrl: () => Effect.Effect<URL, never, never>;
-  delete: (storageId: GenericId<"_storage">) => Effect.Effect<void, BlobNotFoundError, never>;
-}> & {
-  use: <X>(body: (_: {
-    generateUploadUrl: () => Effect.Effect<URL, never, never>;
-    delete: (storageId: GenericId<"_storage">) => Effect.Effect<void, BlobNotFoundError, never>;
-  }) => X) => [X] extends [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E, R | StorageWriter> : [X] extends [PromiseLike<infer A_1>] ? Effect.Effect<A_1, effect_Cause0.UnknownException, StorageWriter> : Effect.Effect<X, never, StorageWriter>;
-};
-declare class StorageWriter extends StorageWriter_base {
-  static readonly layer: (storageWriter: StorageWriter$1) => Layer.Layer<StorageWriter, never, never>;
-}
-declare const StorageActionWriter_base: effect_Context0.TagClass<StorageActionWriter, "@confect/server/Storage/StorageActionWriter", {
-  get: (storageId: GenericId<"_storage">) => Effect.Effect<Blob, BlobNotFoundError, never>;
-  store: (blob: Blob, options?: {
-    sha256?: string;
-  }) => Effect.Effect<GenericId<"_storage">, never, never>;
-}> & Effect.Tag.Proxy<StorageActionWriter, {
-  get: (storageId: GenericId<"_storage">) => Effect.Effect<Blob, BlobNotFoundError, never>;
-  store: (blob: Blob, options?: {
-    sha256?: string;
-  }) => Effect.Effect<GenericId<"_storage">, never, never>;
-}> & {
-  use: <X>(body: (_: {
-    get: (storageId: GenericId<"_storage">) => Effect.Effect<Blob, BlobNotFoundError, never>;
-    store: (blob: Blob, options?: {
-      sha256?: string;
-    }) => Effect.Effect<GenericId<"_storage">, never, never>;
-  }) => X) => [X] extends [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E, R | StorageActionWriter> : [X] extends [PromiseLike<infer A_1>] ? Effect.Effect<A_1, effect_Cause0.UnknownException, StorageActionWriter> : Effect.Effect<X, never, StorageActionWriter>;
-};
-declare class StorageActionWriter extends StorageActionWriter_base {
-  static readonly layer: (storageActionWriter: StorageActionWriter$1) => Layer.Layer<StorageActionWriter, never, never>;
-}
-declare const BlobNotFoundError_base: Schema.TaggedErrorClass<BlobNotFoundError, "BlobNotFoundError", {
-  readonly _tag: Schema.tag<"BlobNotFoundError">;
-} & {
-  id: typeof Schema.String;
-}>;
-declare class BlobNotFoundError extends BlobNotFoundError_base {
-  get message(): string;
-}
-//#endregion
-export { BlobNotFoundError, StorageActionWriter, StorageReader, StorageWriter, Storage_d_exports };
-//# sourceMappingURL=Storage.d.ts.map

package/dist/Storage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Storage.d.ts","names":[],"sources":["../src/Storage.ts"],"mappings":";;;;;;;;;;cAMmE,kBAAA,EAGxB,eAAA,CAAA,QAAA;sBAArB,SAAA,iBAAqB,MAAA,CAAA,MAAA,CAAA,GAAA,EAAA,iBAAA;AAAA;sBAArB,SAAA,iBAAqB,MAAA,CAAA,MAAA,CAAA,GAAA,EAAA,iBAAA;AAAA;;wBAArB,SAAA,iBAAqB,MAAA,CAAA,MAAA,CAAA,GAAA,EAAA,iBAAA;EAAA;;cA+C9B,aAAA,SAAsB,kBAAA;EAAA,gBAGjB,KAAA,GAAS,aAAA,EAAe,eAAA,KAAmB,KAAA,CAAA,KAAA,CAAA,aAAA;AAAA;AAAA,cAE5D,kBAAA,EA/B0C,eAAA,CAAA,QAAA;;sBAArB,SAAA,iBAAqB,MAAA,CAAA,MAAA,OAAA,iBAAA;AAAA;;sBAArB,SAAA,iBAAqB,MAAA,CAAA,MAAA,OAAA,iBAAA;AAAA;;;wBAArB,SAAA,iBAAqB,MAAA,CAAA,MAAA,OAAA,iBAAA;EAAA;;cAiC9B,aAAA,SAAsB,kBAAA;EAAA,gBAGjB,KAAA,GAAS,aAAA,EAAe,eAAA,KAAmB,KAAA,CAAA,KAAA,CAAA,aAAA;AAAA;AAAA,cAE5D,wBAAA,EAhBkD,eAAA,CAAA,QAAA;mBAZhC,SAAA,iBAAqB,MAAA,CAAA,MAAA,CAAA,IAAA,EAAA,iBAAA;gBAYxB,IAAA,EAAI,OAAA;IAAc,MAAA;EAAA,MAAiB,MAAA,CAAA,MAAA,CAAA,SAAA;AAAA;mBAZhC,SAAA,iBAAqB,MAAA,CAAA,MAAA,CAAA,IAAA,EAAA,iBAAA;gBAYxB,IAAA,EAAI,OAAA;IAAc,MAAA;EAAA,MAAiB,MAAA,CAAA,MAAA,CAAA,SAAA;AAAA;;qBAZhC,SAAA,iBAAqB,MAAA,CAAA,MAAA,CAAA,IAAA,EAAA,iBAAA;kBAYxB,IAAA,EAAI,OAAA;MAAc,MAAA;IAAA,MAAiB,MAAA,CAAA,MAAA,CAAA,SAAA;EAAA;;cAkBtC,mBAAA,SAA4B,wBAAA;EAAA,gBAGvB,KAAA,GAAS,mBAAA,EAAqB,qBAAA,KAAyB,KAAA,CAAA,KAAA,CAAA,mBAAA;AAAA;AAAA,cAExE,sBAAA;;;;;cAEY,iBAAA,SAA0B,sBAAA;EAAA,IAMxB,OAAA,CAAA;AAAA"}

package/dist/Storage.js

@@ -1,46 +0,0 @@
-import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { Effect, Layer, Option, Schema, flow, pipe } from "effect";
-
-//#region src/Storage.ts
-var Storage_exports = /* @__PURE__ */ __exportAll({
-	BlobNotFoundError: () => BlobNotFoundError,
-	StorageActionWriter: () => StorageActionWriter,
-	StorageReader: () => StorageReader,
-	StorageWriter: () => StorageWriter
-});
-const makeStorageReader = (storageReader) => ({ getUrl: (storageId) => Effect.promise(() => storageReader.getUrl(storageId)).pipe(Effect.andThen(flow(Option.fromNullable, Option.match({
-	onNone: () => Effect.fail(new BlobNotFoundError({ id: storageId })),
-	onSome: (doc) => pipe(doc, Schema.decode(Schema.URL), Effect.orDie)
-})))) });
-const makeStorageWriter = (storageWriter) => ({
-	generateUploadUrl: () => Effect.promise(() => storageWriter.generateUploadUrl()).pipe(Effect.andThen((url) => pipe(url, Schema.decode(Schema.URL), Effect.orDie))),
-	delete: (storageId) => Effect.tryPromise({
-		try: () => storageWriter.delete(storageId),
-		catch: () => new BlobNotFoundError({ id: storageId })
-	})
-});
-const makeStorageActionWriter = (storageActionWriter) => ({
-	get: (storageId) => Effect.promise(() => storageActionWriter.get(storageId)).pipe(Effect.andThen(flow(Option.fromNullable, Option.match({
-		onNone: () => Effect.fail(new BlobNotFoundError({ id: storageId })),
-		onSome: Effect.succeed
-	})))),
-	store: (blob, options) => Effect.promise(() => storageActionWriter.store(blob, options))
-});
-var StorageReader = class extends Effect.Tag("@confect/server/Storage/StorageReader")() {
-	static layer = (storageReader) => Layer.succeed(this, makeStorageReader(storageReader));
-};
-var StorageWriter = class extends Effect.Tag("@confect/server/Storage/StorageWriter")() {
-	static layer = (storageWriter) => Layer.succeed(this, makeStorageWriter(storageWriter));
-};
-var StorageActionWriter = class extends Effect.Tag("@confect/server/Storage/StorageActionWriter")() {
-	static layer = (storageActionWriter) => Layer.succeed(this, makeStorageActionWriter(storageActionWriter));
-};
-var BlobNotFoundError = class extends Schema.TaggedError()("BlobNotFoundError", { id: Schema.String }) {
-	get message() {
-		return `File with ID '${this.id}' not found`;
-	}
-};
-
-//#endregion
-export { BlobNotFoundError, StorageActionWriter, StorageReader, StorageWriter, Storage_exports };
-//# sourceMappingURL=Storage.js.map

package/dist/Storage.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Storage.js","names":[],"sources":["../src/Storage.ts"],"sourcesContent":["import type {\n  StorageActionWriter as ConvexStorageActionWriter,\n  StorageReader as ConvexStorageReader,\n  StorageWriter as ConvexStorageWriter,\n} from \"convex/server\";\nimport type { GenericId } from \"convex/values\";\nimport { Effect, flow, Layer, Option, pipe, Schema } from \"effect\";\n\nconst makeStorageReader = (storageReader: ConvexStorageReader) => ({\n  getUrl: (storageId: GenericId<\"_storage\">) =>\n    Effect.promise(() => storageReader.getUrl(storageId)).pipe(\n      Effect.andThen(\n        flow(\n          Option.fromNullable,\n          Option.match({\n            onNone: () => Effect.fail(new BlobNotFoundError({ id: storageId })),\n            onSome: (doc) => pipe(doc, Schema.decode(Schema.URL), Effect.orDie),\n          }),\n        ),\n      ),\n    ),\n});\n\nconst makeStorageWriter = (storageWriter: ConvexStorageWriter) => ({\n  generateUploadUrl: () =>\n    Effect.promise(() => storageWriter.generateUploadUrl()).pipe(\n      Effect.andThen((url) =>\n        pipe(url, Schema.decode(Schema.URL), Effect.orDie),\n      ),\n    ),\n  delete: (storageId: GenericId<\"_storage\">) =>\n    Effect.tryPromise({\n      try: () => storageWriter.delete(storageId),\n      catch: () => new BlobNotFoundError({ id: storageId }),\n    }),\n});\n\nconst makeStorageActionWriter = (\n  storageActionWriter: ConvexStorageActionWriter,\n) => ({\n  get: (storageId: GenericId<\"_storage\">) =>\n    Effect.promise(() => storageActionWriter.get(storageId)).pipe(\n      Effect.andThen(\n        flow(\n          Option.fromNullable,\n          Option.match({\n            onNone: () => Effect.fail(new BlobNotFoundError({ id: storageId })),\n            onSome: Effect.succeed,\n          }),\n        ),\n      ),\n    ),\n  store: (blob: Blob, options?: { sha256?: string }) =>\n    Effect.promise(() => storageActionWriter.store(blob, options)),\n});\n\nexport class StorageReader extends Effect.Tag(\n  \"@confect/server/Storage/StorageReader\",\n)<StorageReader, ReturnType<typeof makeStorageReader>>() {\n  static readonly layer = (storageReader: ConvexStorageReader) =>\n    Layer.succeed(this, makeStorageReader(storageReader));\n}\n\nexport class StorageWriter extends Effect.Tag(\n  \"@confect/server/Storage/StorageWriter\",\n)<StorageWriter, ReturnType<typeof makeStorageWriter>>() {\n  static readonly layer = (storageWriter: ConvexStorageWriter) =>\n    Layer.succeed(this, makeStorageWriter(storageWriter));\n}\n\nexport class StorageActionWriter extends Effect.Tag(\n  \"@confect/server/Storage/StorageActionWriter\",\n)<StorageActionWriter, ReturnType<typeof makeStorageActionWriter>>() {\n  static readonly layer = (storageActionWriter: ConvexStorageActionWriter) =>\n    Layer.succeed(this, makeStorageActionWriter(storageActionWriter));\n}\n\nexport class BlobNotFoundError extends Schema.TaggedError<BlobNotFoundError>()(\n  \"BlobNotFoundError\",\n  {\n    id: Schema.String,\n  },\n) {\n  override get message(): string {\n    return `File with ID '${this.id}' not found`;\n  }\n}\n"],"mappings":";;;;;;;;;;AAQA,MAAM,qBAAqB,mBAAwC,EACjE,SAAS,cACP,OAAO,cAAc,cAAc,OAAO,UAAU,CAAC,CAAC,KACpD,OAAO,QACL,KACE,OAAO,cACP,OAAO,MAAM;CACX,cAAc,OAAO,KAAK,IAAI,kBAAkB,EAAE,IAAI,WAAW,CAAC,CAAC;CACnE,SAAS,QAAQ,KAAK,KAAK,OAAO,OAAO,OAAO,IAAI,EAAE,OAAO,MAAM;CACpE,CAAC,CACH,CACF,CACF,EACJ;AAED,MAAM,qBAAqB,mBAAwC;CACjE,yBACE,OAAO,cAAc,cAAc,mBAAmB,CAAC,CAAC,KACtD,OAAO,SAAS,QACd,KAAK,KAAK,OAAO,OAAO,OAAO,IAAI,EAAE,OAAO,MAAM,CACnD,CACF;CACH,SAAS,cACP,OAAO,WAAW;EAChB,WAAW,cAAc,OAAO,UAAU;EAC1C,aAAa,IAAI,kBAAkB,EAAE,IAAI,WAAW,CAAC;EACtD,CAAC;CACL;AAED,MAAM,2BACJ,yBACI;CACJ,MAAM,cACJ,OAAO,cAAc,oBAAoB,IAAI,UAAU,CAAC,CAAC,KACvD,OAAO,QACL,KACE,OAAO,cACP,OAAO,MAAM;EACX,cAAc,OAAO,KAAK,IAAI,kBAAkB,EAAE,IAAI,WAAW,CAAC,CAAC;EACnE,QAAQ,OAAO;EAChB,CAAC,CACH,CACF,CACF;CACH,QAAQ,MAAY,YAClB,OAAO,cAAc,oBAAoB,MAAM,MAAM,QAAQ,CAAC;CACjE;AAED,IAAa,gBAAb,cAAmC,OAAO,IACxC,wCACD,EAAuD,CAAC;CACvD,OAAgB,SAAS,kBACvB,MAAM,QAAQ,MAAM,kBAAkB,cAAc,CAAC;;AAGzD,IAAa,gBAAb,cAAmC,OAAO,IACxC,wCACD,EAAuD,CAAC;CACvD,OAAgB,SAAS,kBACvB,MAAM,QAAQ,MAAM,kBAAkB,cAAc,CAAC;;AAGzD,IAAa,sBAAb,cAAyC,OAAO,IAC9C,8CACD,EAAmE,CAAC;CACnE,OAAgB,SAAS,wBACvB,MAAM,QAAQ,MAAM,wBAAwB,oBAAoB,CAAC;;AAGrE,IAAa,oBAAb,cAAuC,OAAO,aAAgC,CAC5E,qBACA,EACE,IAAI,OAAO,QACZ,CACF,CAAC;CACA,IAAa,UAAkB;AAC7B,SAAO,iBAAiB,KAAK,GAAG"}

package/src/Storage.ts

@@ -1,87 +0,0 @@
-import type {
-  StorageActionWriter as ConvexStorageActionWriter,
-  StorageReader as ConvexStorageReader,
-  StorageWriter as ConvexStorageWriter,
-} from "convex/server";
-import type { GenericId } from "convex/values";
-import { Effect, flow, Layer, Option, pipe, Schema } from "effect";
-
-const makeStorageReader = (storageReader: ConvexStorageReader) => ({
-  getUrl: (storageId: GenericId<"_storage">) =>
-    Effect.promise(() => storageReader.getUrl(storageId)).pipe(
-      Effect.andThen(
-        flow(
-          Option.fromNullable,
-          Option.match({
-            onNone: () => Effect.fail(new BlobNotFoundError({ id: storageId })),
-            onSome: (doc) => pipe(doc, Schema.decode(Schema.URL), Effect.orDie),
-          }),
-        ),
-      ),
-    ),
-});
-
-const makeStorageWriter = (storageWriter: ConvexStorageWriter) => ({
-  generateUploadUrl: () =>
-    Effect.promise(() => storageWriter.generateUploadUrl()).pipe(
-      Effect.andThen((url) =>
-        pipe(url, Schema.decode(Schema.URL), Effect.orDie),
-      ),
-    ),
-  delete: (storageId: GenericId<"_storage">) =>
-    Effect.tryPromise({
-      try: () => storageWriter.delete(storageId),
-      catch: () => new BlobNotFoundError({ id: storageId }),
-    }),
-});
-
-const makeStorageActionWriter = (
-  storageActionWriter: ConvexStorageActionWriter,
-) => ({
-  get: (storageId: GenericId<"_storage">) =>
-    Effect.promise(() => storageActionWriter.get(storageId)).pipe(
-      Effect.andThen(
-        flow(
-          Option.fromNullable,
-          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 StorageReader extends Effect.Tag(
-  "@confect/server/Storage/StorageReader",
-)<StorageReader, ReturnType<typeof makeStorageReader>>() {
-  static readonly layer = (storageReader: ConvexStorageReader) =>
-    Layer.succeed(this, makeStorageReader(storageReader));
-}
-
-export class StorageWriter extends Effect.Tag(
-  "@confect/server/Storage/StorageWriter",
-)<StorageWriter, ReturnType<typeof makeStorageWriter>>() {
-  static readonly layer = (storageWriter: ConvexStorageWriter) =>
-    Layer.succeed(this, makeStorageWriter(storageWriter));
-}
-
-export class StorageActionWriter extends Effect.Tag(
-  "@confect/server/Storage/StorageActionWriter",
-)<StorageActionWriter, ReturnType<typeof makeStorageActionWriter>>() {
-  static readonly layer = (storageActionWriter: ConvexStorageActionWriter) =>
-    Layer.succeed(this, makeStorageActionWriter(storageActionWriter));
-}
-
-export class BlobNotFoundError extends Schema.TaggedError<BlobNotFoundError>()(
-  "BlobNotFoundError",
-  {
-    id: Schema.String,
-  },
-) {
-  override get message(): string {
-    return `File with ID '${this.id}' not found`;
-  }
-}