@confect/core 10.0.0-next.17 → 10.0.0-next.18

package/src/FunctionProvenance.ts

@@ -14,9 +14,9 @@ export type FunctionProvenance = Data.TaggedEnum<{
   };
   Convex: {
     /** @internal */
-    _args: DefaultFunctionArgs;
+    "~args": DefaultFunctionArgs;
     /** @internal */
-    _returns: any;
+    "~returns": any;
   };
 }>;
 
@@ -67,8 +67,8 @@ export interface AnyConfect extends Confect<
 
 export interface Convex<Args extends DefaultFunctionArgs, Returns> {
   readonly _tag: "Convex";
-  readonly _args: Args;
-  readonly _returns: Returns;
+  readonly "~args": Args;
+  readonly "~returns": Returns;
 }
 
 export interface AnyConvex extends Convex<DefaultFunctionArgs, any> {}
@@ -81,7 +81,7 @@ const Standard: Standard = { _tag: "Standard" };
  * Build a `Confect` provenance from lazy schema thunks. `args`, `returns`,
  * and `error` are exposed as sync lazy memoised getters (via {@link Lazy.defineProperty})
  * that only evaluate their thunk on first access, mirroring how `Table`
- * defers `Fields`/`Doc`/`tableDefinition`. This keeps importing the assembled
+ * defers `Fields`/`Doc`. This keeps importing the assembled
  * `_generated/spec.ts` cheap — no `Schema.Struct(...)` / `Schema.Array(...)`
  * work runs at module load; it is deferred to the first invocation that
  * actually compiles validators or runs a codec.
@@ -223,10 +223,10 @@ export const ConfectPaginated = <
   return self;
 };
 
-export const Convex = <_Args extends DefaultFunctionArgs, _Returns>() =>
+export const Convex = <Args extends DefaultFunctionArgs, Returns>() =>
   FunctionProvenance.Convex(
     {} as {
-      _args: _Args;
-      _returns: _Returns;
+      "~args": Args;
+      "~returns": Returns;
     },
   );

package/src/FunctionSpec.ts

@@ -12,7 +12,7 @@ import { validateConfectFunctionIdentifier } from "./Identifier";
 import type * as MiddlewareSpec from "./MiddlewareSpec";
 import * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";
 
-export const TypeId = "@confect/core/FunctionSpec";
+export const TypeId = "~@confect/core/FunctionSpec";
 export type TypeId = typeof TypeId;
 
 export const isFunctionSpec = (u: unknown): u is AnyWithProps =>
@@ -140,7 +140,7 @@ export type Args<FunctionSpec_ extends AnyWithProps> = FunctionSpec_ extends {
 }
   ? ArgsSchema_["Type"]
   : FunctionSpec_ extends {
-        functionProvenance: { _tag: "Convex"; _args: infer Args_ };
+        functionProvenance: { _tag: "Convex"; "~args": infer Args_ };
       }
     ? Args_
     : never;
@@ -154,7 +154,7 @@ export type Returns<FunctionSpec_ extends AnyWithProps> =
   }
     ? ReturnsSchema_["Type"]
     : FunctionSpec_ extends {
-          functionProvenance: { _tag: "Convex"; _returns: infer Returns_ };
+          functionProvenance: { _tag: "Convex"; "~returns": infer Returns_ };
         }
       ? Awaited<Returns_>
       : never;
@@ -168,7 +168,7 @@ export type EncodedArgs<FunctionSpec_ extends AnyWithProps> =
   }
     ? ArgsSchema_["Encoded"]
     : FunctionSpec_ extends {
-          functionProvenance: { _tag: "Convex"; _args: infer Args_ };
+          functionProvenance: { _tag: "Convex"; "~args": infer Args_ };
         }
       ? Args_
       : never;
@@ -182,7 +182,7 @@ export type EncodedReturns<FunctionSpec_ extends AnyWithProps> =
   }
     ? ReturnsSchema_["Encoded"]
     : FunctionSpec_ extends {
-          functionProvenance: { _tag: "Convex"; _returns: infer Returns_ };
+          functionProvenance: { _tag: "Convex"; "~returns": infer Returns_ };
         }
       ? Returns_
       : never;

package/src/GroupPath.ts

@@ -1,4 +1,3 @@
-import type { Record } from "effect";
 import type * as GroupSpec from "./GroupSpec";
 
 /**
@@ -41,11 +40,7 @@ export type GroupAt<
 > = Group extends GroupSpec.AnyWithProps
   ? Path extends `${infer Head}.${infer Tail}`
     ? Group extends { readonly name: Head }
-      ? Group extends {
-          readonly groups: Record.ReadonlyRecord<string, infer SubGroup>;
-        }
-        ? GroupAt<SubGroup, Tail>
-        : never
+      ? GroupAt<GroupSpec.Groups<Group>, Tail>
       : never
     : GroupSpec.WithName<Group, Path>
   : never;

package/src/GroupSpec.ts

@@ -5,7 +5,7 @@ import type * as MiddlewareSpec from "./MiddlewareSpec";
 import type * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";
 import { validateConfectFunctionIdentifier } from "./Identifier";
 
-export const TypeId = "@confect/core/GroupSpec";
+export const TypeId = "~@confect/core/GroupSpec";
 export type TypeId = typeof TypeId;
 
 export const isGroupSpec = (u: unknown): u is AnyWithProps =>
@@ -36,6 +36,8 @@ export interface GroupSpec<
     [GroupName in Name<Groups_>]: WithName<Groups_, GroupName>;
   };
   readonly middlewareSpecs: ReadonlyArray<MiddlewareSpecs_>;
+  readonly "~Functions": Functions_;
+  readonly "~Groups": Groups_;
 
   addFunction<Function extends FunctionSpec.AnyWithPropsWithRuntime<Runtime>>(
     function_: Function &
@@ -103,11 +105,9 @@ export interface AnyWithPropsWithRuntime<
 
 export type Name<Group extends AnyWithProps> = Group["name"];
 
-export type Functions<Group extends AnyWithProps> =
-  Group["functions"][keyof Group["functions"]];
+export type Functions<Group extends AnyWithProps> = Group["~Functions"];
 
-export type Groups<Group extends AnyWithProps> =
-  Group["groups"][keyof Group["groups"]];
+export type Groups<Group extends AnyWithProps> = Group["~Groups"];
 
 export type MiddlewareSpecs<Group extends AnyWithProps> =
   Group["middlewareSpecs"][number];
@@ -271,7 +271,7 @@ const makeProto = <
     functions,
     groups,
     middlewareSpecs,
-  });
+  }) as GroupSpec<Runtime, Name_, Functions_, Groups_, MiddlewareSpecs_>;
 
 export const make = (): GroupSpec<"Convex", ""> =>
   makeProto({

package/src/Lazy.ts

@@ -14,9 +14,8 @@
  * forcing the computation.
  *
  * This is the single shared implementation consumed across packages (e.g.
- * `@confect/core`'s lazy `FunctionSpec` schemas and `@confect/server`'s lazy
- * `Table` `Fields` / `Doc` / `tableDefinition`), so there is no chance of the
- * two drifting apart.
+ * `@confect/core`'s lazy `FunctionSpec` schemas and lazy `Table` `Fields` /
+ * `Doc`), so there is no chance of the two drifting apart.
  */
 export const defineProperty = <T extends object, K extends PropertyKey>(
   target: T,

package/src/MiddlewareSpec.ts

@@ -8,7 +8,7 @@ import type * as FunctionSpec from "./FunctionSpec";
 import * as Lazy from "./Lazy";
 import type * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";
 
-export const TypeId = "@confect/core/MiddlewareSpec";
+export const TypeId = "~@confect/core/MiddlewareSpec";
 export type TypeId = typeof TypeId;
 
 export const isMiddlewareSpec = (u: unknown): u is AnyMiddlewareSpec =>
@@ -228,7 +228,7 @@ export const errorSchemas = (
  * problem at the `.middleware()` / `.addFunction()` call site.
  */
 export interface AttachmentError<Message extends string> {
-  readonly "~confect/MiddlewareSpec/AttachmentError": Message;
+  readonly "~@confect/core/MiddlewareSpec/AttachmentError": Message;
 }
 
 type FunctionTypeOf<FunctionSpec_ extends FunctionSpec.AnyWithProps> =

package/src/Ref.ts

@@ -18,17 +18,17 @@ import * as MiddlewareSpec from "./MiddlewareSpec";
 import type * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";
 
 export interface Base<
-  _RuntimeAndFunctionType extends RuntimeAndFunctionType.RuntimeAndFunctionType,
-  _FunctionVisibility extends FunctionVisibility,
-  _Args,
-  _Returns,
-  _Error = never,
+  RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType,
+  FunctionVisibility_ extends FunctionVisibility,
+  Args_,
+  Returns_,
+  Error_ = never,
 > {
-  readonly _RuntimeAndFunctionType?: _RuntimeAndFunctionType;
-  readonly _FunctionVisibility?: _FunctionVisibility;
-  readonly _Args?: _Args;
-  readonly _Returns?: _Returns;
-  readonly _Error?: _Error;
+  readonly "~RuntimeAndFunctionType": RuntimeAndFunctionType_;
+  readonly "~FunctionVisibility": FunctionVisibility_;
+  readonly "~Args": Args_;
+  readonly "~Returns": Returns_;
+  readonly "~Error": Error_;
   /** @internal */
   readonly convexFunctionName: string;
 }
@@ -39,39 +39,39 @@ export interface Base<
  * errors. A ref is one of two shapes, keyed by the spec's provenance.
  */
 export type Ref<
-  _RuntimeAndFunctionType extends RuntimeAndFunctionType.RuntimeAndFunctionType,
-  _FunctionVisibility extends FunctionVisibility,
-  _Args,
-  _Returns,
-  _Error = never,
+  RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType,
+  FunctionVisibility_ extends FunctionVisibility,
+  Args_,
+  Returns_,
+  Error_ = never,
 > =
   | ConfectRef<
-      _RuntimeAndFunctionType,
-      _FunctionVisibility,
-      _Args,
-      _Returns,
-      _Error
+      RuntimeAndFunctionType_,
+      FunctionVisibility_,
+      Args_,
+      Returns_,
+      Error_
     >
   | ConvexRef<
-      _RuntimeAndFunctionType,
-      _FunctionVisibility,
-      _Args,
-      _Returns,
-      _Error
+      RuntimeAndFunctionType_,
+      FunctionVisibility_,
+      Args_,
+      Returns_,
+      Error_
     >;
 
 export interface ConfectRef<
-  _RuntimeAndFunctionType extends RuntimeAndFunctionType.RuntimeAndFunctionType,
-  _FunctionVisibility extends FunctionVisibility,
-  _Args,
-  _Returns,
-  _Error = never,
+  RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType,
+  FunctionVisibility_ extends FunctionVisibility,
+  Args_,
+  Returns_,
+  Error_ = never,
 > extends Base<
-  _RuntimeAndFunctionType,
-  _FunctionVisibility,
-  _Args,
-  _Returns,
-  _Error
+  RuntimeAndFunctionType_,
+  FunctionVisibility_,
+  Args_,
+  Returns_,
+  Error_
 > {
   /** @internal */
   readonly _tag: "Confect";
@@ -88,17 +88,17 @@ export interface ConfectRef<
 }
 
 export interface ConvexRef<
-  _RuntimeAndFunctionType extends RuntimeAndFunctionType.RuntimeAndFunctionType,
-  _FunctionVisibility extends FunctionVisibility,
-  _Args,
-  _Returns,
-  _Error = never,
+  RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType,
+  FunctionVisibility_ extends FunctionVisibility,
+  Args_,
+  Returns_,
+  Error_ = never,
 > extends Base<
-  _RuntimeAndFunctionType,
-  _FunctionVisibility,
-  _Args,
-  _Returns,
-  _Error
+  RuntimeAndFunctionType_,
+  FunctionVisibility_,
+  Args_,
+  Returns_,
+  Error_
 > {
   /** @internal */
   readonly _tag: "Convex";
@@ -169,86 +169,42 @@ export type AnyPublicAction = Ref<
   any
 >;
 
-export type GetRuntimeAndFunctionType<Ref_> =
-  Ref_ extends Base<
-    infer RuntimeAndFunctionType_,
-    infer _FunctionVisibility,
-    infer _Args,
-    infer _Returns,
-    infer _Error
-  >
-    ? RuntimeAndFunctionType_
-    : never;
-
-export type GetRuntime<Ref_> =
-  Ref_ extends Base<
-    infer RuntimeAndFunctionType_,
-    infer _FunctionVisibility,
-    infer _Args,
-    infer _Returns,
-    infer _Error
-  >
-    ? RuntimeAndFunctionType.GetRuntime<RuntimeAndFunctionType_>
-    : never;
-
-export type GetFunctionType<Ref_> =
-  Ref_ extends Base<
-    infer RuntimeAndFunctionType_,
-    infer _FunctionVisibility,
-    infer _Args,
-    infer _Returns,
-    infer _Error
-  >
-    ? RuntimeAndFunctionType.GetFunctionType<RuntimeAndFunctionType_>
-    : never;
-
-export type GetFunctionVisibility<Ref_> =
-  Ref_ extends Base<
-    infer _RuntimeAndFunctionType,
-    infer FunctionVisibility_,
-    infer _Args,
-    infer _Returns,
-    infer _Error
-  >
-    ? FunctionVisibility_
-    : never;
-
-export type Args<Ref_> =
-  Ref_ extends Base<
-    infer _RuntimeAndFunctionType,
-    infer _FunctionVisibility,
-    infer Args_,
-    infer _Returns,
-    infer _Error
-  >
-    ? Args_
-    : never;
+export type GetRuntimeAndFunctionType<Ref_> = Ref_ extends {
+  readonly "~RuntimeAndFunctionType": infer RuntimeAndFunctionType_ extends
+    RuntimeAndFunctionType.RuntimeAndFunctionType;
+}
+  ? RuntimeAndFunctionType_
+  : never;
+
+export type GetRuntime<Ref_> = RuntimeAndFunctionType.GetRuntime<
+  GetRuntimeAndFunctionType<Ref_>
+>;
+
+export type GetFunctionType<Ref_> = RuntimeAndFunctionType.GetFunctionType<
+  GetRuntimeAndFunctionType<Ref_>
+>;
+
+export type GetFunctionVisibility<Ref_> = Ref_ extends {
+  readonly "~FunctionVisibility": infer FunctionVisibility_;
+}
+  ? FunctionVisibility_
+  : never;
+
+export type Args<Ref_> = Ref_ extends { readonly "~Args": infer Args_ }
+  ? Args_
+  : never;
 
 export type OptionalArgs<Ref_ extends Any> = keyof Args<Ref_> extends never
   ? [args?: Args<Ref_>]
   : [args: Args<Ref_>];
 
-export type Returns<Ref_> =
-  Ref_ extends Base<
-    infer _RuntimeAndFunctionType,
-    infer _FunctionVisibility,
-    infer _Args,
-    infer Returns_,
-    infer _Error
-  >
-    ? Returns_
-    : never;
-
-export type Error<Ref_> =
-  Ref_ extends Base<
-    infer _RuntimeAndFunctionType,
-    infer _FunctionVisibility,
-    infer _Args,
-    infer _Returns,
-    infer Error_
-  >
-    ? Error_
-    : never;
+export type Returns<Ref_> = Ref_ extends { readonly "~Returns": infer Returns_ }
+  ? Returns_
+  : never;
+
+export type Error<Ref_> = Ref_ extends { readonly "~Error": infer Error_ }
+  ? Error_
+  : never;
 
 export type FunctionReference<Ref_ extends Any> = ConvexFunctionReference<
   GetFunctionType<Ref_>,
@@ -318,10 +274,14 @@ export const make = <FunctionSpec_ extends FunctionSpec.AnyWithProps>(
   const convexFunctionName = `${convexFunctionNamespace}:${functionSpec.name}`;
 
   return Match.value(functionSpec.functionProvenance).pipe(
-    Match.tag("Convex", (): Any => ({
-      _tag: "Convex",
-      convexFunctionName,
-    })),
+    Match.tag(
+      "Convex",
+      (): Any =>
+        ({
+          _tag: "Convex",
+          convexFunctionName,
+        }) as Any,
+    ),
     Match.tag("Confect", (provenance): Any => {
       const ref = {
         _tag: "Confect" as const,