@confect/server 3.0.0 → 5.0.0

package/dist/StorageActionWriter.js

@@ -0,0 +1,20 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { BlobNotFoundError } from "./BlobNotFoundError.js";
+import { Effect, Layer, Option, flow } from "effect";
+
+//#region src/StorageActionWriter.ts
+var StorageActionWriter_exports = /* @__PURE__ */ __exportAll({ StorageActionWriter: () => StorageActionWriter });
+const make = (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 StorageActionWriter = class extends Effect.Tag("@confect/server/StorageActionWriter")() {
+	static layer = (storageActionWriter) => Layer.succeed(this, make(storageActionWriter));
+};
+
+//#endregion
+export { StorageActionWriter, StorageActionWriter_exports };
+//# sourceMappingURL=StorageActionWriter.js.map

package/dist/StorageActionWriter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StorageActionWriter.js","names":[],"sources":["../src/StorageActionWriter.ts"],"sourcesContent":["import type { StorageActionWriter as ConvexStorageActionWriter } from \"convex/server\";\nimport type { GenericId } from \"convex/values\";\nimport { Effect, flow, Layer, Option } from \"effect\";\nimport { BlobNotFoundError } from \"./BlobNotFoundError\";\n\nconst make = (storageActionWriter: ConvexStorageActionWriter) => ({\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 StorageActionWriter extends Effect.Tag(\n  \"@confect/server/StorageActionWriter\",\n)<StorageActionWriter, ReturnType<typeof make>>() {\n  static readonly layer = (storageActionWriter: ConvexStorageActionWriter) =>\n    Layer.succeed(this, make(storageActionWriter));\n}\n"],"mappings":";;;;;;AAKA,MAAM,QAAQ,yBAAoD;CAChE,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,sBAAb,cAAyC,OAAO,IAC9C,sCACD,EAAgD,CAAC;CAChD,OAAgB,SAAS,wBACvB,MAAM,QAAQ,MAAM,KAAK,oBAAoB,CAAC"}

package/dist/StorageReader.d.ts

@@ -0,0 +1,26 @@
+import { BlobNotFoundError } from "./BlobNotFoundError.js";
+import { Effect, Layer } from "effect";
+import { StorageReader as StorageReader$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/StorageReader.d.ts
+declare namespace StorageReader_d_exports {
+  export { StorageReader };
+}
+declare const StorageReader_base: effect_Context0.TagClass<StorageReader, "@confect/server/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>;
+}
+//#endregion
+export { StorageReader, StorageReader_d_exports };
+//# sourceMappingURL=StorageReader.d.ts.map

package/dist/StorageReader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StorageReader.d.ts","names":[],"sources":["../src/StorageReader.ts"],"mappings":";;;;;;;;;;;cAGwD,kBAAA,EAGb,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;;cAc9B,aAAA,SAAsB,kBAAA;EAAA,gBAIjB,KAAA,GAAS,aAAA,EAAe,eAAA,KAAmB,KAAA,CAAA,KAAA,CAAA,aAAA;AAAA"}

package/dist/StorageReader.js

@@ -0,0 +1,17 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { BlobNotFoundError } from "./BlobNotFoundError.js";
+import { Effect, Layer, Option, Schema, flow, pipe } from "effect";
+
+//#region src/StorageReader.ts
+var StorageReader_exports = /* @__PURE__ */ __exportAll({ StorageReader: () => StorageReader });
+const make = (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)
+})))) });
+var StorageReader = class extends Effect.Tag("@confect/server/StorageReader")() {
+	static layer = (storageReader) => Layer.succeed(this, make(storageReader));
+};
+
+//#endregion
+export { StorageReader, StorageReader_exports };
+//# sourceMappingURL=StorageReader.js.map

package/dist/StorageReader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StorageReader.js","names":[],"sources":["../src/StorageReader.ts"],"sourcesContent":["import type { StorageReader as ConvexStorageReader } from \"convex/server\";\nimport type { GenericId } from \"convex/values\";\nimport { Effect, flow, Layer, Option, pipe, Schema } from \"effect\";\nimport { BlobNotFoundError } from \"./BlobNotFoundError\";\n\nconst make = (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\nexport class StorageReader extends Effect.Tag(\"@confect/server/StorageReader\")<\n  StorageReader,\n  ReturnType<typeof make>\n>() {\n  static readonly layer = (storageReader: ConvexStorageReader) =>\n    Layer.succeed(this, make(storageReader));\n}\n"],"mappings":";;;;;;AAKA,MAAM,QAAQ,mBAAwC,EACpD,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,IAAa,gBAAb,cAAmC,OAAO,IAAI,gCAAgC,EAG3E,CAAC;CACF,OAAgB,SAAS,kBACvB,MAAM,QAAQ,MAAM,KAAK,cAAc,CAAC"}

package/dist/StorageWriter.d.ts

@@ -0,0 +1,29 @@
+import { BlobNotFoundError } from "./BlobNotFoundError.js";
+import { Effect, Layer } from "effect";
+import { 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/StorageWriter.d.ts
+declare namespace StorageWriter_d_exports {
+  export { StorageWriter };
+}
+declare const StorageWriter_base: effect_Context0.TagClass<StorageWriter, "@confect/server/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>;
+}
+//#endregion
+export { StorageWriter, StorageWriter_d_exports };
+//# sourceMappingURL=StorageWriter.d.ts.map

package/dist/StorageWriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StorageWriter.d.ts","names":[],"sources":["../src/StorageWriter.ts"],"mappings":";;;;;;;;;;;cAGwD,kBAAA,EASb,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;;cAO9B,aAAA,SAAsB,kBAAA;EAAA,gBAIjB,KAAA,GAAS,aAAA,EAAe,eAAA,KAAmB,KAAA,CAAA,KAAA,CAAA,aAAA;AAAA"}

package/dist/StorageWriter.js

@@ -0,0 +1,20 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { BlobNotFoundError } from "./BlobNotFoundError.js";
+import { Effect, Layer, Schema, pipe } from "effect";
+
+//#region src/StorageWriter.ts
+var StorageWriter_exports = /* @__PURE__ */ __exportAll({ StorageWriter: () => StorageWriter });
+const make = (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 })
+	})
+});
+var StorageWriter = class extends Effect.Tag("@confect/server/StorageWriter")() {
+	static layer = (storageWriter) => Layer.succeed(this, make(storageWriter));
+};
+
+//#endregion
+export { StorageWriter, StorageWriter_exports };
+//# sourceMappingURL=StorageWriter.js.map

package/dist/StorageWriter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StorageWriter.js","names":[],"sources":["../src/StorageWriter.ts"],"sourcesContent":["import type { StorageWriter as ConvexStorageWriter } from \"convex/server\";\nimport type { GenericId } from \"convex/values\";\nimport { Effect, Layer, pipe, Schema } from \"effect\";\nimport { BlobNotFoundError } from \"./BlobNotFoundError\";\n\nconst make = (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\nexport class StorageWriter extends Effect.Tag(\"@confect/server/StorageWriter\")<\n  StorageWriter,\n  ReturnType<typeof make>\n>() {\n  static readonly layer = (storageWriter: ConvexStorageWriter) =>\n    Layer.succeed(this, make(storageWriter));\n}\n"],"mappings":";;;;;;AAKA,MAAM,QAAQ,mBAAwC;CACpD,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,IAAa,gBAAb,cAAmC,OAAO,IAAI,gCAAgC,EAG3E,CAAC;CACF,OAAgB,SAAS,kBACvB,MAAM,QAAQ,MAAM,KAAK,cAAc,CAAC"}

package/dist/index.d.ts

@@ -5,7 +5,10 @@ import { Table_d_exports } from "./Table.js";
 import { DatabaseSchema_d_exports } from "./DatabaseSchema.js";
 import { Api_d_exports } from "./Api.js";
 import { Auth_d_exports } from "./Auth.js";
+import { BlobNotFoundError_d_exports } from "./BlobNotFoundError.js";
 import { ConvexConfigProvider_d_exports } from "./ConvexConfigProvider.js";
+import { CronJob_d_exports } from "./CronJob.js";
+import { CronJobs_d_exports } from "./CronJobs.js";
 import { Document_d_exports } from "./Document.js";
 import { TableInfo_d_exports } from "./TableInfo.js";
 import { DataModel_d_exports } from "./DataModel.js";
@@ -18,7 +21,9 @@ import { MutationRunner_d_exports } from "./MutationRunner.js";
 import { QueryCtx_d_exports } from "./QueryCtx.js";
 import { QueryRunner_d_exports } from "./QueryRunner.js";
 import { Scheduler_d_exports } from "./Scheduler.js";
-import { Storage_d_exports } from "./Storage.js";
+import { StorageActionWriter_d_exports } from "./StorageActionWriter.js";
+import { StorageReader_d_exports } from "./StorageReader.js";
+import { StorageWriter_d_exports } from "./StorageWriter.js";
 import { VectorSearch_d_exports } from "./VectorSearch.js";
 import { RegisteredFunction_d_exports } from "./RegisteredFunction.js";
 import { Handler_d_exports } from "./Handler.js";
@@ -30,4 +35,4 @@ import { RegistryItem_d_exports } from "./RegistryItem.js";
 import { RegisteredConvexFunction_d_exports } from "./RegisteredConvexFunction.js";
 import { RegisteredFunctions_d_exports } from "./RegisteredFunctions.js";
 import { Registry_d_exports } from "./Registry.js";
-export { ActionCtx_d_exports as ActionCtx, ActionRunner_d_exports as ActionRunner, Api_d_exports as Api, Auth_d_exports as Auth, ConvexConfigProvider_d_exports as ConvexConfigProvider, DataModel_d_exports as DataModel, DatabaseReader_d_exports as DatabaseReader, DatabaseSchema_d_exports as DatabaseSchema, DatabaseWriter_d_exports as DatabaseWriter, Document_d_exports as Document, FunctionImpl_d_exports as FunctionImpl, GroupImpl_d_exports as GroupImpl, Handler_d_exports as Handler, HttpApi_d_exports as HttpApi, Impl_d_exports as Impl, MutationCtx_d_exports as MutationCtx, MutationRunner_d_exports as MutationRunner, OrderedQuery_d_exports as OrderedQuery, QueryCtx_d_exports as QueryCtx, QueryInitializer_d_exports as QueryInitializer, QueryRunner_d_exports as QueryRunner, RegisteredConvexFunction_d_exports as RegisteredConvexFunction, RegisteredFunction_d_exports as RegisteredFunction, RegisteredFunctions_d_exports as RegisteredFunctions, Registry_d_exports as Registry, RegistryItem_d_exports as RegistryItem, Scheduler_d_exports as Scheduler, SchemaToValidator_d_exports as SchemaToValidator, Storage_d_exports as Storage, Table_d_exports as Table, TableInfo_d_exports as TableInfo, VectorSearch_d_exports as VectorSearch };
+export { ActionCtx_d_exports as ActionCtx, ActionRunner_d_exports as ActionRunner, Api_d_exports as Api, Auth_d_exports as Auth, BlobNotFoundError_d_exports as BlobNotFoundError, ConvexConfigProvider_d_exports as ConvexConfigProvider, CronJob_d_exports as CronJob, CronJobs_d_exports as CronJobs, DataModel_d_exports as DataModel, DatabaseReader_d_exports as DatabaseReader, DatabaseSchema_d_exports as DatabaseSchema, DatabaseWriter_d_exports as DatabaseWriter, Document_d_exports as Document, FunctionImpl_d_exports as FunctionImpl, GroupImpl_d_exports as GroupImpl, Handler_d_exports as Handler, HttpApi_d_exports as HttpApi, Impl_d_exports as Impl, MutationCtx_d_exports as MutationCtx, MutationRunner_d_exports as MutationRunner, OrderedQuery_d_exports as OrderedQuery, QueryCtx_d_exports as QueryCtx, QueryInitializer_d_exports as QueryInitializer, QueryRunner_d_exports as QueryRunner, RegisteredConvexFunction_d_exports as RegisteredConvexFunction, RegisteredFunction_d_exports as RegisteredFunction, RegisteredFunctions_d_exports as RegisteredFunctions, Registry_d_exports as Registry, RegistryItem_d_exports as RegistryItem, Scheduler_d_exports as Scheduler, SchemaToValidator_d_exports as SchemaToValidator, StorageActionWriter_d_exports as StorageActionWriter, StorageReader_d_exports as StorageReader, StorageWriter_d_exports as StorageWriter, Table_d_exports as Table, TableInfo_d_exports as TableInfo, VectorSearch_d_exports as VectorSearch };

package/dist/index.js

@@ -2,7 +2,10 @@ import { ActionCtx_exports } from "./ActionCtx.js";
 import { ActionRunner_exports } from "./ActionRunner.js";
 import { Api_exports } from "./Api.js";
 import { Auth_exports } from "./Auth.js";
+import { BlobNotFoundError_exports } from "./BlobNotFoundError.js";
 import { ConvexConfigProvider_exports } from "./ConvexConfigProvider.js";
+import { CronJob_exports } from "./CronJob.js";
+import { CronJobs_exports } from "./CronJobs.js";
 import { DataModel_exports } from "./DataModel.js";
 import { SchemaToValidator_exports } from "./SchemaToValidator.js";
 import { Table_exports } from "./Table.js";
@@ -20,7 +23,9 @@ import { Handler_exports } from "./Handler.js";
 import { MutationRunner_exports } from "./MutationRunner.js";
 import { QueryRunner_exports } from "./QueryRunner.js";
 import { Scheduler_exports } from "./Scheduler.js";
-import { Storage_exports } from "./Storage.js";
+import { StorageActionWriter_exports } from "./StorageActionWriter.js";
+import { StorageReader_exports } from "./StorageReader.js";
+import { StorageWriter_exports } from "./StorageWriter.js";
 import { HttpApi_exports } from "./HttpApi.js";
 import { Impl_exports } from "./Impl.js";
 import { MutationCtx_exports } from "./MutationCtx.js";
@@ -31,4 +36,4 @@ import { RegisteredConvexFunction_exports } from "./RegisteredConvexFunction.js"
 import { RegisteredFunctions_exports } from "./RegisteredFunctions.js";
 import { TableInfo_exports } from "./TableInfo.js";
 
-export { ActionCtx_exports as ActionCtx, ActionRunner_exports as ActionRunner, Api_exports as Api, Auth_exports as Auth, ConvexConfigProvider_exports as ConvexConfigProvider, DataModel_exports as DataModel, DatabaseReader_exports as DatabaseReader, DatabaseSchema_exports as DatabaseSchema, DatabaseWriter_exports as DatabaseWriter, Document_exports as Document, FunctionImpl_exports as FunctionImpl, GroupImpl_exports as GroupImpl, Handler_exports as Handler, HttpApi_exports as HttpApi, Impl_exports as Impl, MutationCtx_exports as MutationCtx, MutationRunner_exports as MutationRunner, OrderedQuery_exports as OrderedQuery, QueryCtx_exports as QueryCtx, QueryInitializer_exports as QueryInitializer, QueryRunner_exports as QueryRunner, RegisteredConvexFunction_exports as RegisteredConvexFunction, RegisteredFunction_exports as RegisteredFunction, RegisteredFunctions_exports as RegisteredFunctions, Registry_exports as Registry, RegistryItem_exports as RegistryItem, Scheduler_exports as Scheduler, SchemaToValidator_exports as SchemaToValidator, Storage_exports as Storage, Table_exports as Table, TableInfo_exports as TableInfo, VectorSearch_exports as VectorSearch };
+export { ActionCtx_exports as ActionCtx, ActionRunner_exports as ActionRunner, Api_exports as Api, Auth_exports as Auth, BlobNotFoundError_exports as BlobNotFoundError, ConvexConfigProvider_exports as ConvexConfigProvider, CronJob_exports as CronJob, CronJobs_exports as CronJobs, DataModel_exports as DataModel, DatabaseReader_exports as DatabaseReader, DatabaseSchema_exports as DatabaseSchema, DatabaseWriter_exports as DatabaseWriter, Document_exports as Document, FunctionImpl_exports as FunctionImpl, GroupImpl_exports as GroupImpl, Handler_exports as Handler, HttpApi_exports as HttpApi, Impl_exports as Impl, MutationCtx_exports as MutationCtx, MutationRunner_exports as MutationRunner, OrderedQuery_exports as OrderedQuery, QueryCtx_exports as QueryCtx, QueryInitializer_exports as QueryInitializer, QueryRunner_exports as QueryRunner, RegisteredConvexFunction_exports as RegisteredConvexFunction, RegisteredFunction_exports as RegisteredFunction, RegisteredFunctions_exports as RegisteredFunctions, Registry_exports as Registry, RegistryItem_exports as RegistryItem, Scheduler_exports as Scheduler, SchemaToValidator_exports as SchemaToValidator, StorageActionWriter_exports as StorageActionWriter, StorageReader_exports as StorageReader, StorageWriter_exports as StorageWriter, Table_exports as Table, TableInfo_exports as TableInfo, VectorSearch_exports as VectorSearch };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@confect/server",
-  "version": "3.0.0",
+  "version": "5.0.0",
   "description": "Backend bindings to the Convex platform",
   "repository": {
     "type": "git",
@@ -67,15 +67,15 @@
     "vite": "7.3.1",
     "vite-tsconfig-paths": "6.1.1",
     "vitest": "3.2.4",
-    "@confect/cli": "3.0.0",
-    "@confect/test": "3.0.0"
+    "@confect/cli": "5.0.0",
+    "@confect/test": "5.0.0"
   },
   "peerDependencies": {
     "@effect/platform": "^0.94.5",
     "@effect/platform-node": "^0.104.1",
     "convex": "^1.30.0",
     "effect": "^3.19.16",
-    "@confect/core": "3.0.0"
+    "@confect/core": "5.0.0"
   },
   "engines": {
     "node": ">=22",

package/src/ActionRunner.ts

@@ -1,38 +1,13 @@
 import * as Ref from "@confect/core/Ref";
 import { type GenericActionCtx } from "convex/server";
-import type { ParseResult } from "effect";
-import { Context, Effect, Layer, Match, Schema } from "effect";
+import { Context, Layer } from "effect";
 
 const make =
   (runAction: GenericActionCtx<any>["runAction"]) =>
-  <Action extends Ref.AnyAction>(
-    action: Action,
-    args: Ref.Args<Action>,
-  ): Effect.Effect<Ref.Returns<Action>, ParseResult.ParseError> =>
-    Effect.gen(function* () {
-      const functionSpec = Ref.getFunctionSpec(action);
-      const functionName = Ref.getConvexFunctionName(action);
-
-      return yield* Match.value(functionSpec.functionProvenance).pipe(
-        Match.tag("Confect", (confectFunctionSpec) =>
-          Effect.gen(function* () {
-            const encodedArgs = yield* Schema.encode(confectFunctionSpec.args)(
-              args,
-            );
-            const encodedReturns = yield* Effect.promise(() =>
-              runAction(functionName as any, encodedArgs),
-            );
-            return yield* Schema.decode(confectFunctionSpec.returns)(
-              encodedReturns,
-            );
-          }),
-        ),
-        Match.tag("Convex", () =>
-          Effect.promise(() => runAction(functionName as any, args as any)),
-        ),
-        Match.exhaustive,
-      );
-    });
+  <Action extends Ref.AnyAction>(action: Action, args: Ref.Args<Action>) =>
+    Ref.runWithCodec(action, args, (functionReference, encodedArgs) =>
+      runAction(functionReference, encodedArgs),
+    );
 
 export const ActionRunner = Context.GenericTag<ReturnType<typeof make>>(
   "@confect/server/ActionRunner",

package/src/BlobNotFoundError.ts

@@ -0,0 +1,12 @@
+import { Schema } from "effect";
+
+export class BlobNotFoundError extends Schema.TaggedError<BlobNotFoundError>()(
+  "BlobNotFoundError",
+  {
+    id: Schema.String,
+  },
+) {
+  override get message(): string {
+    return `File with ID '${this.id}' not found`;
+  }
+}

package/src/CronJob.ts

@@ -0,0 +1,45 @@
+import type { Ref } from "@confect/core";
+import type { Cron, Duration } from "effect";
+import { Predicate } from "effect";
+
+export const TypeId = "@confect/server/CronJob";
+export type TypeId = typeof TypeId;
+
+export interface CronJob {
+  readonly [TypeId]: TypeId;
+
+  readonly identifier: string;
+  readonly schedule: Cron.Cron | Duration.Duration;
+  readonly ref: Ref.AnyMutation | Ref.AnyAction;
+  readonly args: Record<string, unknown>;
+}
+
+export const isCronJob = (u: unknown): u is CronJob =>
+  Predicate.hasProperty(u, TypeId);
+
+type OptionalArgs<R extends Ref.AnyMutation | Ref.AnyAction> =
+  keyof Ref.Args<R> extends never ? [args?: Ref.Args<R>] : [args: Ref.Args<R>];
+
+const Proto = {
+  [TypeId]: TypeId,
+};
+
+const makeProto = (
+  identifier: string,
+  schedule: Cron.Cron | Duration.Duration,
+  ref: Ref.AnyMutation | Ref.AnyAction,
+  args: Record<string, unknown>,
+): CronJob =>
+  Object.assign(Object.create(Proto), {
+    identifier,
+    schedule,
+    ref,
+    args,
+  });
+
+export const make = <R extends Ref.AnyMutation | Ref.AnyAction>(
+  identifier: string,
+  schedule: Cron.Cron | Duration.Duration,
+  ref: R,
+  ...args: OptionalArgs<R>
+): CronJob => makeProto(identifier, schedule, ref, args[0] ?? {});

package/src/CronJobs.ts

@@ -0,0 +1,147 @@
+import { Ref } from "@confect/core";
+import type { CronJob as ConvexCronJob } from "convex/server";
+import { cronJobs as makeConvexCrons, type Crons } from "convex/server";
+import {
+  Array,
+  Cron,
+  Duration,
+  Match,
+  Order,
+  pipe,
+  Predicate,
+  Record,
+} 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 functionReference = Ref.getFunctionReference(cronJob.ref);
+    const encodedArgs = Ref.encodeArgsSync(cronJob.ref, cronJob.args);
+
+    Match.value(cronJob.schedule).pipe(
+      Match.when(Cron.isCron, (cron) => {
+        newConvexCrons.cron(
+          cronJob.identifier,
+          cronToConvexCronString(cron),
+          functionReference,
+          encodedArgs,
+        );
+      }),
+      Match.when(Duration.isDuration, (duration) => {
+        newConvexCrons.interval(
+          cronJob.identifier,
+          durationToConvexIntervalSchedule(duration),
+          functionReference,
+          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/MutationRunner.ts

@@ -1,38 +1,16 @@
 import * as Ref from "@confect/core/Ref";
 import { type GenericMutationCtx } from "convex/server";
-import type { ParseResult } from "effect";
-import { Context, Effect, Layer, Match, Schema } from "effect";
+import { Context, Layer, Schema } from "effect";
 
 const make =
   (runMutation: GenericMutationCtx<any>["runMutation"]) =>
   <Mutation extends Ref.AnyMutation>(
     mutation: Mutation,
     args: Ref.Args<Mutation>,
-  ): Effect.Effect<Ref.Returns<Mutation>, ParseResult.ParseError> =>
-    Effect.gen(function* () {
-      const functionSpec = Ref.getFunctionSpec(mutation);
-      const functionName = Ref.getConvexFunctionName(mutation);
-
-      return yield* Match.value(functionSpec.functionProvenance).pipe(
-        Match.tag("Confect", (confectFunctionSpec) =>
-          Effect.gen(function* () {
-            const encodedArgs = yield* Schema.encode(confectFunctionSpec.args)(
-              args,
-            );
-            const encodedReturns = yield* Effect.promise(() =>
-              runMutation(functionName as any, encodedArgs),
-            );
-            return yield* Schema.decode(confectFunctionSpec.returns)(
-              encodedReturns,
-            );
-          }),
-        ),
-        Match.tag("Convex", () =>
-          Effect.promise(() => runMutation(functionName as any, args as any)),
-        ),
-        Match.exhaustive,
-      );
-    });
+  ) =>
+    Ref.runWithCodec(mutation, args, (functionReference, encodedArgs) =>
+      runMutation(functionReference, encodedArgs),
+    );
 
 export const MutationRunner = Context.GenericTag<ReturnType<typeof make>>(
   "@confect/server/MutationRunner",

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/QueryRunner.ts

@@ -1,38 +1,13 @@
 import * as Ref from "@confect/core/Ref";
 import { type GenericQueryCtx } from "convex/server";
-import type { ParseResult } from "effect";
-import { Context, Effect, Layer, Match, Schema } from "effect";
+import { Context, Layer } from "effect";
 
 const make =
   (runQuery: GenericQueryCtx<any>["runQuery"]) =>
-  <Query extends Ref.AnyQuery>(
-    query: Query,
-    args: Ref.Args<Query>,
-  ): Effect.Effect<Ref.Returns<Query>, ParseResult.ParseError> =>
-    Effect.gen(function* () {
-      const functionSpec = Ref.getFunctionSpec(query);
-      const functionName = Ref.getConvexFunctionName(query);
-
-      return yield* Match.value(functionSpec.functionProvenance).pipe(
-        Match.tag("Confect", (confectFunctionSpec) =>
-          Effect.gen(function* () {
-            const encodedArgs = yield* Schema.encode(confectFunctionSpec.args)(
-              args,
-            );
-            const encodedReturns = yield* Effect.promise(() =>
-              runQuery(functionName as any, encodedArgs),
-            );
-            return yield* Schema.decode(confectFunctionSpec.returns)(
-              encodedReturns,
-            );
-          }),
-        ),
-        Match.tag("Convex", () =>
-          Effect.promise(() => runQuery(functionName as any, args as any)),
-        ),
-        Match.exhaustive,
-      );
-    });
+  <Query extends Ref.AnyQuery>(query: Query, args: Ref.Args<Query>) =>
+    Ref.runWithCodec(query, args, (functionReference, encodedArgs) =>
+      runQuery(functionReference, encodedArgs),
+    );
 
 export const QueryRunner = Context.GenericTag<ReturnType<typeof make>>(
   "@confect/server/QueryRunner",