@confect/server 8.0.0 → 9.0.0-next.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 { GroupImpl } from "./GroupImpl.js";
 import { AnyWithProps as AnyWithProps$2 } from "./RegistryItem.js";
 import { Layer, Types } from "effect";
 import * as Spec from "@confect/core/Spec";
@@ -9,14 +9,25 @@ import * as GroupSpec from "@confect/core/GroupSpec";
 
 //#region src/RegisteredFunctions.d.ts
 declare namespace RegisteredFunctions_d_exports {
-  export { AnyWithProps, RegisteredFunctions, make };
+  export { AnyWithProps, ForGroupPath, RegisteredFunctions, buildForGroup };
 }
 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 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]: Any | AnyWithProps;
 }
-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"]>>>;
+type RegisteredFunctionsAtPath<Tree, Path extends string> = Path extends `${infer Head}.${infer Tail}` ? Head extends keyof Tree ? Tree[Head] extends AnyWithProps ? RegisteredFunctionsAtPath<Tree[Head], Tail> : never : never : Path extends keyof Tree ? Tree[Path] : never;
+type ForGroupPath<Spec_ extends Spec.AnyWithProps, Path extends string> = RegisteredFunctionsAtPath<RegisteredFunctions<Spec_>, Path>;
+/**
+ * Build the registered Convex functions for a single group from its finalized
+ * `GroupImpl` layer.
+ *
+ * The `groupLayer` parameter requires `GroupImpl<string, "Finalized">`, so
+ * impls that were never piped through `GroupImpl.finalize` (and impls with
+ * unmet `FunctionImpl` requirements, which cannot be finalized) are rejected
+ * at the codegen boundary, not just deep inside Convex at runtime.
+ */
+declare const buildForGroup: <Api_ extends AnyWithProps$1, const GroupPath_ extends string>(api: Api_, groupPath: GroupPath_, groupLayer: Layer.Layer<GroupImpl<string, "Finalized">>, makeRegisteredFunction: (api: Api_, registryItem: AnyWithProps$2) => Any) => ForGroupPath<Api_["spec"], GroupPath_>;
 //#endregion
-export { AnyWithProps, RegisteredFunctions, RegisteredFunctions_d_exports, make };
+export { AnyWithProps, ForGroupPath, RegisteredFunctions, RegisteredFunctions_d_exports, buildForGroup };
 //# 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,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"}
+{"version":3,"file":"RegisteredFunctions.d.ts","names":[],"sources":["../src/RegisteredFunctions.ts"],"mappings":";;;;;;;;;;;;;KAqBY,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,KAG9C,yBAAA,8BAGD,IAAA,yCACA,IAAA,eAAmB,IAAA,GACjB,IAAA,CAAK,IAAA,UAAc,YAAA,GACjB,yBAAA,CAA0B,IAAA,CAAK,IAAA,GAAO,IAAA,oBAG1C,IAAA,eAAmB,IAAA,GACjB,IAAA,CAAK,IAAA;AAAA,KAGC,YAAA,eACI,IAAA,CAAK,YAAA,yBAEjB,yBAAA,CAA0B,mBAAA,CAAoB,KAAA,GAAQ,IAAA;;;;;;;;;;cAW7C,aAAA,gBACE,cAAA,mCAGb,GAAA,EAAK,IAAA,EACL,SAAA,EAAW,UAAA,EACX,UAAA,EAAY,KAAA,CAAM,KAAA,CAAM,SAAA,wBACxB,sBAAA,GACE,GAAA,EAAK,IAAA,EACL,YAAA,EAAc,cAAA,KACX,GAAA,KACJ,YAAA,CAAa,IAAA,UAAc,UAAA"}

package/dist/RegisteredFunctions.js

@@ -1,19 +1,28 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
 import { mapLeaves } from "./internal/utils.js";
-import { Registry } from "./Registry.js";
 import { isRegistryItem } from "./RegistryItem.js";
-import { Impl } from "./Impl.js";
-import { Effect, Match, Ref } from "effect";
+import { Array, Effect, Option, Predicate, Ref, String, pipe } from "effect";
+import * as Registry from "@confect/core/Registry";
 
 //#region src/RegisteredFunctions.ts
-var RegisteredFunctions_exports = /* @__PURE__ */ __exportAll({ make: () => make });
-const make = (impl, makeRegisteredFunction) => Effect.gen(function* () {
-	const registry = yield* Registry;
-	const functionImplItems = yield* Ref.get(registry);
-	const { api, finalizationStatus } = yield* Impl();
-	return yield* Match.value(finalizationStatus).pipe(Match.withReturnType(), Match.when("Unfinalized", () => Effect.dieMessage("Impl is not finalized")), Match.when("Finalized", () => Effect.succeed(mapLeaves(functionImplItems, isRegistryItem, (registryItem) => makeRegisteredFunction(api, registryItem)))), Match.exhaustive);
-}).pipe(Effect.provide(impl), Effect.runSync);
+var RegisteredFunctions_exports = /* @__PURE__ */ __exportAll({ buildForGroup: () => buildForGroup });
+/**
+* Build the registered Convex functions for a single group from its finalized
+* `GroupImpl` layer.
+*
+* The `groupLayer` parameter requires `GroupImpl<string, "Finalized">`, so
+* impls that were never piped through `GroupImpl.finalize` (and impls with
+* unmet `FunctionImpl` requirements, which cannot be finalized) are rejected
+* at the codegen boundary, not just deep inside Convex at runtime.
+*/
+const buildForGroup = (api, groupPath, groupLayer, makeRegisteredFunction) => {
+	const registeredFunctions = mapLeaves(Effect.gen(function* () {
+		const registry = yield* Registry.Registry;
+		return yield* Ref.get(registry);
+	}).pipe(Effect.provide(groupLayer), Effect.runSync), isRegistryItem, (registryItem) => makeRegisteredFunction(api, registryItem));
+	return pipe(String.split(groupPath, "."), Array.reduce(Option.some(registeredFunctions), (currentNode, segment) => currentNode.pipe(Option.filter(Predicate.isRecord), Option.flatMap((nodeRecord) => segment in nodeRecord ? Option.some(nodeRecord[segment]) : Option.none()))), Option.getOrThrowWith(() => /* @__PURE__ */ new Error(`No functions registered for group path "${groupPath}"`)));
+};
 
 //#endregion
-export { RegisteredFunctions_exports, make };
+export { RegisteredFunctions_exports, buildForGroup };
 //# sourceMappingURL=RegisteredFunctions.js.map

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 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"}
+{"version":3,"file":"RegisteredFunctions.js","names":["RegistryItem.isRegistryItem"],"sources":["../src/RegisteredFunctions.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport type * as GroupSpec from \"@confect/core/GroupSpec\";\nimport * as Registry from \"@confect/core/Registry\";\nimport type * as Spec from \"@confect/core/Spec\";\nimport {\n  Array,\n  Effect,\n  type Layer,\n  Option,\n  pipe,\n  Predicate,\n  Ref,\n  String,\n  type Types,\n} from \"effect\";\nimport type * as Api from \"./Api\";\nimport type * as GroupImpl from \"./GroupImpl\";\nimport { mapLeaves } from \"./internal/utils\";\nimport type * as RegisteredFunction from \"./RegisteredFunction\";\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\ntype RegisteredFunctionsAtPath<\n  Tree,\n  Path extends string,\n> = Path extends `${infer Head}.${infer Tail}`\n  ? Head extends keyof Tree\n    ? Tree[Head] extends AnyWithProps\n      ? RegisteredFunctionsAtPath<Tree[Head], Tail>\n      : never\n    : never\n  : Path extends keyof Tree\n    ? Tree[Path]\n    : never;\n\nexport type ForGroupPath<\n  Spec_ extends Spec.AnyWithProps,\n  Path extends string,\n> = RegisteredFunctionsAtPath<RegisteredFunctions<Spec_>, Path>;\n\n/**\n * Build the registered Convex functions for a single group from its finalized\n * `GroupImpl` layer.\n *\n * The `groupLayer` parameter requires `GroupImpl<string, \"Finalized\">`, so\n * impls that were never piped through `GroupImpl.finalize` (and impls with\n * unmet `FunctionImpl` requirements, which cannot be finalized) are rejected\n * at the codegen boundary, not just deep inside Convex at runtime.\n */\nexport const buildForGroup = <\n  Api_ extends Api.AnyWithProps,\n  const GroupPath_ extends string,\n>(\n  api: Api_,\n  groupPath: GroupPath_,\n  groupLayer: Layer.Layer<GroupImpl.GroupImpl<string, \"Finalized\">>,\n  makeRegisteredFunction: (\n    api: Api_,\n    registryItem: RegistryItem.AnyWithProps,\n  ) => RegisteredFunction.Any,\n): ForGroupPath<Api_[\"spec\"], GroupPath_> => {\n  const registryItems = Effect.gen(function* () {\n    const registry = yield* Registry.Registry;\n    return yield* Ref.get(registry);\n  }).pipe(Effect.provide(groupLayer), Effect.runSync);\n\n  const registeredFunctions = mapLeaves<\n    RegistryItem.AnyWithProps,\n    RegisteredFunction.Any\n  >(\n    registryItems as { [key: string]: RegistryItem.AnyWithProps },\n    RegistryItem.isRegistryItem,\n    (registryItem) => makeRegisteredFunction(api, registryItem),\n  );\n\n  return pipe(\n    String.split(groupPath, \".\"),\n    Array.reduce(\n      Option.some<unknown>(registeredFunctions),\n      (currentNode, segment) =>\n        currentNode.pipe(\n          Option.filter(Predicate.isRecord),\n          Option.flatMap((nodeRecord) =>\n            segment in nodeRecord\n              ? Option.some(nodeRecord[segment])\n              : Option.none(),\n          ),\n        ),\n    ),\n    Option.getOrThrowWith(\n      () => new Error(`No functions registered for group path \"${groupPath}\"`),\n    ),\n  ) as ForGroupPath<Api_[\"spec\"], GroupPath_>;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;AAuFA,MAAa,iBAIX,KACA,WACA,YACA,2BAI2C;CAM3C,MAAM,sBAAsB,UALN,OAAO,IAAI,aAAa;EAC5C,MAAM,WAAW,OAAO,SAAS;AACjC,SAAO,OAAO,IAAI,IAAI,SAAS;GAC/B,CAAC,KAAK,OAAO,QAAQ,WAAW,EAAE,OAAO,QAAQ,EAOjDA,iBACC,iBAAiB,uBAAuB,KAAK,aAAa,CAC5D;AAED,QAAO,KACL,OAAO,MAAM,WAAW,IAAI,EAC5B,MAAM,OACJ,OAAO,KAAc,oBAAoB,GACxC,aAAa,YACZ,YAAY,KACV,OAAO,OAAO,UAAU,SAAS,EACjC,OAAO,SAAS,eACd,WAAW,aACP,OAAO,KAAK,WAAW,SAAS,GAChC,OAAO,MAAM,CAClB,CACF,CACJ,EACD,OAAO,qCACC,IAAI,MAAM,2CAA2C,UAAU,GAAG,CACzE,CACF"}

package/dist/StorageActionWriter.d.ts

@@ -25,7 +25,7 @@ declare const StorageActionWriter_base: effect_Context0.TagClass<StorageActionWr
     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, StorageActionWriter | R> : [X] extends [PromiseLike<infer A_1>] ? Effect.Effect<A_1, effect_Cause0.UnknownException, StorageActionWriter> : Effect.Effect<X, never, StorageActionWriter>;
+  }) => 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>;

package/dist/index.d.ts

@@ -30,9 +30,7 @@ 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 { 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, 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 };
+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, 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, 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

@@ -15,7 +15,6 @@ import { OrderedQuery_exports } from "./OrderedQuery.js";
 import { QueryInitializer_exports } from "./QueryInitializer.js";
 import { DatabaseReader_exports } from "./DatabaseReader.js";
 import { DatabaseWriter_exports } from "./DatabaseWriter.js";
-import { Registry_exports } from "./Registry.js";
 import { RegistryItem_exports } from "./RegistryItem.js";
 import { FunctionImpl_exports } from "./FunctionImpl.js";
 import { GroupImpl_exports } from "./GroupImpl.js";
@@ -27,7 +26,6 @@ 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";
 import { QueryCtx_exports } from "./QueryCtx.js";
 import { VectorSearch_exports } from "./VectorSearch.js";
@@ -36,4 +34,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, 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 };
+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, 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, 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": "8.0.0",
+  "version": "9.0.0-next.0",
   "description": "Backend bindings to the Convex platform",
   "repository": {
     "type": "git",
@@ -66,16 +66,14 @@
     "typescript-eslint": "8.56.1",
     "vite": "7.3.1",
     "vite-tsconfig-paths": "6.1.1",
-    "vitest": "3.2.4",
-    "@confect/cli": "8.0.0",
-    "@confect/test": "8.0.0"
+    "vitest": "3.2.4"
   },
   "peerDependencies": {
     "@effect/platform": "^0.96.1",
     "@effect/platform-node": "^0.106.0",
-    "convex": "^1.30.0",
+    "convex": "1.39.1",
     "effect": "^3.21.2",
-    "@confect/core": "^8.0.0"
+    "@confect/core": "^9.0.0-next.0"
   },
   "engines": {
     "node": ">=22",

package/src/DatabaseSchema.ts

@@ -3,15 +3,18 @@ import {
   defineSchema as defineConvexSchema,
   type SchemaDefinition,
 } from "convex/server";
-import { Array, pipe, Record } from "effect";
+import { Array, pipe, Predicate, Record } from "effect";
 import * as Table from "./Table";
-import { TypeId } from "@confect/core/DatabaseSchema";
 
-export {
-  type Any,
-  isDatabaseSchema,
-  TypeId,
-} from "@confect/core/DatabaseSchema";
+export const TypeId = "@confect/server/DatabaseSchema";
+export type TypeId = typeof TypeId;
+
+export interface Any {
+  readonly [TypeId]: TypeId;
+}
+
+export const isDatabaseSchema = (u: unknown): u is Any =>
+  Predicate.hasProperty(u, TypeId);
 
 /**
  * A schema definition tracks the schema and its Convex schema definition.

package/src/FunctionImpl.ts

@@ -1,11 +1,11 @@
 import type * as FunctionSpec from "@confect/core/FunctionSpec";
-import type * as GroupPath from "@confect/core/GroupPath";
 import type * as GroupSpec from "@confect/core/GroupSpec";
-import { Array, Context, Effect, Layer, Ref, String } from "effect";
+import * as Registry from "@confect/core/Registry";
+import { Context, Effect, Layer, Ref, String } from "effect";
 import type * as Api from "./Api";
+import { resolveGroupPathUnsafe } from "./GroupPath";
 import type * as Handler from "./Handler";
 import { setNestedProperty } from "./internal/utils";
-import * as Registry from "./Registry";
 import * as RegistryItem from "./RegistryItem";
 
 export interface FunctionImpl<
@@ -32,34 +32,23 @@ export const FunctionImpl = <
 
 export const make = <
   Api_ extends Api.AnyWithProps,
-  const GroupPath_ extends GroupPath.All<Api.Groups<Api_>>,
-  const FunctionName extends FunctionSpec.Name<
-    GroupSpec.Functions<GroupPath.GroupAt<Api.Groups<Api_>, GroupPath_>>
-  >,
+  Group extends GroupSpec.AnyWithProps,
+  const FunctionName extends FunctionSpec.Name<GroupSpec.Functions<Group>>,
 >(
   api: Api_,
-  groupPath: GroupPath_,
+  group: Group,
   functionName: FunctionName,
   handler: Handler.WithName<
     Api.Schema<Api_>,
-    GroupSpec.Functions<GroupPath.GroupAt<Api.Groups<Api_>, GroupPath_>>,
+    GroupSpec.Functions<Group>,
     FunctionName
   >,
-): Layer.Layer<FunctionImpl<GroupPath_, FunctionName>> => {
-  const groupPathParts = String.split(groupPath, ".");
-  const [firstGroupPathPart, ...restGroupPathParts] = groupPathParts;
-
-  const group_: GroupSpec.AnyWithProps = Array.reduce(
-    restGroupPathParts,
-    (api as any).spec.groups[firstGroupPathPart as any]!,
-    (currentGroup: any, groupPathPart: any) =>
-      currentGroup.groups[groupPathPart],
-  );
-
-  const functionSpec = group_.functions[functionName]!;
+): Layer.Layer<FunctionImpl<string, FunctionName>> => {
+  const groupPath = resolveGroupPathUnsafe(api.spec, group);
+  const functionSpec = group.functions[functionName]!;
 
   return Layer.effect(
-    FunctionImpl<GroupPath_, FunctionName>({
+    FunctionImpl<string, FunctionName>({
       groupPath,
       functionName,
     }),
@@ -69,7 +58,7 @@ export const make = <
       yield* Ref.update(registry, (registryItems) =>
         setNestedProperty(
           registryItems,
-          [...groupPathParts, functionName],
+          [...String.split(groupPath, "."), functionName],
           RegistryItem.make({
             functionSpec,
             handler,
@@ -94,19 +83,21 @@ export type ForGroupPathAndFunction<
 > = FunctionImpl<GroupPath_, FunctionName>;
 
 /**
- * Get all function implementation services required for a group at a given path.
+ * Get all function implementation services required for a group spec.
  */
-export type FromGroupAtPath<
-  GroupPath_ extends string,
-  Group extends GroupSpec.AnyWithProps,
-> =
-  GroupPath.GroupAt<Group, GroupPath_> extends infer GroupAtPath extends
-    GroupSpec.AnyWithProps
-    ? FunctionSpec.Name<
-        GroupSpec.Functions<GroupAtPath>
-      > extends infer FunctionNames extends string
-      ? FunctionNames extends string
-        ? FunctionImpl<GroupPath_, FunctionNames>
-        : never
+export type FromGroupSpec<Group extends GroupSpec.AnyWithProps> =
+  FunctionSpec.Name<
+    GroupSpec.Functions<Group>
+  > extends infer FunctionNames extends string
+    ? FunctionNames extends string
+      ? FunctionImpl<string, FunctionNames>
       : never
     : never;
+
+/**
+ * @deprecated Use {@link FromGroupSpec} instead.
+ */
+export type FromGroupAtPath<
+  _GroupPath extends string,
+  Group extends GroupSpec.AnyWithProps,
+> = FromGroupSpec<Group>;

package/src/GroupImpl.ts

@@ -1,60 +1,196 @@
-import type * as GroupPath from "@confect/core/GroupPath";
 import type * as GroupSpec from "@confect/core/GroupSpec";
-import { Context, Layer } from "effect";
+import * as Registry from "@confect/core/Registry";
+import {
+  Array,
+  Context,
+  Effect,
+  Layer,
+  Option,
+  pipe,
+  Predicate,
+  Record,
+  Ref,
+  String,
+} from "effect";
 import type * as Api from "./Api";
 import type * as FunctionImpl from "./FunctionImpl";
+import { resolveGroupPathUnsafe } from "./GroupPath";
 
-export interface GroupImpl<GroupPath_ extends string> {
+export const TypeId = "@confect/server/GroupImpl";
+export type TypeId = typeof TypeId;
+
+export type FinalizationStatus = "Unfinalized" | "Finalized";
+
+export interface GroupImpl<
+  GroupPath_ extends string,
+  FinalizationStatus_ extends FinalizationStatus = "Unfinalized",
+> {
+  readonly [TypeId]: TypeId;
   readonly groupPath: GroupPath_;
+  readonly finalizationStatus: FinalizationStatus_;
+  /**
+   * Names of every function registered into this group's layer scope by
+   * `FunctionImpl.make`. Authoritative only when `finalizationStatus` is
+   * `"Finalized"`; the `"Unfinalized"` value is set to `[]` at `make`-time
+   * since the list is only known once `finalize` snapshots the registry.
+   */
+  readonly registeredFunctionNames: ReadonlyArray<string>;
 }
 
-export const GroupImpl = <GroupPath_ extends string>({
+export interface Any extends GroupImpl<string, FinalizationStatus> {}
+
+export const isGroupImpl = (u: unknown): u is Any =>
+  Predicate.hasProperty(u, TypeId);
+
+export interface AnyFinalized extends GroupImpl<string, "Finalized"> {}
+export interface AnyUnfinalized extends GroupImpl<string, "Unfinalized"> {}
+
+export const isFinalizedGroupImpl = (u: unknown): u is AnyFinalized =>
+  isGroupImpl(u) && u.finalizationStatus === "Finalized";
+
+export const isUnfinalizedGroupImpl = (u: unknown): u is AnyUnfinalized =>
+  isGroupImpl(u) && u.finalizationStatus === "Unfinalized";
+
+/**
+ * Build the runtime tag for a `GroupImpl` service. The finalization status is
+ * embedded in the tag string so that `Unfinalized` and `Finalized` are distinct
+ * services at runtime; consumers of a finalized layer (the server's
+ * `RegisteredFunctions.buildForGroup` and the CLI's `implValidation`) retrieve
+ * the typed `Finalized` service directly rather than scanning the context.
+ */
+export const GroupImpl = <
+  GroupPath_ extends string,
+  FinalizationStatus_ extends FinalizationStatus,
+>({
   groupPath,
+  finalizationStatus,
 }: {
   groupPath: GroupPath_;
+  finalizationStatus: FinalizationStatus_;
 }) =>
-  Context.GenericTag<GroupImpl<GroupPath_>>(
-    `@confect/server/GroupImpl/${groupPath}`,
+  Context.GenericTag<GroupImpl<GroupPath_, FinalizationStatus_>>(
+    `@confect/server/GroupImpl/${finalizationStatus}/${groupPath}`,
   );
 
 export const make = <
   Api_ extends Api.AnyWithProps,
-  const GroupPath_ extends GroupPath.All<Api.Groups<Api_>>,
+  Group extends GroupSpec.AnyWithProps,
 >(
-  _api: Api_,
-  groupPath: GroupPath_,
+  api: Api_,
+  group: Group,
 ): Layer.Layer<
-  GroupImpl<GroupPath_>,
+  GroupImpl<string, "Unfinalized">,
   never,
-  | FromGroupWithPath<GroupPath_, Api.Groups<Api_>>
-  | FunctionImpl.FromGroupAtPath<GroupPath_, Api.Groups<Api_>>
-> =>
-  Layer.succeed(
-    GroupImpl<GroupPath_>({
+  FunctionImpl.FromGroupSpec<Group>
+> => {
+  const groupPath = resolveGroupPathUnsafe(api.spec, group);
+
+  return Layer.succeed(
+    GroupImpl<string, "Unfinalized">({
       groupPath,
+      finalizationStatus: "Unfinalized",
     }),
     {
+      [TypeId]: TypeId,
       groupPath,
+      finalizationStatus: "Unfinalized" as const,
+      registeredFunctionNames: [],
     },
   ) as Layer.Layer<
-    GroupImpl<GroupPath_>,
+    GroupImpl<string, "Unfinalized">,
     never,
-    | FromGroupWithPath<GroupPath_, Api.Groups<Api_>>
-    | FunctionImpl.FromGroupAtPath<GroupPath_, Api.Groups<Api_>>
+    FunctionImpl.FromGroupSpec<Group>
   >;
+};
 
-export type FromGroups<Groups extends GroupSpec.Any> = Groups extends never
-  ? never
-  : Groups extends GroupSpec.AnyWithProps
-    ? GroupImpl<GroupSpec.Name<Groups>>
-    : never;
+const isFunctionShaped = (value: unknown): boolean =>
+  Predicate.isRecord(value) && "functionSpec" in value;
 
-export type FromGroupWithPath<
-  GroupPath_ extends string,
-  Group extends GroupSpec.AnyWithProps,
-> =
-  GroupPath.SubGroupsAt<Group, GroupPath_> extends infer SubGroupPaths
-    ? SubGroupPaths extends string
-      ? GroupImpl<SubGroupPaths>
-      : never
-    : never;
+/**
+ * Walk a `RegistryItems` tree to the entries at `groupPath` and return the
+ * names of the function-shaped leaves directly underneath.
+ */
+const collectFunctionNamesAtPath = (
+  items: Registry.RegistryItems,
+  groupPath: string,
+): ReadonlyArray<string> =>
+  pipe(
+    String.split(groupPath, "."),
+    Array.reduce(Option.some<unknown>(items), (acc, segment) =>
+      acc.pipe(
+        Option.filter(Predicate.isRecord),
+        Option.flatMap((node) =>
+          segment in node ? Option.some(node[segment]) : Option.none(),
+        ),
+      ),
+    ),
+    Option.filter(Predicate.isRecord),
+    Option.map(Record.toEntries),
+    Option.map(
+      Array.filterMap(([name, value]) =>
+        isFunctionShaped(value) ? Option.some(name) : Option.none(),
+      ),
+    ),
+    Option.getOrElse((): ReadonlyArray<string> => []),
+  );
+
+const findUnfinalizedGroupImpl = <S>(
+  context: Context.Context<S>,
+): Option.Option<AnyUnfinalized> =>
+  Array.findFirst(context.unsafeMap.values(), isUnfinalizedGroupImpl);
+
+/**
+ * Mark a `GroupImpl` layer as fully implemented. The parameter type defaults
+ * `RIn = never`, so passing a layer that still requires any `FunctionImpl`
+ * service produces a type error at the impl author's site. The codegen
+ * boundary requires the resulting `"Finalized"` brand, so omitting this call
+ * is also rejected downstream.
+ *
+ * As a side effect of finalization, the names of every `FunctionImpl` that
+ * registered into this group's scope are snapshotted onto the produced
+ * service value's `registeredFunctionNames` field, so consumers can verify
+ * impl completeness against a `GroupSpec`'s expected functions without
+ * having to inspect the `Registry` themselves.
+ */
+export const finalize = <GroupPath_ extends string>(
+  group: Layer.Layer<GroupImpl<GroupPath_, "Unfinalized">>,
+): Layer.Layer<GroupImpl<GroupPath_, "Finalized">> =>
+  Layer.flatMap(
+    group,
+    (context): Layer.Layer<GroupImpl<GroupPath_, "Finalized">> =>
+      findUnfinalizedGroupImpl(context).pipe(
+        Option.match({
+          onNone: () =>
+            Layer.die(
+              new Error(
+                "GroupImpl.finalize: no Unfinalized GroupImpl service was found in the layer's context.",
+              ),
+            ),
+          onSome: (unfinalized) => {
+            const groupPath = unfinalized.groupPath as GroupPath_;
+            return Layer.effect(
+              GroupImpl<GroupPath_, "Finalized">({
+                groupPath,
+                finalizationStatus: "Finalized",
+              }),
+              Effect.gen(function* () {
+                const registry = yield* Registry.Registry;
+                const items = yield* Ref.get(registry);
+                return {
+                  [TypeId]: TypeId,
+                  groupPath,
+                  finalizationStatus: "Finalized" as const,
+                  registeredFunctionNames: collectFunctionNamesAtPath(
+                    items,
+                    groupPath,
+                  ),
+                };
+              }),
+            );
+          },
+        }),
+      ),
+  );
+
+export type FromGroupSpec<Group extends GroupSpec.AnyWithProps> =
+  FunctionImpl.FromGroupSpec<Group>;

package/src/GroupPath.ts

@@ -0,0 +1,43 @@
+import type * as GroupSpec from "@confect/core/GroupSpec";
+import type * as Spec from "@confect/core/Spec";
+import { Array, Option, pipe, Record } from "effect";
+
+const resolveGroupPathInGroup = (
+  group: GroupSpec.AnyWithProps,
+  target: GroupSpec.AnyWithProps,
+  pathSegments: ReadonlyArray<string>,
+): Option.Option<string> =>
+  pipe(
+    Record.toEntries(group.groups),
+    Array.findFirst(([name, child]) =>
+      child === target
+        ? Option.some(Array.join([...pathSegments, name], "."))
+        : resolveGroupPathInGroup(child, target, [...pathSegments, name]),
+    ),
+  );
+
+const resolveGroupPath = (
+  spec: Spec.AnyWithProps,
+  target: GroupSpec.AnyWithProps,
+): Option.Option<string> =>
+  pipe(
+    Record.toEntries(spec.groups),
+    Array.findFirst(([name, group]) =>
+      group === target
+        ? Option.some(name)
+        : resolveGroupPathInGroup(group, target, [name]),
+    ),
+  );
+
+export const resolveGroupPathUnsafe = (
+  spec: Spec.AnyWithProps,
+  target: GroupSpec.AnyWithProps,
+): string =>
+  resolveGroupPath(spec, target).pipe(
+    Option.getOrThrowWith(
+      () =>
+        new Error(
+          "Could not resolve group path for the provided GroupSpec. Ensure the spec is part of the assembled API spec tree.",
+        ),
+    ),
+  );