@confect/server 3.0.0 → 4.0.0

package/src/CronJobs.ts

@@ -0,0 +1,161 @@
+import { Ref } from "@confect/core";
+import type {
+  CronJob as ConvexCronJob,
+  SchedulableFunctionReference,
+} from "convex/server";
+import { cronJobs as makeConvexCrons, type Crons } from "convex/server";
+import {
+  Array,
+  Cron,
+  Duration,
+  Match,
+  Order,
+  pipe,
+  Predicate,
+  Record,
+  Schema,
+} from "effect";
+import type * as CronJob from "./CronJob";
+
+export const TypeId = "@confect/server/CronJobs";
+export type TypeId = typeof TypeId;
+
+export interface CronJobs {
+  readonly [TypeId]: TypeId;
+  readonly cronJobs: Record<string, CronJob.CronJob>;
+  readonly convexCronJobs: Crons;
+
+  add(cron: CronJob.CronJob): CronJobs;
+}
+
+export const isCronJobs = (u: unknown): u is CronJobs =>
+  Predicate.hasProperty(u, TypeId);
+
+const Proto = {
+  [TypeId]: TypeId,
+
+  add(this: CronJobs, cronJob: CronJob.CronJob) {
+    const newConvexCrons = Object.assign(makeConvexCrons(), {
+      crons: { ...this.convexCronJobs.crons },
+    });
+
+    const schedulableFunctionReference = Ref.getConvexFunctionName(
+      cronJob.ref,
+    ) as unknown as SchedulableFunctionReference;
+
+    const functionSpec = Ref.getFunctionSpec(cronJob.ref);
+    const encodedArgs = Match.value(functionSpec.functionProvenance).pipe(
+      Match.tag("Confect", (confect) =>
+        Schema.encodeSync(confect.args)(cronJob.args),
+      ),
+      Match.tag("Convex", () => cronJob.args),
+      Match.exhaustive,
+    );
+
+    Match.value(cronJob.schedule).pipe(
+      Match.when(Cron.isCron, (cron) => {
+        newConvexCrons.cron(
+          cronJob.identifier,
+          cronToConvexCronString(cron),
+          schedulableFunctionReference,
+          encodedArgs,
+        );
+      }),
+      Match.when(Duration.isDuration, (duration) => {
+        newConvexCrons.interval(
+          cronJob.identifier,
+          durationToConvexIntervalSchedule(duration),
+          schedulableFunctionReference,
+          encodedArgs,
+        );
+      }),
+      Match.exhaustive,
+    );
+
+    return makeProto(
+      Record.set(this.cronJobs, cronJob.identifier, cronJob),
+      newConvexCrons,
+    );
+  },
+};
+
+const makeProto = (
+  cronJobs: Record<string, CronJob.CronJob>,
+  convexCronJobs: Crons,
+): CronJobs =>
+  Object.assign(Object.create(Proto), {
+    cronJobs,
+    convexCronJobs,
+  });
+
+export const make = (): CronJobs => makeProto({}, makeConvexCrons());
+
+/** @internal */
+export const cronToConvexCronString = (cron: Cron.Cron): string => {
+  const hasNonDefaultSeconds = cron.seconds.size !== 1 || !cron.seconds.has(0);
+  if (hasNonDefaultSeconds) {
+    throw new Error(
+      "Convex cron expressions do not support a seconds field. " +
+        "The seconds field must be the default {0}. " +
+        "Sub-minute scheduling is supported only by interval schedules defined using a Duration.",
+    );
+  }
+
+  return Array.join(
+    [
+      setToField(cron.minutes),
+      setToField(cron.hours),
+      setToField(cron.days),
+      setToField(cron.months),
+      setToField(cron.weekdays),
+    ],
+    " ",
+  );
+};
+
+const setToField = (set: ReadonlySet<number>): string => {
+  if (set.size === 0) return "*";
+  return pipe(
+    set,
+    Array.sort(Order.number),
+    Array.map((n) => n.toString()),
+    Array.join(","),
+  );
+};
+
+/** @internal */
+export const durationToConvexIntervalSchedule = (
+  duration: Duration.Duration,
+): IntervalSchedule => {
+  const millis = Duration.toMillis(duration);
+  if (millis <= 0) {
+    throw new Error("Interval must be a positive duration.");
+  }
+
+  const oneHourInMillis = Duration.hours(1).pipe(Duration.toMillis);
+  const hours = millis / oneHourInMillis;
+  if (Number.isInteger(hours)) {
+    return { type: "interval", hours };
+  }
+
+  const oneMinuteInMillis = Duration.minutes(1).pipe(Duration.toMillis);
+  const minutes = millis / oneMinuteInMillis;
+  if (Number.isInteger(minutes)) {
+    return { type: "interval", minutes };
+  }
+
+  const oneSecondInMillis = Duration.seconds(1).pipe(Duration.toMillis);
+  const seconds = millis / oneSecondInMillis;
+  if (Number.isInteger(seconds)) {
+    return { type: "interval", seconds };
+  }
+
+  throw new Error(
+    "Interval must be a whole number of seconds, minutes, or hours.",
+  );
+};
+
+type IntervalSchedule = Extract<
+  ConvexCronJob["schedule"],
+  { type: "interval" }
+>;

package/src/Handler.ts

@@ -15,11 +15,9 @@ import type * as QueryCtx from "./QueryCtx";
 import type * as QueryRunner from "./QueryRunner";
 import type * as RegisteredFunction from "./RegisteredFunction";
 import type * as Scheduler from "./Scheduler";
-import type {
-  StorageActionWriter,
-  StorageReader,
-  StorageWriter,
-} from "./Storage";
+import type { StorageActionWriter } from "./StorageActionWriter";
+import type { StorageReader } from "./StorageReader";
+import type { StorageWriter } from "./StorageWriter";
 import type * as VectorSearch from "./VectorSearch";
 
 export type Handler<

package/src/HttpApi.ts

@@ -23,7 +23,9 @@ import * as ConvexConfigProvider from "./ConvexConfigProvider";
 import * as MutationRunner from "./MutationRunner";
 import * as QueryRunner from "./QueryRunner";
 import * as Scheduler from "./Scheduler";
-import { StorageActionWriter, StorageReader, StorageWriter } from "./Storage";
+import { StorageActionWriter } from "./StorageActionWriter";
+import { StorageReader } from "./StorageReader";
+import { StorageWriter } from "./StorageWriter";
 
 type Middleware = (
   httpApp: HttpApp.Default,

package/src/OrderedQuery.ts

@@ -1,4 +1,6 @@
 import type {
+  ExpressionOrValue,
+  FilterBuilder,
   OrderedQuery as ConvexOrderedQuery,
   PaginationResult,
 } from "convex/server";
@@ -28,10 +30,15 @@ export type OrderedQuery<
     TableInfo_["document"],
     Document.DocumentDecodeError
   >;
-  readonly paginate: (options: {
-    cursor: string | null;
-    numItems: number;
-  }) => Effect.Effect<
+  readonly paginate: (
+    options: {
+      cursor: string | null;
+      numItems: number;
+    },
+    filter?: (
+      q: FilterBuilder<TableInfo.ConvexTableInfo<TableInfo_>>,
+    ) => ExpressionOrValue<boolean>,
+  ) => Effect.Effect<
     PaginationResult<TableInfo_["document"]>,
     Document.DocumentDecodeError
   >;
@@ -73,10 +80,12 @@ export const make = <
   const collect: OrderedQueryFunction<"collect"> = () =>
     pipe(stream(), Stream.runCollect, Effect.map(Chunk.toReadonlyArray));
 
-  const paginate: OrderedQueryFunction<"paginate"> = (options) =>
+  const paginate: OrderedQueryFunction<"paginate"> = (options, filter) =>
     Effect.gen(function* () {
+      const filteredQuery = filter !== undefined ? query.filter(filter) : query;
+
       const paginationResult = yield* Effect.promise(() =>
-        query.paginate(options),
+        filteredQuery.paginate(options),
       );
 
       const parsedPage = yield* Effect.forEach(

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/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`;
-  }
-}