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

package/dist/RegistryItems.js

@@ -0,0 +1,27 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { isMiddlewareRegistryItem } from "./MiddlewareRegistryItem.js";
+import { isFunctionRegistryItem } from "./FunctionRegistryItem.js";
+import { pipe } from "effect/Function";
+import * as Array from "effect/Array";
+import * as Record from "effect/Record";
+//#region src/RegistryItems.ts
+var RegistryItems_exports = /* @__PURE__ */ __exportAll({
+	functionNames: () => functionNames,
+	middlewareKeys: () => middlewareKeys
+});
+/**
+* The names of the function-shaped entries in a group's (flat, isolated)
+* registry. `FunctionImpl.make` registers each function under a single-segment
+* key, so the registry built for one group contains exactly that group's
+* functions at the top level.
+*/
+const functionNames = (items) => pipe(Record.toEntries(items), Array.filter(([, value]) => isFunctionRegistryItem(value)), Array.map(([name]) => name));
+/**
+* The keys of the middleware implementations registered into a group's registry
+* (stored under `middleware:<key>` entries by `MiddlewareImpl`).
+*/
+const middlewareKeys = (items) => pipe(Record.values(items), Array.filter(isMiddlewareRegistryItem), Array.map((item) => item.middlewareSpec.key));
+//#endregion
+export { RegistryItems_exports, functionNames, middlewareKeys };
+
+//# sourceMappingURL=RegistryItems.js.map

package/dist/RegistryItems.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RegistryItems.js","names":["FunctionRegistryItem.isFunctionRegistryItem","MiddlewareRegistryItem.isMiddlewareRegistryItem"],"sources":["../src/RegistryItems.ts"],"sourcesContent":["import * as Array from \"effect/Array\";\nimport { pipe } from \"effect/Function\";\nimport * as Record from \"effect/Record\";\nimport * as FunctionRegistryItem from \"./FunctionRegistryItem.js\";\nimport * as MiddlewareRegistryItem from \"./MiddlewareRegistryItem.js\";\n\n/**\n * Runtime tree that mirrors a `Spec`'s group structure. Values remain unknown\n * at this boundary so producers and consumers can narrow branches and registry\n * items as needed.\n */\nexport interface RegistryItems {\n  readonly [key: string]: unknown;\n}\n\n/**\n * The names of the function-shaped entries in a group's (flat, isolated)\n * registry. `FunctionImpl.make` registers each function under a single-segment\n * key, so the registry built for one group contains exactly that group's\n * functions at the top level.\n */\nexport const functionNames = (items: RegistryItems): ReadonlyArray<string> =>\n  pipe(\n    Record.toEntries(items),\n    Array.filter(([, value]) =>\n      FunctionRegistryItem.isFunctionRegistryItem(value),\n    ),\n    Array.map(([name]) => name),\n  );\n\n/**\n * The keys of the middleware implementations registered into a group's registry\n * (stored under `middleware:<key>` entries by `MiddlewareImpl`).\n */\nexport const middlewareKeys = (items: RegistryItems): ReadonlyArray<string> =>\n  pipe(\n    Record.values(items),\n    Array.filter(MiddlewareRegistryItem.isMiddlewareRegistryItem),\n    Array.map((item) => item.middlewareSpec.key),\n  );\n"],"mappings":";;;;;;;;;;;;;;;;;AAqBA,MAAa,iBAAiB,UAC5B,KACE,OAAO,UAAU,KAAK,GACtB,MAAM,QAAQ,GAAG,WACfA,uBAA4C,KAAK,CACnD,GACA,MAAM,KAAK,CAAC,UAAU,IAAI,CAC5B;;;;;AAMF,MAAa,kBAAkB,UAC7B,KACE,OAAO,OAAO,KAAK,GACnB,MAAM,OAAOC,wBAA+C,GAC5D,MAAM,KAAK,SAAS,KAAK,eAAe,GAAG,CAC7C"}

package/dist/RequestMetadata.d.ts

@@ -0,0 +1,12 @@
+import type { MutationMeta } from "convex/server";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+export type { RequestMetadata as Metadata } from "convex/server";
+declare const RequestMetadata_base: Context.ServiceClass<RequestMetadata, "@confect/server/RequestMetadata", {
+    get: () => Effect.Effect<import("convex/server").RequestMetadata, never, never>;
+}>;
+export declare class RequestMetadata extends RequestMetadata_base {
+}
+export declare const layer: (meta: Pick<MutationMeta, "getRequestMetadata">) => Layer.Layer<RequestMetadata, never, never>;
+//# sourceMappingURL=RequestMetadata.d.ts.map

package/dist/RequestMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RequestMetadata.d.ts","sourceRoot":"","sources":["../src/RequestMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,YAAY,EAAE,eAAe,IAAI,QAAQ,EAAE,MAAM,eAAe,CAAC;;;;AAQjE,qBAAa,eAAgB,SAAQ,oBAGC;CAAG;AAEzC,eAAO,MAAM,KAAK,SAAU,IAAI,CAAC,YAAY,EAAE,oBAAoB,CAAC,+CACxB,CAAC"}

package/dist/RequestMetadata.js

@@ -0,0 +1,16 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as Effect from "effect/Effect";
+//#region src/RequestMetadata.ts
+var RequestMetadata_exports = /* @__PURE__ */ __exportAll({
+	RequestMetadata: () => RequestMetadata,
+	layer: () => layer
+});
+const make = (meta) => ({ get: Effect.fn("RequestMetadata.get")(() => Effect.promise(() => meta.getRequestMetadata())) });
+var RequestMetadata = class extends Context.Service()("@confect/server/RequestMetadata") {};
+const layer = (meta) => Layer.succeed(RequestMetadata, make(meta));
+//#endregion
+export { RequestMetadata, RequestMetadata_exports, layer };
+
+//# sourceMappingURL=RequestMetadata.js.map

package/dist/RequestMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RequestMetadata.js","names":[],"sources":["../src/RequestMetadata.ts"],"sourcesContent":["import type { MutationMeta } from \"convex/server\";\nimport * as Context from \"effect/Context\";\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\n\nexport type { RequestMetadata as Metadata } from \"convex/server\";\n\nconst make = (meta: Pick<MutationMeta, \"getRequestMetadata\">) => ({\n  get: Effect.fn(\"RequestMetadata.get\")(() =>\n    Effect.promise(() => meta.getRequestMetadata()),\n  ),\n});\n\nexport class RequestMetadata extends Context.Service<\n  RequestMetadata,\n  ReturnType<typeof make>\n>()(\"@confect/server/RequestMetadata\") {}\n\nexport const layer = (meta: Pick<MutationMeta, \"getRequestMetadata\">) =>\n  Layer.succeed(RequestMetadata, make(meta));\n"],"mappings":";;;;;;;;;AAOA,MAAM,QAAQ,UAAoD,EAChE,KAAK,OAAO,GAAG,qBAAqB,CAAC,OACnC,OAAO,cAAc,KAAK,mBAAmB,CAAC,CAChD,EACF;AAEA,IAAa,kBAAb,cAAqC,QAAQ,QAG3C,CAAC,CAAC,iCAAiC,CAAC,CAAC,CAAC;AAExC,MAAa,SAAS,SACpB,MAAM,QAAQ,iBAAiB,KAAK,IAAI,CAAC"}

package/dist/ResolvedMiddleware.d.ts

@@ -0,0 +1,24 @@
+import type * as MiddlewareSpec from "@confect/core/MiddlewareSpec";
+import type * as FunctionRegistryItem from "./FunctionRegistryItem.js";
+import type * as MiddlewareRegistryItem from "./MiddlewareRegistryItem.js";
+/**
+ * A middleware spec paired with its implementation for one function's type—the
+ * resolved form consumed by runtime-specific function preparation.
+ */
+export interface ResolvedMiddleware {
+    readonly middlewareSpec: MiddlewareSpec.AnyMiddlewareSpec;
+    readonly middlewareImpl: MiddlewareSpec.AnyMiddlewareImpl;
+    readonly options?: unknown;
+}
+/**
+ * Pair each middleware spec attached to a function with its registered
+ * implementation for the function's type. Both misses are ruled out by the type
+ * system (`GroupImpl.finalize` demands every attached middleware's
+ * `MiddlewareImpl` service; `MiddlewareImpl.make`/`makeByFunctionType` cover
+ * exactly the declared functionTypes, which `GroupSpec.middleware` requires to
+ * cover every function). Spec identity is checked separately because
+ * implementation services are keyed by string, so the type system cannot
+ * distinguish same-key specs.
+ */
+export declare const resolve: (functionRegistryItem: FunctionRegistryItem.ConfectFunctionRegistryItem, middlewareRegistryItems: ReadonlyMap<string, MiddlewareRegistryItem.MiddlewareRegistryItem>) => ReadonlyArray<ResolvedMiddleware>;
+//# sourceMappingURL=ResolvedMiddleware.d.ts.map

package/dist/ResolvedMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResolvedMiddleware.d.ts","sourceRoot":"","sources":["../src/ResolvedMiddleware.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,cAAc,MAAM,8BAA8B,CAAC;AAEpE,OAAO,KAAK,KAAK,oBAAoB,MAAM,2BAA2B,CAAC;AACvE,OAAO,KAAK,KAAK,sBAAsB,MAAM,6BAA6B,CAAC;AAE3E;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC,iBAAiB,CAAC;IAC1D,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC,iBAAiB,CAAC;IAC1D,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO,yBACI,oBAAoB,CAAC,2BAA2B,2BAC7C,WAAW,CAClC,MAAM,EACN,sBAAsB,CAAC,sBAAsB,CAC9C,KACA,aAAa,CAAC,kBAAkB,CAqClC,CAAC"}

package/dist/ResolvedMiddleware.js

@@ -0,0 +1,34 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import * as Result from "effect/Result";
+import * as MiddlewareAttachment from "@confect/core/MiddlewareAttachment";
+//#region src/ResolvedMiddleware.ts
+var ResolvedMiddleware_exports = /* @__PURE__ */ __exportAll({ resolve: () => resolve });
+/**
+* Pair each middleware spec attached to a function with its registered
+* implementation for the function's type. Both misses are ruled out by the type
+* system (`GroupImpl.finalize` demands every attached middleware's
+* `MiddlewareImpl` service; `MiddlewareImpl.make`/`makeByFunctionType` cover
+* exactly the declared functionTypes, which `GroupSpec.middleware` requires to
+* cover every function). Spec identity is checked separately because
+* implementation services are keyed by string, so the type system cannot
+* distinguish same-key specs.
+*/
+const resolve = (functionRegistryItem, middlewareRegistryItems) => {
+	Result.getOrThrowWith(MiddlewareAttachment.validateAll(functionRegistryItem.middlewareAttachments, `function "${functionRegistryItem.name}"`), (error) => new Error(MiddlewareAttachment.formatValidationError(error)));
+	return functionRegistryItem.middlewareAttachments.map(({ spec: middlewareSpec, options }) => {
+		const registered = middlewareRegistryItems.get(middlewareSpec.key);
+		if (registered === void 0) throw new Error(`Middleware "${middlewareSpec.key}" is attached to this group's spec, but no implementation was provided—pipe the group's impl through \`Layer.provide(MiddlewareImpl.make(...))\` (or \`makeByFunctionType\`/\`provides\`).`);
+		if (registered.middlewareSpec !== middlewareSpec) throw new Error(`Middleware "${middlewareSpec.key}" attached to function "${functionRegistryItem.name}" has an implementation registered for a different spec with the same key. Register the implementation using the attached middleware spec.`);
+		const middlewareImpl = registered.impls[functionRegistryItem.functionType];
+		if (middlewareImpl === void 0) throw new Error(`Middleware "${middlewareSpec.key}" has no implementation for function type "${functionRegistryItem.functionType}", the type of function "${functionRegistryItem.name}". Declare the function type in the middleware's \`functionTypes\` and cover it in \`MiddlewareImpl.makeByFunctionType\`.`);
+		return {
+			middlewareImpl,
+			middlewareSpec,
+			options
+		};
+	});
+};
+//#endregion
+export { ResolvedMiddleware_exports, resolve };
+
+//# sourceMappingURL=ResolvedMiddleware.js.map

package/dist/ResolvedMiddleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResolvedMiddleware.js","names":[],"sources":["../src/ResolvedMiddleware.ts"],"sourcesContent":["import * as MiddlewareAttachment from \"@confect/core/MiddlewareAttachment\";\nimport type * as MiddlewareSpec from \"@confect/core/MiddlewareSpec\";\nimport * as Result from \"effect/Result\";\nimport type * as FunctionRegistryItem from \"./FunctionRegistryItem.js\";\nimport type * as MiddlewareRegistryItem from \"./MiddlewareRegistryItem.js\";\n\n/**\n * A middleware spec paired with its implementation for one function's type—the\n * resolved form consumed by runtime-specific function preparation.\n */\nexport interface ResolvedMiddleware {\n  readonly middlewareSpec: MiddlewareSpec.AnyMiddlewareSpec;\n  readonly middlewareImpl: MiddlewareSpec.AnyMiddlewareImpl;\n  readonly options?: unknown;\n}\n\n/**\n * Pair each middleware spec attached to a function with its registered\n * implementation for the function's type. Both misses are ruled out by the type\n * system (`GroupImpl.finalize` demands every attached middleware's\n * `MiddlewareImpl` service; `MiddlewareImpl.make`/`makeByFunctionType` cover\n * exactly the declared functionTypes, which `GroupSpec.middleware` requires to\n * cover every function). Spec identity is checked separately because\n * implementation services are keyed by string, so the type system cannot\n * distinguish same-key specs.\n */\nexport const resolve = (\n  functionRegistryItem: FunctionRegistryItem.ConfectFunctionRegistryItem,\n  middlewareRegistryItems: ReadonlyMap<\n    string,\n    MiddlewareRegistryItem.MiddlewareRegistryItem\n  >,\n): ReadonlyArray<ResolvedMiddleware> => {\n  Result.getOrThrowWith(\n    MiddlewareAttachment.validateAll(\n      functionRegistryItem.middlewareAttachments,\n      `function \"${functionRegistryItem.name}\"`,\n    ),\n    (error) => new Error(MiddlewareAttachment.formatValidationError(error)),\n  );\n  return functionRegistryItem.middlewareAttachments.map(\n    ({ spec: middlewareSpec, options }) => {\n      const registered = middlewareRegistryItems.get(middlewareSpec.key);\n      if (registered === undefined) {\n        throw new Error(\n          `Middleware \"${middlewareSpec.key}\" is attached to this group's spec, but no implementation was provided—pipe the group's impl through \\`Layer.provide(MiddlewareImpl.make(...))\\` (or \\`makeByFunctionType\\`/\\`provides\\`).`,\n        );\n      }\n      if (registered.middlewareSpec !== middlewareSpec) {\n        throw new Error(\n          `Middleware \"${middlewareSpec.key}\" attached to function \"${functionRegistryItem.name}\" has an implementation registered for a different spec with the same key. Register the implementation using the attached middleware spec.`,\n        );\n      }\n\n      const middlewareImpl =\n        registered.impls[functionRegistryItem.functionType];\n      if (middlewareImpl === undefined) {\n        throw new Error(\n          `Middleware \"${middlewareSpec.key}\" has no implementation for function type \"${functionRegistryItem.functionType}\", the type of function \"${functionRegistryItem.name}\". Declare the function type in the middleware's \\`functionTypes\\` and cover it in \\`MiddlewareImpl.makeByFunctionType\\`.`,\n        );\n      }\n\n      return {\n        middlewareImpl,\n        middlewareSpec,\n        options,\n      };\n    },\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;AA0BA,MAAa,WACX,sBACA,4BAIsC;CACtC,OAAO,eACL,qBAAqB,YACnB,qBAAqB,uBACrB,aAAa,qBAAqB,KAAK,EACzC,IACC,UAAU,IAAI,MAAM,qBAAqB,sBAAsB,KAAK,CAAC,CACxE;CACA,OAAO,qBAAqB,sBAAsB,KAC/C,EAAE,MAAM,gBAAgB,cAAc;EACrC,MAAM,aAAa,wBAAwB,IAAI,eAAe,GAAG;EACjE,IAAI,eAAe,KAAA,GACjB,MAAM,IAAI,MACR,eAAe,eAAe,IAAI,2LACpC;EAEF,IAAI,WAAW,mBAAmB,gBAChC,MAAM,IAAI,MACR,eAAe,eAAe,IAAI,0BAA0B,qBAAqB,KAAK,2IACxF;EAGF,MAAM,iBACJ,WAAW,MAAM,qBAAqB;EACxC,IAAI,mBAAmB,KAAA,GACrB,MAAM,IAAI,MACR,eAAe,eAAe,IAAI,6CAA6C,qBAAqB,aAAa,2BAA2B,qBAAqB,KAAK,0HACxK;EAGF,OAAO;GACL;GACA;GACA;EACF;CACF,CACF;AACF"}

package/dist/Scheduler.d.ts

@@ -0,0 +1,31 @@
+import type * as IdScope from "@confect/core/IdScope";
+import { Ref } from "@confect/core";
+import type { GenericId } from "@confect/core/GenericId";
+import type { Scheduler as ConvexScheduler } from "convex/server";
+import type { GenericId as ConvexGenericId } from "convex/values";
+import * as Context from "effect/Context";
+import * as DateTime from "effect/DateTime";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+export declare const Scheduler: Context.Service<{
+    cancel: (id: ConvexGenericId<"_scheduled_functions">) => Effect.Effect<void, never, never>;
+    runAfter: <Ref_ extends Ref.AnyMutation | Ref.AnyAction>(delay: Duration.Duration, ref: Ref_, ...args: Ref.OptionalArgs<Ref_>) => Effect.Effect<ConvexGenericId<"_scheduled_functions">, never, never>;
+    runAt: <Ref_ extends Ref.AnyMutation | Ref.AnyAction>(dateTime: DateTime.DateTime, ref: Ref_, ...args: Ref.OptionalArgs<Ref_>) => Effect.Effect<ConvexGenericId<"_scheduled_functions">, never, never>;
+}, {
+    cancel: (id: ConvexGenericId<"_scheduled_functions">) => Effect.Effect<void, never, never>;
+    runAfter: <Ref_ extends Ref.AnyMutation | Ref.AnyAction>(delay: Duration.Duration, ref: Ref_, ...args: Ref.OptionalArgs<Ref_>) => Effect.Effect<ConvexGenericId<"_scheduled_functions">, never, never>;
+    runAt: <Ref_ extends Ref.AnyMutation | Ref.AnyAction>(dateTime: DateTime.DateTime, ref: Ref_, ...args: Ref.OptionalArgs<Ref_>) => Effect.Effect<ConvexGenericId<"_scheduled_functions">, never, never>;
+}>;
+export type Scheduler = typeof Scheduler.Identifier;
+export interface Service<Scope extends IdScope.IdScope = IdScope.App> {
+    cancel(id: GenericId<"_scheduled_functions", Scope>): Effect.Effect<void>;
+    runAfter<Ref_ extends Ref.AnyMutation | Ref.AnyAction>(delay: Duration.Duration, ref: Ref_, ...args: Ref.OptionalArgs<Ref_>): Effect.Effect<GenericId<"_scheduled_functions", Scope>>;
+    runAt<Ref_ extends Ref.AnyMutation | Ref.AnyAction>(dateTime: DateTime.DateTime, ref: Ref_, ...args: Ref.OptionalArgs<Ref_>): Effect.Effect<GenericId<"_scheduled_functions", Scope>>;
+}
+export type ForScope<Scope extends IdScope.IdScope> = Scope extends IdScope.App ? Scheduler : {
+    readonly "~ScopedScheduler": Scope;
+};
+export declare const forScope: <Scope extends IdScope.IdScope = IdScope.App>() => Context.Service<ForScope<Scope>, Service<Scope>>;
+export declare const layer: <Scope extends IdScope.IdScope = IdScope.App>(scheduler: ConvexScheduler, _scope?: Scope) => Layer.Layer<ForScope<Scope>, never, never>;
+//# sourceMappingURL=Scheduler.d.ts.map

package/dist/Scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Scheduler.d.ts","sourceRoot":"","sources":["../src/Scheduler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,OAAO,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AACpC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAE,SAAS,IAAI,eAAe,EAAE,MAAM,eAAe,CAAC;AAClE,OAAO,KAAK,EAAE,SAAS,IAAI,eAAe,EAAE,MAAM,eAAe,CAAC;AAClE,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAuCtC,eAAO,MAAM,SAAS;iBApCP,eAAe,CAAC,sBAAsB,CAAC;eAEzC,IAAI,SAAS,GAAG,CAAC,WAAW,GAAG,GAAG,CAAC,SAAS,SAC9C,QAAQ,CAAC,QAAQ,OACnB,IAAI,WACA,GAAG,CAAC,YAAY,CAAC,IAAI,CAAC;YAazB,IAAI,SAAS,GAAG,CAAC,WAAW,GAAG,GAAG,CAAC,SAAS,YACxC,QAAQ,CAAC,QAAQ,OACtB,IAAI,WACA,GAAG,CAAC,YAAY,CAAC,IAAI,CAAC;;;;;EAiBlC,CAAC;AACF,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,UAAU,CAAC;AAEpD,MAAM,WAAW,OAAO,CAAC,KAAK,SAAS,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC,GAAG;IAClE,MAAM,CAAC,EAAE,EAAE,SAAS,CAAC,sBAAsB,EAAE,KAAK,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC1E,QAAQ,CAAC,IAAI,SAAS,GAAG,CAAC,WAAW,GAAG,GAAG,CAAC,SAAS,EACnD,KAAK,EAAE,QAAQ,CAAC,QAAQ,EACxB,GAAG,EAAE,IAAI,EACT,GAAG,IAAI,EAAE,GAAG,CAAC,YAAY,CAAC,IAAI,CAAC,GAC9B,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,sBAAsB,EAAE,KAAK,CAAC,CAAC,CAAC;IAC3D,KAAK,CAAC,IAAI,SAAS,GAAG,CAAC,WAAW,GAAG,GAAG,CAAC,SAAS,EAChD,QAAQ,EAAE,QAAQ,CAAC,QAAQ,EAC3B,GAAG,EAAE,IAAI,EACT,GAAG,IAAI,EAAE,GAAG,CAAC,YAAY,CAAC,IAAI,CAAC,GAC9B,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,sBAAsB,EAAE,KAAK,CAAC,CAAC,CAAC;CAC5D;AAED,MAAM,MAAM,QAAQ,CAAC,KAAK,SAAS,OAAO,CAAC,OAAO,IAAI,KAAK,SAAS,OAAO,CAAC,GAAG,GAC3E,SAAS,GACT;IAAE,QAAQ,CAAC,kBAAkB,EAAE,KAAK,CAAA;CAAE,CAAC;AAE3C,eAAO,MAAM,QAAQ,GACnB,KAAK,SAAS,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC,GAAG,OACxC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CACN,CAAC;AAE/C,eAAO,MAAM,KAAK,GAAI,KAAK,SAAS,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC,GAAG,aACpD,eAAe,WACjB,KAAK,+CAMb,CAAC"}

package/dist/Scheduler.js

@@ -0,0 +1,35 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as Effect from "effect/Effect";
+import * as Duration from "effect/Duration";
+import { Ref } from "@confect/core";
+import * as DateTime from "effect/DateTime";
+//#region src/Scheduler.ts
+var Scheduler_exports = /* @__PURE__ */ __exportAll({
+	Scheduler: () => Scheduler,
+	forScope: () => forScope,
+	layer: () => layer
+});
+const make = (scheduler) => ({
+	cancel: (id) => Effect.promise(() => scheduler.cancel(id)),
+	runAfter: (delay, ref, ...args) => {
+		const delayMs = Duration.toMillis(delay);
+		const functionReference = Ref.getFunctionReference(ref);
+		const encodedArgs = Ref.encodeArgsSync(ref, args[0] ?? {});
+		return Effect.promise(() => scheduler.runAfter(delayMs, functionReference, encodedArgs));
+	},
+	runAt: (dateTime, ref, ...args) => {
+		const timestamp = DateTime.toEpochMillis(dateTime);
+		const functionReference = Ref.getFunctionReference(ref);
+		const encodedArgs = Ref.encodeArgsSync(ref, args[0] ?? {});
+		return Effect.promise(() => scheduler.runAt(timestamp, functionReference, encodedArgs));
+	}
+});
+const Scheduler = Context.Service("@confect/server/Scheduler");
+const forScope = () => Context.Service("@confect/server/Scheduler");
+const layer = (scheduler, _scope) => Layer.succeed(forScope(), make(scheduler));
+//#endregion
+export { Scheduler, Scheduler_exports, forScope, layer };
+
+//# sourceMappingURL=Scheduler.js.map

package/dist/Scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Scheduler.js","names":[],"sources":["../src/Scheduler.ts"],"sourcesContent":["import type * as IdScope from \"@confect/core/IdScope\";\nimport { Ref } from \"@confect/core\";\nimport type { GenericId } from \"@confect/core/GenericId\";\nimport type { Scheduler as ConvexScheduler } from \"convex/server\";\nimport type { GenericId as ConvexGenericId } from \"convex/values\";\nimport * as Context from \"effect/Context\";\nimport * as DateTime from \"effect/DateTime\";\nimport * as Duration from \"effect/Duration\";\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\n\nconst make = (scheduler: ConvexScheduler) => ({\n  cancel: (id: ConvexGenericId<\"_scheduled_functions\">) =>\n    Effect.promise(() => scheduler.cancel(id)),\n  runAfter: <Ref_ extends Ref.AnyMutation | Ref.AnyAction>(\n    delay: Duration.Duration,\n    ref: Ref_,\n    ...args: Ref.OptionalArgs<Ref_>\n  ) => {\n    const delayMs = Duration.toMillis(delay);\n    const functionReference = Ref.getFunctionReference(ref);\n    const encodedArgs = Ref.encodeArgsSync(\n      ref,\n      (args[0] ?? {}) as Ref.Args<Ref_>,\n    );\n\n    return Effect.promise(() =>\n      scheduler.runAfter(delayMs, functionReference, encodedArgs),\n    );\n  },\n  runAt: <Ref_ extends Ref.AnyMutation | Ref.AnyAction>(\n    dateTime: DateTime.DateTime,\n    ref: Ref_,\n    ...args: Ref.OptionalArgs<Ref_>\n  ) => {\n    const timestamp = DateTime.toEpochMillis(dateTime);\n    const functionReference = Ref.getFunctionReference(ref);\n    const encodedArgs = Ref.encodeArgsSync(\n      ref,\n      (args[0] ?? {}) as Ref.Args<Ref_>,\n    );\n\n    return Effect.promise(() =>\n      scheduler.runAt(timestamp, functionReference, encodedArgs),\n    );\n  },\n});\n\nexport const Scheduler = Context.Service<ReturnType<typeof make>>(\n  \"@confect/server/Scheduler\",\n);\nexport type Scheduler = typeof Scheduler.Identifier;\n\nexport interface Service<Scope extends IdScope.IdScope = IdScope.App> {\n  cancel(id: GenericId<\"_scheduled_functions\", Scope>): Effect.Effect<void>;\n  runAfter<Ref_ extends Ref.AnyMutation | Ref.AnyAction>(\n    delay: Duration.Duration,\n    ref: Ref_,\n    ...args: Ref.OptionalArgs<Ref_>\n  ): Effect.Effect<GenericId<\"_scheduled_functions\", Scope>>;\n  runAt<Ref_ extends Ref.AnyMutation | Ref.AnyAction>(\n    dateTime: DateTime.DateTime,\n    ref: Ref_,\n    ...args: Ref.OptionalArgs<Ref_>\n  ): Effect.Effect<GenericId<\"_scheduled_functions\", Scope>>;\n}\n\nexport type ForScope<Scope extends IdScope.IdScope> = Scope extends IdScope.App\n  ? Scheduler\n  : { readonly \"~ScopedScheduler\": Scope };\n\nexport const forScope = <\n  Scope extends IdScope.IdScope = IdScope.App,\n>(): Context.Service<ForScope<Scope>, Service<Scope>> =>\n  Context.Service(\"@confect/server/Scheduler\");\n\nexport const layer = <Scope extends IdScope.IdScope = IdScope.App>(\n  scheduler: ConvexScheduler,\n  _scope?: Scope,\n) =>\n  // Scopes are phantom: Convex still receives and returns the same ID strings.\n  Layer.succeed(\n    forScope<Scope>(),\n    make(scheduler) as unknown as Service<Scope>,\n  );\n"],"mappings":";;;;;;;;;;;;;AAWA,MAAM,QAAQ,eAAgC;CAC5C,SAAS,OACP,OAAO,cAAc,UAAU,OAAO,EAAE,CAAC;CAC3C,WACE,OACA,KACA,GAAG,SACA;EACH,MAAM,UAAU,SAAS,SAAS,KAAK;EACvC,MAAM,oBAAoB,IAAI,qBAAqB,GAAG;EACtD,MAAM,cAAc,IAAI,eACtB,KACC,KAAK,MAAM,CAAC,CACf;EAEA,OAAO,OAAO,cACZ,UAAU,SAAS,SAAS,mBAAmB,WAAW,CAC5D;CACF;CACA,QACE,UACA,KACA,GAAG,SACA;EACH,MAAM,YAAY,SAAS,cAAc,QAAQ;EACjD,MAAM,oBAAoB,IAAI,qBAAqB,GAAG;EACtD,MAAM,cAAc,IAAI,eACtB,KACC,KAAK,MAAM,CAAC,CACf;EAEA,OAAO,OAAO,cACZ,UAAU,MAAM,WAAW,mBAAmB,WAAW,CAC3D;CACF;AACF;AAEA,MAAa,YAAY,QAAQ,QAC/B,2BACF;AAqBA,MAAa,iBAGX,QAAQ,QAAQ,2BAA2B;AAE7C,MAAa,SACX,WACA,WAGA,MAAM,QACJ,SAAgB,GAChB,KAAK,SAAS,CAChB"}

package/dist/Storage.d.ts

@@ -0,0 +1,22 @@
+import type { StorageReader as ConvexStorageReader } from "convex/server";
+import type { GenericId } from "convex/values";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { StorageActionWriter } from "./StorageActionWriter.js";
+import { StorageReader } from "./StorageReader.js";
+import { StorageWriter } from "./StorageWriter.js";
+declare const Storage_base: Context.ServiceClass<Storage, "@confect/server/Storage", {
+    getUrl: (storageId: GenericId<"_storage">) => Effect.Effect<URL, import("./BlobNotFoundError.js").BlobNotFoundError, never>;
+    generateUploadUrl: Effect.Effect<URL, never, StorageWriter>;
+    delete: (storageId: GenericId<"_storage">) => Effect.Effect<void, import("./BlobNotFoundError.js").BlobNotFoundError, StorageWriter>;
+    get: (storageId: GenericId<"_storage">) => Effect.Effect<Blob, import("./BlobNotFoundError.js").BlobNotFoundError, StorageActionWriter>;
+    store: (blob: Blob, options?: {
+        sha256?: string;
+    }) => Effect.Effect<GenericId<"_storage">, never, StorageActionWriter>;
+}>;
+export declare class Storage extends Storage_base {
+}
+export declare const layer: (storageReader: ConvexStorageReader) => Layer.Layer<Storage | StorageReader, never, never>;
+export {};
+//# sourceMappingURL=Storage.d.ts.map

package/dist/Storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Storage.d.ts","sourceRoot":"","sources":["../src/Storage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,IAAI,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAC1E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;;;;wBAU3B,SAAS,CAAC,UAAU,CAAC;qBAExB,SAAS,CAAC,UAAU,CAAC;kBAExB,IAAI,YAAY;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE;;AAOrD,qBAAa,OAAQ,SAAQ,YAGC;CAAG;AAEjC,eAAO,MAAM,KAAK,kBAAmB,mBAAmB,uDAGrD,CAAC"}

package/dist/Storage.js

@@ -0,0 +1,27 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { StorageActionWriter } from "./StorageActionWriter.js";
+import { StorageReader } from "./StorageReader.js";
+import { StorageWriter } from "./StorageWriter.js";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as Effect from "effect/Effect";
+//#region src/Storage.ts
+var Storage_exports = /* @__PURE__ */ __exportAll({
+	Storage: () => Storage,
+	layer: () => layer
+});
+const make = Effect.gen(function* () {
+	return {
+		getUrl: (yield* StorageReader).getUrl,
+		generateUploadUrl: Effect.flatMap(StorageWriter, (writer) => writer.generateUploadUrl),
+		delete: (storageId) => Effect.flatMap(StorageWriter, (writer) => writer.delete(storageId)),
+		get: (storageId) => Effect.flatMap(StorageActionWriter, (writer) => writer.get(storageId)),
+		store: (blob, options) => Effect.flatMap(StorageActionWriter, (writer) => writer.store(blob, options))
+	};
+});
+var Storage = class extends Context.Service()("@confect/server/Storage") {};
+const layer = (storageReader) => Layer.effect(Storage, make).pipe(Layer.provideMerge(StorageReader.layer(storageReader)));
+//#endregion
+export { Storage, Storage_exports, layer };
+
+//# sourceMappingURL=Storage.js.map

package/dist/Storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Storage.js","names":[],"sources":["../src/Storage.ts"],"sourcesContent":["import type { StorageReader as ConvexStorageReader } from \"convex/server\";\nimport type { GenericId } from \"convex/values\";\nimport * as Context from \"effect/Context\";\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\nimport { StorageActionWriter } from \"./StorageActionWriter.js\";\nimport { StorageReader } from \"./StorageReader.js\";\nimport { StorageWriter } from \"./StorageWriter.js\";\n\nconst make = Effect.gen(function* () {\n  const reader = yield* StorageReader;\n  return {\n    getUrl: reader.getUrl,\n    generateUploadUrl: Effect.flatMap(\n      StorageWriter,\n      (writer) => writer.generateUploadUrl,\n    ),\n    delete: (storageId: GenericId<\"_storage\">) =>\n      Effect.flatMap(StorageWriter, (writer) => writer.delete(storageId)),\n    get: (storageId: GenericId<\"_storage\">) =>\n      Effect.flatMap(StorageActionWriter, (writer) => writer.get(storageId)),\n    store: (blob: Blob, options?: { sha256?: string }) =>\n      Effect.flatMap(StorageActionWriter, (writer) =>\n        writer.store(blob, options),\n      ),\n  };\n});\n\nexport class Storage extends Context.Service<\n  Storage,\n  Effect.Success<typeof make>\n>()(\"@confect/server/Storage\") {}\n\nexport const layer = (storageReader: ConvexStorageReader) =>\n  Layer.effect(Storage, make).pipe(\n    Layer.provideMerge(StorageReader.layer(storageReader)),\n  );\n"],"mappings":";;;;;;;;;;;;AASA,MAAM,OAAO,OAAO,IAAI,aAAa;CAEnC,OAAO;EACL,SAAQ,OAFY,cAAA,CAEL;EACf,mBAAmB,OAAO,QACxB,gBACC,WAAW,OAAO,iBACrB;EACA,SAAS,cACP,OAAO,QAAQ,gBAAgB,WAAW,OAAO,OAAO,SAAS,CAAC;EACpE,MAAM,cACJ,OAAO,QAAQ,sBAAsB,WAAW,OAAO,IAAI,SAAS,CAAC;EACvE,QAAQ,MAAY,YAClB,OAAO,QAAQ,sBAAsB,WACnC,OAAO,MAAM,MAAM,OAAO,CAC5B;CACJ;AACF,CAAC;AAED,IAAa,UAAb,cAA6B,QAAQ,QAGnC,CAAC,CAAC,yBAAyB,CAAC,CAAC,CAAC;AAEhC,MAAa,SAAS,kBACpB,MAAM,OAAO,SAAS,IAAI,CAAC,CAAC,KAC1B,MAAM,aAAa,cAAc,MAAM,aAAa,CAAC,CACvD"}

package/dist/StorageActionWriter.d.ts

@@ -0,0 +1,35 @@
+import type * as IdScope from "@confect/core/IdScope";
+import type { StorageActionWriter as ConvexStorageActionWriter } from "convex/server";
+import type { GenericId } from "convex/values";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { BlobNotFoundError } from "./BlobNotFoundError.js";
+import type * as ScopedId from "@confect/core/GenericId";
+export type Service<Scope extends IdScope.IdScope = IdScope.App> = {
+    get: (id: ScopedId.GenericId<"_storage", Scope>) => ReturnType<ReturnType<typeof make>["get"]>;
+    store: (blob: Blob, options?: {
+        sha256?: string;
+    }) => Effect.Effect<ScopedId.GenericId<"_storage", Scope>>;
+};
+export type ForScope<Scope extends IdScope.IdScope> = Scope extends IdScope.App ? StorageActionWriter : {
+    readonly "~ScopedStorageActionWriter": Scope;
+};
+declare const make: (storageActionWriter: ConvexStorageActionWriter) => {
+    get: (storageId: GenericId<"_storage">) => Effect.Effect<Blob, BlobNotFoundError, never>;
+    store: (blob: Blob, options?: {
+        sha256?: string;
+    }) => Effect.Effect<GenericId<"_storage">, never, never>;
+};
+declare const StorageActionWriter_base: Context.ServiceClass<StorageActionWriter, "@confect/server/StorageActionWriter", {
+    get: (storageId: GenericId<"_storage">) => Effect.Effect<Blob, BlobNotFoundError, never>;
+    store: (blob: Blob, options?: {
+        sha256?: string;
+    }) => Effect.Effect<GenericId<"_storage">, never, never>;
+}>;
+export declare class StorageActionWriter extends StorageActionWriter_base {
+    static readonly forScope: <Scope extends IdScope.IdScope = IdScope.App>() => Context.Service<ForScope<Scope>, Service<Scope>>;
+    static readonly layer: <Scope extends IdScope.IdScope = IdScope.App>(storageActionWriter: ConvexStorageActionWriter, _scope?: Scope) => Layer.Layer<ForScope<Scope>, never, never>;
+}
+export {};
+//# sourceMappingURL=StorageActionWriter.d.ts.map

package/dist/StorageActionWriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StorageActionWriter.d.ts","sourceRoot":"","sources":["../src/StorageActionWriter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,OAAO,MAAM,uBAAuB,CAAC;AACtD,OAAO,KAAK,EAAE,mBAAmB,IAAI,yBAAyB,EAAE,MAAM,eAAe,CAAC;AACtF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAE1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,KAAK,QAAQ,MAAM,yBAAyB,CAAC;AAEzD,MAAM,MAAM,OAAO,CAAC,KAAK,SAAS,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC,GAAG,IAAI;IACjE,GAAG,EAAE,CACH,EAAE,EAAE,QAAQ,CAAC,SAAS,CAAC,UAAU,EAAE,KAAK,CAAC,KACtC,UAAU,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;IAChD,KAAK,EAAE,CACL,IAAI,EAAE,IAAI,EACV,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,KAC1B,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC,CAAC;CAC3D,CAAC;AACF,MAAM,MAAM,QAAQ,CAAC,KAAK,SAAS,OAAO,CAAC,OAAO,IAAI,KAAK,SAAS,OAAO,CAAC,GAAG,GAC3E,mBAAmB,GACnB;IAAE,QAAQ,CAAC,4BAA4B,EAAE,KAAK,CAAA;CAAE,CAAC;AAErD,QAAA,MAAM,IAAI,wBAAyB,yBAAyB;IAC1D,GAAG,cAAc,SAAS,CAAC,UAAU,CAAC;IAYtC,KAAK,SAAS,IAAI,YAAY;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE;CAEjD,CAAC;;qBAdgB,SAAS,CAAC,UAAU,CAAC;kBAYxB,IAAI,YAAY;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE;;AAInD,qBAAa,mBAAoB,SAAQ,wBAGC;IACxC,MAAM,CAAC,QAAQ,CAAC,QAAQ,GACtB,KAAK,SAAS,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC,GAAG,OACxC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CACI;IAEzD,MAAM,CAAC,QAAQ,CAAC,KAAK,GAAI,KAAK,SAAS,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC,GAAG,uBAC7C,yBAAyB,WACrC,KAAK,gDAKZ;CACL"}

package/dist/StorageActionWriter.js

@@ -0,0 +1,24 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { BlobNotFoundError } from "./BlobNotFoundError.js";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as Effect from "effect/Effect";
+import { flow } from "effect/Function";
+import * as Option from "effect/Option";
+//#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.fromNullishOr, 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 Context.Service()("@confect/server/StorageActionWriter") {
+	static forScope = () => Context.Service("@confect/server/StorageActionWriter");
+	static layer = (storageActionWriter, _scope) => Layer.succeed(this.forScope(), 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 * as IdScope from \"@confect/core/IdScope\";\nimport type { StorageActionWriter as ConvexStorageActionWriter } from \"convex/server\";\nimport type { GenericId } from \"convex/values\";\nimport * as Context from \"effect/Context\";\nimport { flow } from \"effect/Function\";\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\nimport * as Option from \"effect/Option\";\nimport { BlobNotFoundError } from \"./BlobNotFoundError.js\";\nimport type * as ScopedId from \"@confect/core/GenericId\";\n\nexport type Service<Scope extends IdScope.IdScope = IdScope.App> = {\n  get: (\n    id: ScopedId.GenericId<\"_storage\", Scope>,\n  ) => ReturnType<ReturnType<typeof make>[\"get\"]>;\n  store: (\n    blob: Blob,\n    options?: { sha256?: string },\n  ) => Effect.Effect<ScopedId.GenericId<\"_storage\", Scope>>;\n};\nexport type ForScope<Scope extends IdScope.IdScope> = Scope extends IdScope.App\n  ? StorageActionWriter\n  : { readonly \"~ScopedStorageActionWriter\": Scope };\n\nconst make = (storageActionWriter: ConvexStorageActionWriter) => ({\n  get: (storageId: GenericId<\"_storage\">) =>\n    Effect.promise(() => storageActionWriter.get(storageId)).pipe(\n      Effect.andThen(\n        flow(\n          Option.fromNullishOr,\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 Context.Service<\n  StorageActionWriter,\n  ReturnType<typeof make>\n>()(\"@confect/server/StorageActionWriter\") {\n  static readonly forScope = <\n    Scope extends IdScope.IdScope = IdScope.App,\n  >(): Context.Service<ForScope<Scope>, Service<Scope>> =>\n    Context.Service(\"@confect/server/StorageActionWriter\");\n\n  static readonly layer = <Scope extends IdScope.IdScope = IdScope.App>(\n    storageActionWriter: ConvexStorageActionWriter,\n    _scope?: Scope,\n  ) =>\n    Layer.succeed(\n      this.forScope<Scope>(),\n      make(storageActionWriter) as unknown as Service<Scope>,\n    );\n}\n"],"mappings":";;;;;;;;;AAwBA,MAAM,QAAQ,yBAAoD;CAChE,MAAM,cACJ,OAAO,cAAc,oBAAoB,IAAI,SAAS,CAAC,CAAC,CAAC,KACvD,OAAO,QACL,KACE,OAAO,eACP,OAAO,MAAM;EACX,cAAc,OAAO,KAAK,IAAI,kBAAkB,EAAE,IAAI,UAAU,CAAC,CAAC;EAClE,QAAQ,OAAO;CACjB,CAAC,CACH,CACF,CACF;CACF,QAAQ,MAAY,YAClB,OAAO,cAAc,oBAAoB,MAAM,MAAM,OAAO,CAAC;AACjE;AAEA,IAAa,sBAAb,cAAyC,QAAQ,QAG/C,CAAC,CAAC,qCAAqC,CAAC,CAAC;CACzC,OAAgB,iBAGd,QAAQ,QAAQ,qCAAqC;CAEvD,OAAgB,SACd,qBACA,WAEA,MAAM,QACJ,KAAK,SAAgB,GACrB,KAAK,mBAAmB,CAC1B;AACJ"}

package/dist/StorageReader.d.ts

@@ -0,0 +1,26 @@
+import type * as IdScope from "@confect/core/IdScope";
+import type { StorageReader as ConvexStorageReader } from "convex/server";
+import type { GenericId } from "convex/values";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { BlobNotFoundError } from "./BlobNotFoundError.js";
+import type * as ScopedId from "@confect/core/GenericId";
+export type Service<Scope extends IdScope.IdScope = IdScope.App> = {
+    getUrl: (id: ScopedId.GenericId<"_storage", Scope>) => ReturnType<ReturnType<typeof make>["getUrl"]>;
+};
+export type ForScope<Scope extends IdScope.IdScope> = Scope extends IdScope.App ? StorageReader : {
+    readonly "~ScopedStorageReader": Scope;
+};
+declare const make: (storageReader: ConvexStorageReader) => {
+    getUrl: (storageId: GenericId<"_storage">) => Effect.Effect<URL, BlobNotFoundError, never>;
+};
+declare const StorageReader_base: Context.ServiceClass<StorageReader, "@confect/server/StorageReader", {
+    getUrl: (storageId: GenericId<"_storage">) => Effect.Effect<URL, BlobNotFoundError, never>;
+}>;
+export declare class StorageReader extends StorageReader_base {
+    static readonly forScope: <Scope extends IdScope.IdScope = IdScope.App>() => Context.Service<ForScope<Scope>, Service<Scope>>;
+    static readonly layer: <Scope extends IdScope.IdScope = IdScope.App>(storageReader: ConvexStorageReader, _scope?: Scope) => Layer.Layer<ForScope<Scope>, never, never>;
+}
+export {};
+//# sourceMappingURL=StorageReader.d.ts.map

package/dist/StorageReader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StorageReader.d.ts","sourceRoot":"","sources":["../src/StorageReader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,OAAO,MAAM,uBAAuB,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,IAAI,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAC1E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAE1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAGtC,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,KAAK,QAAQ,MAAM,yBAAyB,CAAC;AAEzD,MAAM,MAAM,OAAO,CAAC,KAAK,SAAS,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC,GAAG,IAAI;IACjE,MAAM,EAAE,CACN,EAAE,EAAE,QAAQ,CAAC,SAAS,CAAC,UAAU,EAAE,KAAK,CAAC,KACtC,UAAU,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;CACpD,CAAC;AACF,MAAM,MAAM,QAAQ,CAAC,KAAK,SAAS,OAAO,CAAC,OAAO,IAAI,KAAK,SAAS,OAAO,CAAC,GAAG,GAC3E,aAAa,GACb;IAAE,QAAQ,CAAC,sBAAsB,EAAE,KAAK,CAAA;CAAE,CAAC;AAE/C,QAAA,MAAM,IAAI,kBAAmB,mBAAmB;IAC9C,MAAM,cAAc,SAAS,CAAC,UAAU,CAAC;CAiBzC,CAAC;;wBAjBmB,SAAS,CAAC,UAAU,CAAC;;AAmB3C,qBAAa,aAAc,SAAQ,kBAGC;IAClC,MAAM,CAAC,QAAQ,CAAC,QAAQ,GACtB,KAAK,SAAS,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC,GAAG,OACxC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CACF;IAEnD,MAAM,CAAC,QAAQ,CAAC,KAAK,GAAI,KAAK,SAAS,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC,GAAG,iBACnD,mBAAmB,WACzB,KAAK,gDAKZ;CACL"}

package/dist/StorageReader.js

@@ -0,0 +1,22 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { BlobNotFoundError } from "./BlobNotFoundError.js";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { flow, pipe } from "effect/Function";
+import * as Option from "effect/Option";
+//#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.fromNullishOr, Option.match({
+	onNone: () => Effect.fail(new BlobNotFoundError({ id: storageId })),
+	onSome: (doc) => pipe(doc, Schema.decodeEffect(Schema.URLFromString), Effect.catchTag("SchemaError", Effect.die))
+})))) });
+var StorageReader = class extends Context.Service()("@confect/server/StorageReader") {
+	static forScope = () => Context.Service("@confect/server/StorageReader");
+	static layer = (storageReader, _scope) => Layer.succeed(this.forScope(), 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 * as IdScope from \"@confect/core/IdScope\";\nimport type { StorageReader as ConvexStorageReader } from \"convex/server\";\nimport type { GenericId } from \"convex/values\";\nimport * as Context from \"effect/Context\";\nimport { flow, pipe } from \"effect/Function\";\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\nimport * as Option from \"effect/Option\";\nimport * as Schema from \"effect/Schema\";\nimport { BlobNotFoundError } from \"./BlobNotFoundError.js\";\nimport type * as ScopedId from \"@confect/core/GenericId\";\n\nexport type Service<Scope extends IdScope.IdScope = IdScope.App> = {\n  getUrl: (\n    id: ScopedId.GenericId<\"_storage\", Scope>,\n  ) => ReturnType<ReturnType<typeof make>[\"getUrl\"]>;\n};\nexport type ForScope<Scope extends IdScope.IdScope> = Scope extends IdScope.App\n  ? StorageReader\n  : { readonly \"~ScopedStorageReader\": Scope };\n\nconst make = (storageReader: ConvexStorageReader) => ({\n  getUrl: (storageId: GenericId<\"_storage\">) =>\n    Effect.promise(() => storageReader.getUrl(storageId)).pipe(\n      Effect.andThen(\n        flow(\n          Option.fromNullishOr,\n          Option.match({\n            onNone: () => Effect.fail(new BlobNotFoundError({ id: storageId })),\n            onSome: (doc) =>\n              pipe(\n                doc,\n                Schema.decodeEffect(Schema.URLFromString),\n                Effect.catchTag(\"SchemaError\", Effect.die),\n              ),\n          }),\n        ),\n      ),\n    ),\n});\n\nexport class StorageReader extends Context.Service<\n  StorageReader,\n  ReturnType<typeof make>\n>()(\"@confect/server/StorageReader\") {\n  static readonly forScope = <\n    Scope extends IdScope.IdScope = IdScope.App,\n  >(): Context.Service<ForScope<Scope>, Service<Scope>> =>\n    Context.Service(\"@confect/server/StorageReader\");\n\n  static readonly layer = <Scope extends IdScope.IdScope = IdScope.App>(\n    storageReader: ConvexStorageReader,\n    _scope?: Scope,\n  ) =>\n    Layer.succeed(\n      this.forScope<Scope>(),\n      make(storageReader) as unknown as Service<Scope>,\n    );\n}\n"],"mappings":";;;;;;;;;;AAqBA,MAAM,QAAQ,mBAAwC,EACpD,SAAS,cACP,OAAO,cAAc,cAAc,OAAO,SAAS,CAAC,CAAC,CAAC,KACpD,OAAO,QACL,KACE,OAAO,eACP,OAAO,MAAM;CACX,cAAc,OAAO,KAAK,IAAI,kBAAkB,EAAE,IAAI,UAAU,CAAC,CAAC;CAClE,SAAS,QACP,KACE,KACA,OAAO,aAAa,OAAO,aAAa,GACxC,OAAO,SAAS,eAAe,OAAO,GAAG,CAC3C;AACJ,CAAC,CACH,CACF,CACF,EACJ;AAEA,IAAa,gBAAb,cAAmC,QAAQ,QAGzC,CAAC,CAAC,+BAA+B,CAAC,CAAC;CACnC,OAAgB,iBAGd,QAAQ,QAAQ,+BAA+B;CAEjD,OAAgB,SACd,eACA,WAEA,MAAM,QACJ,KAAK,SAAgB,GACrB,KAAK,aAAa,CACpB;AACJ"}

package/dist/StorageWriter.d.ts

@@ -0,0 +1,29 @@
+import type * as IdScope from "@confect/core/IdScope";
+import type { StorageWriter as ConvexStorageWriter } from "convex/server";
+import type { GenericId } from "convex/values";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { BlobNotFoundError } from "./BlobNotFoundError.js";
+import type * as ScopedId from "@confect/core/GenericId";
+export type Service<Scope extends IdScope.IdScope = IdScope.App> = {
+    generateUploadUrl: ReturnType<typeof make>["generateUploadUrl"];
+    delete: (id: ScopedId.GenericId<"_storage", Scope>) => ReturnType<ReturnType<typeof make>["delete"]>;
+};
+export type ForScope<Scope extends IdScope.IdScope> = Scope extends IdScope.App ? StorageWriter : {
+    readonly "~ScopedStorageWriter": Scope;
+};
+declare const make: (storageWriter: ConvexStorageWriter) => {
+    generateUploadUrl: Effect.Effect<URL, never, never>;
+    delete: (storageId: GenericId<"_storage">) => Effect.Effect<void, BlobNotFoundError, never>;
+};
+declare const StorageWriter_base: Context.ServiceClass<StorageWriter, "@confect/server/StorageWriter", {
+    generateUploadUrl: Effect.Effect<URL, never, never>;
+    delete: (storageId: GenericId<"_storage">) => Effect.Effect<void, BlobNotFoundError, never>;
+}>;
+export declare class StorageWriter extends StorageWriter_base {
+    static readonly forScope: <Scope extends IdScope.IdScope = IdScope.App>() => Context.Service<ForScope<Scope>, Service<Scope>>;
+    static readonly layer: <Scope extends IdScope.IdScope = IdScope.App>(storageWriter: ConvexStorageWriter, _scope?: Scope) => Layer.Layer<ForScope<Scope>, never, never>;
+}
+export {};
+//# sourceMappingURL=StorageWriter.d.ts.map

package/dist/StorageWriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StorageWriter.d.ts","sourceRoot":"","sources":["../src/StorageWriter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,OAAO,MAAM,uBAAuB,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,IAAI,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAC1E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAE1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,KAAK,QAAQ,MAAM,yBAAyB,CAAC;AAEzD,MAAM,MAAM,OAAO,CAAC,KAAK,SAAS,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC,GAAG,IAAI;IACjE,iBAAiB,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAChE,MAAM,EAAE,CACN,EAAE,EAAE,QAAQ,CAAC,SAAS,CAAC,UAAU,EAAE,KAAK,CAAC,KACtC,UAAU,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;CACpD,CAAC;AACF,MAAM,MAAM,QAAQ,CAAC,KAAK,SAAS,OAAO,CAAC,OAAO,IAAI,KAAK,SAAS,OAAO,CAAC,GAAG,GAC3E,aAAa,GACb;IAAE,QAAQ,CAAC,sBAAsB,EAAE,KAAK,CAAA;CAAE,CAAC;AAE/C,QAAA,MAAM,IAAI,kBAAmB,mBAAmB;IAC9C,iBAAiB;IAWjB,MAAM,cAAc,SAAS,CAAC,UAAU,CAAC;CAKzC,CAAC;;;wBALmB,SAAS,CAAC,UAAU,CAAC;;AAO3C,qBAAa,aAAc,SAAQ,kBAGC;IAClC,MAAM,CAAC,QAAQ,CAAC,QAAQ,GACtB,KAAK,SAAS,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC,GAAG,OACxC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CACF;IAEnD,MAAM,CAAC,QAAQ,CAAC,KAAK,GAAI,KAAK,SAAS,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC,GAAG,iBACnD,mBAAmB,WACzB,KAAK,gDAKZ;CACL"}

package/dist/StorageWriter.js

@@ -0,0 +1,24 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { BlobNotFoundError } from "./BlobNotFoundError.js";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { pipe } from "effect/Function";
+//#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.decodeEffect(Schema.URLFromString), Effect.catchTag("SchemaError", Effect.die)))),
+	delete: (storageId) => Effect.tryPromise({
+		try: () => storageWriter.delete(storageId),
+		catch: () => new BlobNotFoundError({ id: storageId })
+	})
+});
+var StorageWriter = class extends Context.Service()("@confect/server/StorageWriter") {
+	static forScope = () => Context.Service("@confect/server/StorageWriter");
+	static layer = (storageWriter, _scope) => Layer.succeed(this.forScope(), 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 * as IdScope from \"@confect/core/IdScope\";\nimport type { StorageWriter as ConvexStorageWriter } from \"convex/server\";\nimport type { GenericId } from \"convex/values\";\nimport * as Context from \"effect/Context\";\nimport { pipe } from \"effect/Function\";\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\nimport * as Schema from \"effect/Schema\";\nimport { BlobNotFoundError } from \"./BlobNotFoundError.js\";\nimport type * as ScopedId from \"@confect/core/GenericId\";\n\nexport type Service<Scope extends IdScope.IdScope = IdScope.App> = {\n  generateUploadUrl: ReturnType<typeof make>[\"generateUploadUrl\"];\n  delete: (\n    id: ScopedId.GenericId<\"_storage\", Scope>,\n  ) => ReturnType<ReturnType<typeof make>[\"delete\"]>;\n};\nexport type ForScope<Scope extends IdScope.IdScope> = Scope extends IdScope.App\n  ? StorageWriter\n  : { readonly \"~ScopedStorageWriter\": Scope };\n\nconst make = (storageWriter: ConvexStorageWriter) => ({\n  generateUploadUrl: Effect.promise(() =>\n    storageWriter.generateUploadUrl(),\n  ).pipe(\n    Effect.andThen((url) =>\n      pipe(\n        url,\n        Schema.decodeEffect(Schema.URLFromString),\n        Effect.catchTag(\"SchemaError\", Effect.die),\n      ),\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 Context.Service<\n  StorageWriter,\n  ReturnType<typeof make>\n>()(\"@confect/server/StorageWriter\") {\n  static readonly forScope = <\n    Scope extends IdScope.IdScope = IdScope.App,\n  >(): Context.Service<ForScope<Scope>, Service<Scope>> =>\n    Context.Service(\"@confect/server/StorageWriter\");\n\n  static readonly layer = <Scope extends IdScope.IdScope = IdScope.App>(\n    storageWriter: ConvexStorageWriter,\n    _scope?: Scope,\n  ) =>\n    Layer.succeed(\n      this.forScope<Scope>(),\n      make(storageWriter) as unknown as Service<Scope>,\n    );\n}\n"],"mappings":";;;;;;;;;AAqBA,MAAM,QAAQ,mBAAwC;CACpD,mBAAmB,OAAO,cACxB,cAAc,kBAAkB,CAClC,CAAC,CAAC,KACA,OAAO,SAAS,QACd,KACE,KACA,OAAO,aAAa,OAAO,aAAa,GACxC,OAAO,SAAS,eAAe,OAAO,GAAG,CAC3C,CACF,CACF;CACA,SAAS,cACP,OAAO,WAAW;EAChB,WAAW,cAAc,OAAO,SAAS;EACzC,aAAa,IAAI,kBAAkB,EAAE,IAAI,UAAU,CAAC;CACtD,CAAC;AACL;AAEA,IAAa,gBAAb,cAAmC,QAAQ,QAGzC,CAAC,CAAC,+BAA+B,CAAC,CAAC;CACnC,OAAgB,iBAGd,QAAQ,QAAQ,+BAA+B;CAEjD,OAAgB,SACd,eACA,WAEA,MAAM,QACJ,KAAK,SAAgB,GACrB,KAAK,aAAa,CACpB;AACJ"}