@confect/server 3.0.0 → 5.0.0

package/src/RegisteredConvexFunction.ts

@@ -27,7 +27,8 @@ import * as RegisteredFunction from "./RegisteredFunction";
 import type * as RegistryItem from "./RegistryItem";
 import * as Scheduler from "./Scheduler";
 import * as SchemaToValidator from "./SchemaToValidator";
-import { StorageReader, StorageWriter } from "./Storage";
+import { StorageReader } from "./StorageReader";
+import { StorageWriter } from "./StorageWriter";
 
 export const make = <Api_ extends Api.AnyWithPropsWithRuntime<"Convex">>(
   api: Api_,

package/src/RegisteredFunction.ts

@@ -18,7 +18,9 @@ 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 Any =

package/src/Scheduler.ts

@@ -1,31 +1,43 @@
-import type {
-  OptionalRestArgs,
-  SchedulableFunctionReference,
-  Scheduler as ConvexScheduler,
-} from "convex/server";
+import { Ref } from "@confect/core";
+import type { Scheduler as ConvexScheduler } from "convex/server";
 import { Context, DateTime, Duration, Effect, Layer } from "effect";
 
+type OptionalArgs<Ref_ extends Ref.AnyMutation | Ref.AnyAction> =
+  keyof Ref.Args<Ref_> extends never
+    ? [args?: Ref.Args<Ref_>]
+    : [args: Ref.Args<Ref_>];
+
 const make = (scheduler: ConvexScheduler) => ({
-  runAfter: <FuncRef extends SchedulableFunctionReference>(
+  runAfter: <Ref_ extends Ref.AnyMutation | Ref.AnyAction>(
     delay: Duration.Duration,
-    functionReference: FuncRef,
-    ...args: OptionalRestArgs<FuncRef>
+    ref: Ref_,
+    ...args: 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, ...args),
+      scheduler.runAfter(delayMs, functionReference, encodedArgs),
     );
   },
-  runAt: <FuncRef extends SchedulableFunctionReference>(
+  runAt: <Ref_ extends Ref.AnyMutation | Ref.AnyAction>(
     dateTime: DateTime.DateTime,
-    functionReference: FuncRef,
-    ...args: OptionalRestArgs<FuncRef>
+    ref: Ref_,
+    ...args: 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, ...args),
+      scheduler.runAt(timestamp, functionReference, encodedArgs),
     );
   },
 });

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,7 +2,10 @@ 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";
@@ -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`;
-  }
-}