@confect/server 2.0.0 → 4.0.0

package/dist/RegisteredFunctions.d.ts

@@ -1,6 +1,6 @@
 import { AnyWithProps as AnyWithProps$1 } from "./Api.js";
+import { Any, RegisteredFunction } from "./RegisteredFunction.js";
 import { Impl } from "./Impl.js";
-import { RegisteredFunction } from "./RegisteredFunction.js";
 import { AnyWithProps as AnyWithProps$2 } from "./RegistryItem.js";
 import { Layer, Types } from "effect";
 import * as Spec from "@confect/core/Spec";
@@ -12,11 +12,11 @@ declare namespace RegisteredFunctions_d_exports {
   export { AnyWithProps, RegisteredFunctions, make };
 }
 type RegisteredFunctions<Spec_ extends Spec.AnyWithProps> = Types.Simplify<RegisteredFunctionsHelper<Spec.Groups<Spec_>>>;
-type RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = { [GroupName in GroupSpec.Name<Groups>]: GroupSpec.WithName<Groups, GroupName> extends infer Group extends GroupSpec.AnyWithProps ? GroupSpec.Groups<Group> extends infer SubGroups extends GroupSpec.AnyWithProps ? Types.Simplify<RegisteredFunctionsHelper<SubGroups> & { [FunctionName in FunctionSpec.Name<GroupSpec.Functions<Group>>]: FunctionSpec.WithName<GroupSpec.Functions<Group>, FunctionName> extends infer Function extends FunctionSpec.AnyWithProps ? FunctionSpec.RegisteredFunction<Function> : never }> : { [FunctionName in FunctionSpec.Name<GroupSpec.Functions<Group>>]: FunctionSpec.WithName<GroupSpec.Functions<Group>, FunctionName> extends infer Function extends FunctionSpec.AnyWithProps ? FunctionSpec.RegisteredFunction<Function> : never } : never };
+type RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = { [GroupName in GroupSpec.Name<Groups>]: GroupSpec.WithName<Groups, GroupName> extends infer Group extends GroupSpec.AnyWithProps ? GroupSpec.Groups<Group> extends infer SubGroups extends GroupSpec.AnyWithProps ? Types.Simplify<RegisteredFunctionsHelper<SubGroups> & { [FunctionName in FunctionSpec.Name<GroupSpec.Functions<Group>>]: FunctionSpec.WithName<GroupSpec.Functions<Group>, FunctionName> extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps ? RegisteredFunction<FunctionSpec_> : never }> : { [FunctionName in FunctionSpec.Name<GroupSpec.Functions<Group>>]: FunctionSpec.WithName<GroupSpec.Functions<Group>, FunctionName> extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps ? RegisteredFunction<FunctionSpec_> : never } : never };
 interface AnyWithProps {
-  readonly [key: string]: RegisteredFunction | AnyWithProps;
+  readonly [key: string]: Any | AnyWithProps;
 }
-declare const make: <Api_ extends AnyWithProps$1>(impl: Layer.Layer<Impl<Api_, "Finalized">>, makeRegisteredFunction: (api: Api_, registryItem: AnyWithProps$2) => RegisteredFunction) => Types.Simplify<RegisteredFunctionsHelper<Spec.Groups<Api_["spec"]>>>;
+declare const make: <Api_ extends AnyWithProps$1>(impl: Layer.Layer<Impl<Api_, "Finalized">>, makeRegisteredFunction: (api: Api_, registryItem: AnyWithProps$2) => Any) => Types.Simplify<RegisteredFunctionsHelper<Spec.Groups<Api_["spec"]>>>;
 //#endregion
 export { AnyWithProps, RegisteredFunctions, RegisteredFunctions_d_exports, make };
 //# sourceMappingURL=RegisteredFunctions.d.ts.map

package/dist/RegisteredFunctions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredFunctions.d.ts","names":[],"sources":["../src/RegisteredFunctions.ts"],"mappings":";;;;;;;;;;;;;KAYY,mBAAA,eAAkC,IAAA,CAAK,YAAA,IACjD,KAAA,CAAM,QAAA,CAAS,yBAAA,CAA0B,IAAA,CAAK,MAAA,CAAO,KAAA;AAAA,KAElD,yBAAA,gBAAyC,SAAA,CAAU,YAAA,oBACxC,SAAA,CAAU,IAAA,CAAK,MAAA,IAAU,SAAA,CAAU,QAAA,CAC/C,MAAA,EACA,SAAA,8BAC4B,SAAA,CAAU,YAAA,GACpC,SAAA,CAAU,MAAA,CAAO,KAAA,kCACf,SAAA,CAAU,YAAA,GACV,KAAA,CAAM,QAAA,CACJ,yBAAA,CAA0B,SAAA,uBACP,YAAA,CAAa,IAAA,CAC5B,SAAA,CAAU,SAAA,CAAU,KAAA,KAClB,YAAA,CAAa,QAAA,CACf,SAAA,CAAU,SAAA,CAAU,KAAA,GACpB,YAAA,iCAC+B,YAAA,CAAa,YAAA,GAC1C,YAAA,CAAa,kBAAA,CAAmB,QAAA,kCAKrB,YAAA,CAAa,IAAA,CAC5B,SAAA,CAAU,SAAA,CAAU,KAAA,KAClB,YAAA,CAAa,QAAA,CACf,SAAA,CAAU,SAAA,CAAU,KAAA,GACpB,YAAA,iCAC+B,YAAA,CAAa,YAAA,GAC1C,YAAA,CAAa,kBAAA,CAAmB,QAAA;AAAA,UAM7B,YAAA;EAAA,UACL,GAAA,WAAc,kBAAA,GAAwC,YAAA;AAAA;AAAA,cAGrD,IAAA,gBAAqB,cAAA,EAChC,IAAA,EAAM,KAAA,CAAM,KAAA,CAAM,IAAA,CAAU,IAAA,iBAC5B,sBAAA,GACE,GAAA,EAAK,IAAA,EACL,YAAA,EAAc,cAAA,KACX,kBAAA,KAAqC,KAAA,CAAA,QAAA,CAAA,yBAAA,CAAA,IAAA,CAAA,MAAA,CAAA,IAAA"}
+{"version":3,"file":"RegisteredFunctions.d.ts","names":[],"sources":["../src/RegisteredFunctions.ts"],"mappings":";;;;;;;;;;;;;KAYY,mBAAA,eAAkC,IAAA,CAAK,YAAA,IACjD,KAAA,CAAM,QAAA,CAAS,yBAAA,CAA0B,IAAA,CAAK,MAAA,CAAO,KAAA;AAAA,KAElD,yBAAA,gBAAyC,SAAA,CAAU,YAAA,oBACxC,SAAA,CAAU,IAAA,CAAK,MAAA,IAAU,SAAA,CAAU,QAAA,CAC/C,MAAA,EACA,SAAA,8BAC4B,SAAA,CAAU,YAAA,GACpC,SAAA,CAAU,MAAA,CAAO,KAAA,kCACf,SAAA,CAAU,YAAA,GACV,KAAA,CAAM,QAAA,CACJ,yBAAA,CAA0B,SAAA,uBACP,YAAA,CAAa,IAAA,CAC5B,SAAA,CAAU,SAAA,CAAU,KAAA,KAClB,YAAA,CAAa,QAAA,CACf,SAAA,CAAU,SAAA,CAAU,KAAA,GACpB,YAAA,sCACoC,YAAA,CAAa,YAAA,GAC/C,kBAAA,CAAsC,aAAA,kCAK3B,YAAA,CAAa,IAAA,CAC5B,SAAA,CAAU,SAAA,CAAU,KAAA,KAClB,YAAA,CAAa,QAAA,CACf,SAAA,CAAU,SAAA,CAAU,KAAA,GACpB,YAAA,sCACoC,YAAA,CAAa,YAAA,GAC/C,kBAAA,CAAsC,aAAA;AAAA,UAMnC,YAAA;EAAA,UACL,GAAA,WAAc,GAAA,GAAyB,YAAA;AAAA;AAAA,cAGtC,IAAA,gBAAqB,cAAA,EAChC,IAAA,EAAM,KAAA,CAAM,KAAA,CAAM,IAAA,CAAU,IAAA,iBAC5B,sBAAA,GACE,GAAA,EAAK,IAAA,EACL,YAAA,EAAc,cAAA,KACX,GAAA,KAAsB,KAAA,CAAA,QAAA,CAAA,yBAAA,CAAA,IAAA,CAAA,MAAA,CAAA,IAAA"}

package/dist/RegisteredFunctions.js.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredFunctions.js","names":["Registry.Registry","Impl.Impl","RegistryItem.isRegistryItem"],"sources":["../src/RegisteredFunctions.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport type * as GroupSpec from \"@confect/core/GroupSpec\";\nimport type * as Spec from \"@confect/core/Spec\";\nimport type { Layer } from \"effect\";\nimport { Effect, Match, Ref, type Types } from \"effect\";\nimport type * as Api from \"./Api\";\nimport * as Impl from \"./Impl\";\nimport { mapLeaves } from \"./internal/utils\";\nimport type * as RegisteredFunction from \"./RegisteredFunction\";\nimport * as Registry from \"./Registry\";\nimport * as RegistryItem from \"./RegistryItem\";\n\nexport type RegisteredFunctions<Spec_ extends Spec.AnyWithProps> =\n  Types.Simplify<RegisteredFunctionsHelper<Spec.Groups<Spec_>>>;\n\ntype RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = {\n  [GroupName in GroupSpec.Name<Groups>]: GroupSpec.WithName<\n    Groups,\n    GroupName\n  > extends infer Group extends GroupSpec.AnyWithProps\n    ? GroupSpec.Groups<Group> extends infer SubGroups extends\n        GroupSpec.AnyWithProps\n      ? Types.Simplify<\n          RegisteredFunctionsHelper<SubGroups> & {\n            [FunctionName in FunctionSpec.Name<\n              GroupSpec.Functions<Group>\n            >]: FunctionSpec.WithName<\n              GroupSpec.Functions<Group>,\n              FunctionName\n            > extends infer Function extends FunctionSpec.AnyWithProps\n              ? FunctionSpec.RegisteredFunction<Function>\n              : never;\n          }\n        >\n      : {\n          [FunctionName in FunctionSpec.Name<\n            GroupSpec.Functions<Group>\n          >]: FunctionSpec.WithName<\n            GroupSpec.Functions<Group>,\n            FunctionName\n          > extends infer Function extends FunctionSpec.AnyWithProps\n            ? FunctionSpec.RegisteredFunction<Function>\n            : never;\n        }\n    : never;\n};\n\nexport interface AnyWithProps {\n  readonly [key: string]: RegisteredFunction.RegisteredFunction | AnyWithProps;\n}\n\nexport const make = <Api_ extends Api.AnyWithProps>(\n  impl: Layer.Layer<Impl.Impl<Api_, \"Finalized\">>,\n  makeRegisteredFunction: (\n    api: Api_,\n    registryItem: RegistryItem.AnyWithProps,\n  ) => RegisteredFunction.RegisteredFunction,\n) =>\n  Effect.gen(function* () {\n    const registry = yield* Registry.Registry;\n    const functionImplItems = yield* Ref.get(registry);\n    const { api, finalizationStatus } = yield* Impl.Impl<Api_, \"Finalized\">();\n\n    return yield* Match.value(\n      finalizationStatus as Impl.FinalizationStatus,\n    ).pipe(\n      Match.withReturnType<Effect.Effect<RegisteredFunctions<Api_[\"spec\"]>>>(),\n      Match.when(\"Unfinalized\", () =>\n        Effect.dieMessage(\"Impl is not finalized\"),\n      ),\n      Match.when(\"Finalized\", () =>\n        Effect.succeed(\n          mapLeaves<\n            RegistryItem.AnyWithProps,\n            RegisteredFunction.RegisteredFunction\n          >(functionImplItems, RegistryItem.isRegistryItem, (registryItem) =>\n            makeRegisteredFunction(api, registryItem),\n          ) as RegisteredFunctions<Api_[\"spec\"]>,\n        ),\n      ),\n      Match.exhaustive,\n    );\n  }).pipe(Effect.provide(impl), Effect.runSync);\n"],"mappings":";;;;;;;;;AAmDA,MAAa,QACX,MACA,2BAKA,OAAO,IAAI,aAAa;CACtB,MAAM,WAAW,OAAOA;CACxB,MAAM,oBAAoB,OAAO,IAAI,IAAI,SAAS;CAClD,MAAM,EAAE,KAAK,uBAAuB,OAAOC,MAA8B;AAEzE,QAAO,OAAO,MAAM,MAClB,mBACD,CAAC,KACA,MAAM,gBAAkE,EACxE,MAAM,KAAK,qBACT,OAAO,WAAW,wBAAwB,CAC3C,EACD,MAAM,KAAK,mBACT,OAAO,QACL,UAGE,mBAAmBC,iBAA8B,iBACjD,uBAAuB,KAAK,aAAa,CAC1C,CACF,CACF,EACD,MAAM,WACP;EACD,CAAC,KAAK,OAAO,QAAQ,KAAK,EAAE,OAAO,QAAQ"}
+{"version":3,"file":"RegisteredFunctions.js","names":["Registry.Registry","Impl.Impl","RegistryItem.isRegistryItem"],"sources":["../src/RegisteredFunctions.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport type * as GroupSpec from \"@confect/core/GroupSpec\";\nimport type * as Spec from \"@confect/core/Spec\";\nimport type { Layer } from \"effect\";\nimport { Effect, Match, Ref, type Types } from \"effect\";\nimport type * as Api from \"./Api\";\nimport * as Impl from \"./Impl\";\nimport { mapLeaves } from \"./internal/utils\";\nimport type * as RegisteredFunction from \"./RegisteredFunction\";\nimport * as Registry from \"./Registry\";\nimport * as RegistryItem from \"./RegistryItem\";\n\nexport type RegisteredFunctions<Spec_ extends Spec.AnyWithProps> =\n  Types.Simplify<RegisteredFunctionsHelper<Spec.Groups<Spec_>>>;\n\ntype RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = {\n  [GroupName in GroupSpec.Name<Groups>]: GroupSpec.WithName<\n    Groups,\n    GroupName\n  > extends infer Group extends GroupSpec.AnyWithProps\n    ? GroupSpec.Groups<Group> extends infer SubGroups extends\n        GroupSpec.AnyWithProps\n      ? Types.Simplify<\n          RegisteredFunctionsHelper<SubGroups> & {\n            [FunctionName in FunctionSpec.Name<\n              GroupSpec.Functions<Group>\n            >]: FunctionSpec.WithName<\n              GroupSpec.Functions<Group>,\n              FunctionName\n            > extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps\n              ? RegisteredFunction.RegisteredFunction<FunctionSpec_>\n              : never;\n          }\n        >\n      : {\n          [FunctionName in FunctionSpec.Name<\n            GroupSpec.Functions<Group>\n          >]: FunctionSpec.WithName<\n            GroupSpec.Functions<Group>,\n            FunctionName\n          > extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps\n            ? RegisteredFunction.RegisteredFunction<FunctionSpec_>\n            : never;\n        }\n    : never;\n};\n\nexport interface AnyWithProps {\n  readonly [key: string]: RegisteredFunction.Any | AnyWithProps;\n}\n\nexport const make = <Api_ extends Api.AnyWithProps>(\n  impl: Layer.Layer<Impl.Impl<Api_, \"Finalized\">>,\n  makeRegisteredFunction: (\n    api: Api_,\n    registryItem: RegistryItem.AnyWithProps,\n  ) => RegisteredFunction.Any,\n) =>\n  Effect.gen(function* () {\n    const registry = yield* Registry.Registry;\n    const functionImplItems = yield* Ref.get(registry);\n    const { api, finalizationStatus } = yield* Impl.Impl<Api_, \"Finalized\">();\n\n    return yield* Match.value(\n      finalizationStatus as Impl.FinalizationStatus,\n    ).pipe(\n      Match.withReturnType<Effect.Effect<RegisteredFunctions<Api_[\"spec\"]>>>(),\n      Match.when(\"Unfinalized\", () =>\n        Effect.dieMessage(\"Impl is not finalized\"),\n      ),\n      Match.when(\"Finalized\", () =>\n        Effect.succeed(\n          mapLeaves<RegistryItem.AnyWithProps, RegisteredFunction.Any>(\n            functionImplItems,\n            RegistryItem.isRegistryItem,\n            (registryItem) => makeRegisteredFunction(api, registryItem),\n          ) as RegisteredFunctions<Api_[\"spec\"]>,\n        ),\n      ),\n      Match.exhaustive,\n    );\n  }).pipe(Effect.provide(impl), Effect.runSync);\n"],"mappings":";;;;;;;;;AAmDA,MAAa,QACX,MACA,2BAKA,OAAO,IAAI,aAAa;CACtB,MAAM,WAAW,OAAOA;CACxB,MAAM,oBAAoB,OAAO,IAAI,IAAI,SAAS;CAClD,MAAM,EAAE,KAAK,uBAAuB,OAAOC,MAA8B;AAEzE,QAAO,OAAO,MAAM,MAClB,mBACD,CAAC,KACA,MAAM,gBAAkE,EACxE,MAAM,KAAK,qBACT,OAAO,WAAW,wBAAwB,CAC3C,EACD,MAAM,KAAK,mBACT,OAAO,QACL,UACE,mBACAC,iBACC,iBAAiB,uBAAuB,KAAK,aAAa,CAC5D,CACF,CACF,EACD,MAAM,WACP;EACD,CAAC,KAAK,OAAO,QAAQ,KAAK,EAAE,OAAO,QAAQ"}

package/dist/RegisteredNodeFunction.d.ts

@@ -1,5 +1,5 @@
 import { AnyWithPropsWithRuntime } from "./Api.js";
-import { RegisteredFunction } from "./RegisteredFunction.js";
+import { Any } from "./RegisteredFunction.js";
 import { AnyWithProps } from "./RegistryItem.js";
 
 //#region src/RegisteredNodeFunction.d.ts
@@ -7,9 +7,9 @@ declare namespace RegisteredNodeFunction_d_exports {
   export { make };
 }
 declare const make: <Api_ extends AnyWithPropsWithRuntime<"Node">>(api: Api_, {
-  function_,
+  functionSpec,
   handler
-}: AnyWithProps) => RegisteredFunction;
+}: AnyWithProps) => Any;
 //#endregion
 export { RegisteredNodeFunction_d_exports, make };
 //# sourceMappingURL=RegisteredNodeFunction.d.ts.map

package/dist/RegisteredNodeFunction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredNodeFunction.d.ts","names":[],"sources":["../src/RegisteredNodeFunction.ts"],"mappings":";;;;;;;;cAaa,IAAA,gBAAqB,uBAAA,UAChC,GAAA,EAAK,IAAA;EACL,SAAA;EAAA;AAAA,GAAwB,YAAA,KACvB,kBAAA"}
+{"version":3,"file":"RegisteredNodeFunction.d.ts","names":[],"sources":["../src/RegisteredNodeFunction.ts"],"mappings":";;;;;;;;cAea,IAAA,gBAAqB,uBAAA,UAChC,GAAA,EAAK,IAAA;EACL,YAAA;EAAA;AAAA,GAA2B,YAAA,KAC1B,GAAA"}

package/dist/RegisteredNodeFunction.js

@@ -6,13 +6,14 @@ import { NodeContext } from "@effect/platform-node";
 
 //#region src/RegisteredNodeFunction.ts
 var RegisteredNodeFunction_exports = /* @__PURE__ */ __exportAll({ make: () => make });
-const make = (api, { function_, handler }) => {
-	return Match.value(function_.functionVisibility).pipe(Match.when("public", () => actionGeneric), Match.when("internal", () => internalActionGeneric), Match.exhaustive)(nodeActionFunction(api.databaseSchema, {
-		args: function_.args,
-		returns: function_.returns,
+const make = (api, { functionSpec, handler }) => Match.value(functionSpec.functionProvenance).pipe(Match.tag("Convex", () => handler), Match.tag("Confect", () => {
+	const { functionVisibility, functionProvenance } = functionSpec;
+	return Match.value(functionVisibility).pipe(Match.when("public", () => actionGeneric), Match.when("internal", () => internalActionGeneric), Match.exhaustive)(nodeActionFunction(api.databaseSchema, {
+		args: functionProvenance.args,
+		returns: functionProvenance.returns,
 		handler
 	}));
-};
+}), Match.exhaustive);
 const nodeActionFunction = (databaseSchema, { args, returns, handler }) => actionFunctionBase({
 	args,
 	returns,

package/dist/RegisteredNodeFunction.js.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredNodeFunction.js","names":["RegisteredFunction.actionFunctionBase","RegisteredFunction.actionLayer"],"sources":["../src/RegisteredNodeFunction.ts"],"sourcesContent":["import { NodeContext } from \"@effect/platform-node\";\nimport {\n  actionGeneric,\n  type DefaultFunctionArgs,\n  internalActionGeneric,\n} from \"convex/server\";\nimport type { Effect } from \"effect\";\nimport { Layer, Match, type Schema } from \"effect\";\nimport type * as Api from \"./Api\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport * as RegisteredFunction from \"./RegisteredFunction\";\nimport type * as RegistryItem from \"./RegistryItem\";\n\nexport const make = <Api_ extends Api.AnyWithPropsWithRuntime<\"Node\">>(\n  api: Api_,\n  { function_, handler }: RegistryItem.AnyWithProps,\n): RegisteredFunction.RegisteredFunction => {\n  const genericFunction = Match.value(function_.functionVisibility).pipe(\n    Match.when(\"public\", () => actionGeneric),\n    Match.when(\"internal\", () => internalActionGeneric),\n    Match.exhaustive,\n  );\n\n  return genericFunction(\n    nodeActionFunction(api.databaseSchema, {\n      args: function_.args,\n      returns: function_.returns,\n      handler,\n    }),\n  );\n};\n\nconst nodeActionFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>(\n  databaseSchema: DatabaseSchema_,\n  {\n    args,\n    returns,\n    handler,\n  }: {\n    args: Schema.Schema<Args, ConvexArgs>;\n    returns: Schema.Schema<Returns, ConvexReturns>;\n    handler: (\n      a: Args,\n    ) => Effect.Effect<\n      Returns,\n      E,\n      | RegisteredFunction.ActionServices<DatabaseSchema_>\n      | NodeContext.NodeContext\n    >;\n  },\n) =>\n  RegisteredFunction.actionFunctionBase({\n    args,\n    returns,\n    handler,\n    createLayer: (ctx) =>\n      Layer.mergeAll(\n        RegisteredFunction.actionLayer(databaseSchema, ctx),\n        NodeContext.layer,\n      ),\n  });\n"],"mappings":";;;;;;;;AAaA,MAAa,QACX,KACA,EAAE,WAAW,cAC6B;AAO1C,QANwB,MAAM,MAAM,UAAU,mBAAmB,CAAC,KAChE,MAAM,KAAK,gBAAgB,cAAc,EACzC,MAAM,KAAK,kBAAkB,sBAAsB,EACnD,MAAM,WACP,CAGC,mBAAmB,IAAI,gBAAgB;EACrC,MAAM,UAAU;EAChB,SAAS,UAAU;EACnB;EACD,CAAC,CACH;;AAGH,MAAM,sBAQJ,gBACA,EACE,MACA,SACA,cAcFA,mBAAsC;CACpC;CACA;CACA;CACA,cAAc,QACZ,MAAM,SACJC,YAA+B,gBAAgB,IAAI,EACnD,YAAY,MACb;CACJ,CAAC"}
+{"version":3,"file":"RegisteredNodeFunction.js","names":["RegisteredFunction.actionFunctionBase","RegisteredFunction.actionLayer"],"sources":["../src/RegisteredNodeFunction.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport { NodeContext } from \"@effect/platform-node\";\nimport {\n  actionGeneric,\n  type DefaultFunctionArgs,\n  internalActionGeneric,\n} from \"convex/server\";\nimport type { Effect } from \"effect\";\nimport { Layer, Match, type Schema } from \"effect\";\nimport type * as Api from \"./Api\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as Handler from \"./Handler\";\nimport * as RegisteredFunction from \"./RegisteredFunction\";\nimport type * as RegistryItem from \"./RegistryItem\";\n\nexport const make = <Api_ extends Api.AnyWithPropsWithRuntime<\"Node\">>(\n  api: Api_,\n  { functionSpec, handler }: RegistryItem.AnyWithProps,\n): RegisteredFunction.Any =>\n  Match.value(functionSpec.functionProvenance).pipe(\n    Match.tag(\"Convex\", () => handler as RegisteredFunction.Any),\n    Match.tag(\"Confect\", () => {\n      const { functionVisibility, functionProvenance } =\n        functionSpec as FunctionSpec.AnyConfect;\n\n      const genericFunction = Match.value(functionVisibility).pipe(\n        Match.when(\"public\", () => actionGeneric),\n        Match.when(\"internal\", () => internalActionGeneric),\n        Match.exhaustive,\n      );\n\n      return genericFunction(\n        nodeActionFunction(api.databaseSchema, {\n          args: functionProvenance.args,\n          returns: functionProvenance.returns,\n          handler: handler as Handler.AnyConfectProvenance,\n        }),\n      );\n    }),\n    Match.exhaustive,\n  );\n\nconst nodeActionFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>(\n  databaseSchema: DatabaseSchema_,\n  {\n    args,\n    returns,\n    handler,\n  }: {\n    args: Schema.Schema<Args, ConvexArgs>;\n    returns: Schema.Schema<Returns, ConvexReturns>;\n    handler: (\n      a: Args,\n    ) => Effect.Effect<\n      Returns,\n      E,\n      | RegisteredFunction.ActionServices<DatabaseSchema_>\n      | NodeContext.NodeContext\n    >;\n  },\n) =>\n  RegisteredFunction.actionFunctionBase({\n    args,\n    returns,\n    handler,\n    createLayer: (ctx) =>\n      Layer.mergeAll(\n        RegisteredFunction.actionLayer(databaseSchema, ctx),\n        NodeContext.layer,\n      ),\n  });\n"],"mappings":";;;;;;;;AAeA,MAAa,QACX,KACA,EAAE,cAAc,cAEhB,MAAM,MAAM,aAAa,mBAAmB,CAAC,KAC3C,MAAM,IAAI,gBAAgB,QAAkC,EAC5D,MAAM,IAAI,iBAAiB;CACzB,MAAM,EAAE,oBAAoB,uBAC1B;AAQF,QANwB,MAAM,MAAM,mBAAmB,CAAC,KACtD,MAAM,KAAK,gBAAgB,cAAc,EACzC,MAAM,KAAK,kBAAkB,sBAAsB,EACnD,MAAM,WACP,CAGC,mBAAmB,IAAI,gBAAgB;EACrC,MAAM,mBAAmB;EACzB,SAAS,mBAAmB;EACnB;EACV,CAAC,CACH;EACD,EACF,MAAM,WACP;AAEH,MAAM,sBAQJ,gBACA,EACE,MACA,SACA,cAcFA,mBAAsC;CACpC;CACA;CACA;CACA,cAAc,QACZ,MAAM,SACJC,YAA+B,gBAAgB,IAAI,EACnD,YAAY,MACb;CACJ,CAAC"}

package/dist/RegistryItem.d.ts

@@ -1,5 +1,5 @@
 import { AnyWithProps as AnyWithProps$1 } from "./DatabaseSchema.js";
-import { AnyWithProps as AnyWithProps$2, Handler } from "./Handler.js";
+import { Any, Handler } from "./Handler.js";
 import * as FunctionSpec from "@confect/core/FunctionSpec";
 
 //#region src/RegistryItem.d.ts
@@ -11,21 +11,21 @@ type TypeId = typeof TypeId;
 declare const isRegistryItem: (value: unknown) => value is AnyWithProps;
 interface RegistryItem<DatabaseSchema_ extends AnyWithProps$1, FunctionSpec_ extends FunctionSpec.AnyWithProps> {
   readonly [TypeId]: TypeId;
-  readonly function_: FunctionSpec_;
+  readonly functionSpec: FunctionSpec_;
   readonly handler: Handler<DatabaseSchema_, FunctionSpec_>;
 }
 interface AnyWithProps {
   readonly [TypeId]: TypeId;
-  readonly function_: FunctionSpec.AnyWithProps;
-  readonly handler: AnyWithProps$2;
+  readonly functionSpec: FunctionSpec.AnyWithProps;
+  readonly handler: Any;
 }
-declare const make: <DatabaseSchema_ extends AnyWithProps$1, FunctionSpec_ extends FunctionSpec.AnyWithProps>({
-  function_,
+declare const make: ({
+  functionSpec,
   handler
 }: {
-  function_: FunctionSpec_;
-  handler: Handler<DatabaseSchema_, FunctionSpec_>;
-}) => RegistryItem<DatabaseSchema_, FunctionSpec_>;
+  functionSpec: FunctionSpec.AnyWithProps;
+  handler: AnyWithProps["handler"];
+}) => AnyWithProps;
 //#endregion
 export { AnyWithProps, RegistryItem, RegistryItem_d_exports, TypeId, isRegistryItem, make };
 //# sourceMappingURL=RegistryItem.d.ts.map

package/dist/RegistryItem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RegistryItem.d.ts","names":[],"sources":["../src/RegistryItem.ts"],"mappings":";;;;;;;;cAKa,MAAA;AAAA,KACD,MAAA,UAAgB,MAAA;AAAA,cAEf,cAAA,GAAkB,KAAA,cAAiB,KAAA,IAAS,YAAA;AAAA,UAOxC,YAAA,yBACS,cAAA,wBACF,YAAA,CAAa,YAAA;EAAA,UAEzB,MAAA,GAAS,MAAA;EAAA,SACV,SAAA,EAAW,aAAA;EAAA,SACX,OAAA,EAAS,OAAA,CAAgB,eAAA,EAAiB,aAAA;AAAA;AAAA,UAGpC,YAAA;EAAA,UACL,MAAA,GAAS,MAAA;EAAA,SACV,SAAA,EAAW,YAAA,CAAa,YAAA;EAAA,SACxB,OAAA,EAAS,cAAA;AAAA;AAAA,cAGP,IAAA,2BACa,cAAA,wBACF,YAAA,CAAa,YAAA;EACnC,SAAA;EAAA;AAAA;EAIA,SAAA,EAAW,aAAA;EACX,OAAA,EAAS,OAAA,CAAgB,eAAA,EAAiB,aAAA;AAAA,MACxC,YAAA,CAAa,eAAA,EAAiB,aAAA"}
+{"version":3,"file":"RegistryItem.d.ts","names":[],"sources":["../src/RegistryItem.ts"],"mappings":";;;;;;;;cAKa,MAAA;AAAA,KACD,MAAA,UAAgB,MAAA;AAAA,cAEf,cAAA,GAAkB,KAAA,cAAiB,KAAA,IAAS,YAAA;AAAA,UAOxC,YAAA,yBACS,cAAA,wBACF,YAAA,CAAa,YAAA;EAAA,UAEzB,MAAA,GAAS,MAAA;EAAA,SACV,YAAA,EAAc,aAAA;EAAA,SACd,OAAA,EAAS,OAAA,CAAgB,eAAA,EAAiB,aAAA;AAAA;AAAA,UAGpC,YAAA;EAAA,UACL,MAAA,GAAS,MAAA;EAAA,SACV,YAAA,EAAc,YAAA,CAAa,YAAA;EAAA,SAC3B,OAAA,EAAS,GAAA;AAAA;AAAA,cAGP,IAAA;EAAQ,YAAA;EAAA;AAAA;EAInB,YAAA,EAAc,YAAA,CAAa,YAAA;EAC3B,OAAA,EAAS,YAAA;AAAA,MACP,YAAA"}

package/dist/RegistryItem.js

@@ -10,8 +10,8 @@ var RegistryItem_exports = /* @__PURE__ */ __exportAll({
 const TypeId = "@confect/server/RegistryItem";
 const isRegistryItem = (value) => Predicate.hasProperty(value, TypeId);
 const RegistryItemProto = { [TypeId]: TypeId };
-const make = ({ function_, handler }) => Object.assign(Object.create(RegistryItemProto), {
-	function_,
+const make = ({ functionSpec, handler }) => Object.assign(Object.create(RegistryItemProto), {
+	functionSpec,
 	handler
 });
 

package/dist/RegistryItem.js.map

@@ -1 +1 @@
-{"version":3,"file":"RegistryItem.js","names":[],"sources":["../src/RegistryItem.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport { Predicate } from \"effect\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as Handler from \"./Handler\";\n\nexport const TypeId = \"@confect/server/RegistryItem\";\nexport type TypeId = typeof TypeId;\n\nexport const isRegistryItem = (value: unknown): value is AnyWithProps =>\n  Predicate.hasProperty(value, TypeId);\n\nconst RegistryItemProto = {\n  [TypeId]: TypeId,\n};\n\nexport interface RegistryItem<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n> {\n  readonly [TypeId]: TypeId;\n  readonly function_: FunctionSpec_;\n  readonly handler: Handler.Handler<DatabaseSchema_, FunctionSpec_>;\n}\n\nexport interface AnyWithProps {\n  readonly [TypeId]: TypeId;\n  readonly function_: FunctionSpec.AnyWithProps;\n  readonly handler: Handler.AnyWithProps;\n}\n\nexport const make = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n>({\n  function_,\n  handler,\n}: {\n  function_: FunctionSpec_;\n  handler: Handler.Handler<DatabaseSchema_, FunctionSpec_>;\n}): RegistryItem<DatabaseSchema_, FunctionSpec_> =>\n  Object.assign(Object.create(RegistryItemProto), {\n    function_,\n    handler,\n  });\n"],"mappings":";;;;;;;;;AAKA,MAAa,SAAS;AAGtB,MAAa,kBAAkB,UAC7B,UAAU,YAAY,OAAO,OAAO;AAEtC,MAAM,oBAAoB,GACvB,SAAS,QACX;AAiBD,MAAa,QAGX,EACA,WACA,cAKA,OAAO,OAAO,OAAO,OAAO,kBAAkB,EAAE;CAC9C;CACA;CACD,CAAC"}
+{"version":3,"file":"RegistryItem.js","names":[],"sources":["../src/RegistryItem.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport { Predicate } from \"effect\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as Handler from \"./Handler\";\n\nexport const TypeId = \"@confect/server/RegistryItem\";\nexport type TypeId = typeof TypeId;\n\nexport const isRegistryItem = (value: unknown): value is AnyWithProps =>\n  Predicate.hasProperty(value, TypeId);\n\nconst RegistryItemProto = {\n  [TypeId]: TypeId,\n};\n\nexport interface RegistryItem<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n> {\n  readonly [TypeId]: TypeId;\n  readonly functionSpec: FunctionSpec_;\n  readonly handler: Handler.Handler<DatabaseSchema_, FunctionSpec_>;\n}\n\nexport interface AnyWithProps {\n  readonly [TypeId]: TypeId;\n  readonly functionSpec: FunctionSpec.AnyWithProps;\n  readonly handler: Handler.Any;\n}\n\nexport const make = ({\n  functionSpec,\n  handler,\n}: {\n  functionSpec: FunctionSpec.AnyWithProps;\n  handler: AnyWithProps[\"handler\"];\n}): AnyWithProps =>\n  Object.assign(Object.create(RegistryItemProto), {\n    functionSpec,\n    handler,\n  });\n"],"mappings":";;;;;;;;;AAKA,MAAa,SAAS;AAGtB,MAAa,kBAAkB,UAC7B,UAAU,YAAY,OAAO,OAAO;AAEtC,MAAM,oBAAoB,GACvB,SAAS,QACX;AAiBD,MAAa,QAAQ,EACnB,cACA,cAKA,OAAO,OAAO,OAAO,OAAO,kBAAkB,EAAE;CAC9C;CACA;CACD,CAAC"}

package/dist/StorageActionWriter.d.ts

@@ -0,0 +1,35 @@
+import { BlobNotFoundError } from "./BlobNotFoundError.js";
+import { Effect, Layer } from "effect";
+import { StorageActionWriter as StorageActionWriter$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/StorageActionWriter.d.ts
+declare namespace StorageActionWriter_d_exports {
+  export { StorageActionWriter };
+}
+declare const StorageActionWriter_base: effect_Context0.TagClass<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>;
+}> & 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>;
+}
+//#endregion
+export { StorageActionWriter, StorageActionWriter_d_exports };
+//# sourceMappingURL=StorageActionWriter.d.ts.map

package/dist/StorageActionWriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StorageActionWriter.d.ts","names":[],"sources":["../src/StorageActionWriter.ts"],"mappings":";;;;;;;;;;;cAGwD,wBAAA,EAeL,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;;cAItC,mBAAA,SAA4B,wBAAA;EAAA,gBAGvB,KAAA,GAAS,mBAAA,EAAqB,qBAAA,KAAyB,KAAA,CAAA,KAAA,CAAA,mBAAA;AAAA"}

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,16 +21,18 @@ 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";
 import { FunctionImpl_d_exports } from "./FunctionImpl.js";
 import { GroupImpl_d_exports } from "./GroupImpl.js";
 import { HttpApi_d_exports } from "./HttpApi.js";
 import { Impl_d_exports } from "./Impl.js";
-import { RegisteredFunction_d_exports } from "./RegisteredFunction.js";
 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": "2.0.0",
+  "version": "4.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": "2.0.0",
-    "@confect/test": "2.0.0"
+    "@confect/cli": "4.0.0",
+    "@confect/test": "4.0.0"
   },
   "peerDependencies": {
     "@effect/platform": "^0.94.5",
     "@effect/platform-node": "^0.104.1",
     "convex": "^1.30.0",
     "effect": "^3.19.16",
-    "@confect/core": "2.0.0"
+    "@confect/core": "4.0.0"
   },
   "engines": {
     "node": ">=22",

package/src/ActionRunner.ts

@@ -1,29 +1,43 @@
 import * as Ref from "@confect/core/Ref";
 import { type GenericActionCtx } from "convex/server";
 import type { ParseResult } from "effect";
-import { Context, Effect, Layer, Schema } from "effect";
+import { Context, Effect, Layer, Match, Schema } from "effect";
 
-const makeActionRunner =
+const make =
   (runAction: GenericActionCtx<any>["runAction"]) =>
   <Action extends Ref.AnyAction>(
     action: Action,
-    args: Ref.Args<Action>["Type"],
-  ): Effect.Effect<Ref.Returns<Action>["Type"], ParseResult.ParseError> =>
+    args: Ref.Args<Action>,
+  ): Effect.Effect<Ref.Returns<Action>, ParseResult.ParseError> =>
     Effect.gen(function* () {
-      const function_ = Ref.getFunction(action);
+      const functionSpec = Ref.getFunctionSpec(action);
       const functionName = Ref.getConvexFunctionName(action);
 
-      const encodedArgs = yield* Schema.encode(function_.args)(args);
-      const encodedReturns = yield* Effect.promise(() =>
-        runAction(functionName as any, encodedArgs),
+      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,
       );
-      return yield* Schema.decode(function_.returns)(encodedReturns);
     });
 
-export const ActionRunner = Context.GenericTag<
-  ReturnType<typeof makeActionRunner>
->("@confect/server/ActionRunner");
+export const ActionRunner = Context.GenericTag<ReturnType<typeof make>>(
+  "@confect/server/ActionRunner",
+);
 export type ActionRunner = typeof ActionRunner.Identifier;
 
 export const layer = (runAction: GenericActionCtx<any>["runAction"]) =>
-  Layer.succeed(ActionRunner, makeActionRunner(runAction));
+  Layer.succeed(ActionRunner, make(runAction));

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] ?? {});