@confect/core 10.0.0-next.9 → 10.1.0

package/src/Spec.ts

@@ -1,8 +1,9 @@
 import * as Predicate from "effect/Predicate";
 import * as Record from "effect/Record";
+import * as Struct from "effect/Struct";
 import * as GroupSpec from "./GroupSpec";
 
-export const TypeId = "@confect/core/Spec";
+export const TypeId = "~@confect/core/Spec";
 export type TypeId = typeof TypeId;
 
 export const isSpec = (u: unknown): u is AnyWithProps =>
@@ -10,66 +11,76 @@ export const isSpec = (u: unknown): u is AnyWithProps =>
 
 /**
  * A Confect spec: a flat container of function groups. Groups may be of any
- * runtime — a group built with `GroupSpec.makeNode()` (a Node action group) sits
+ * runtime—a group built with `GroupSpec.makeNode()` (a Node action group) sits
  * alongside `GroupSpec.make()` groups in the same namespace. The runtime of a
  * group lives on the group itself (`GroupSpec.runtime`) and on each function's
  * `RuntimeAndFunctionType`; the spec does not carry a runtime of its own.
  */
-export interface Spec<Groups_ extends GroupSpec.AnyWithProps = never> {
-  readonly [TypeId]: TypeId;
-  readonly groups: {
-    [GroupName in GroupSpec.Name<Groups_>]: GroupSpec.WithName<
-      Groups_,
-      GroupName
-    >;
-  };
+export interface Spec<
+  Groups_ extends Record.ReadonlyRecord<string, GroupSpec.AnyWithProps> = {},
+> {
+  readonly [TypeId]: Readonly<Groups_>;
 
   add<Group extends GroupSpec.AnyWithProps>(
     group: Group,
-  ): Spec<Groups_ | Group>;
+  ): Spec<
+    Struct.Assign<Groups_, Record.ReadonlyRecord<GroupSpec.Name<Group>, Group>>
+  >;
 
   addAt<const Name extends string, Group extends GroupSpec.AnyWithProps>(
     name: Name,
     group: Group,
-  ): Spec<Groups_ | GroupSpec.NamedAt<Group, Name>>;
+  ): Spec<
+    Struct.Assign<
+      Groups_,
+      Record.ReadonlyRecord<Name, GroupSpec.NamedAt<Group, Name>>
+    >
+  >;
 }
 
 export interface Any {
-  readonly [TypeId]: TypeId;
+  readonly [TypeId]: unknown;
 }
 
-export interface AnyWithProps extends Spec<GroupSpec.AnyWithProps> {}
+export interface AnyWithProps extends Any {
+  readonly [TypeId]: Record.ReadonlyRecord<string, GroupSpec.AnyWithProps>;
+}
 
 export type Groups<Spec_ extends AnyWithProps> =
-  Spec_["groups"][keyof Spec_["groups"]];
+  Spec_[TypeId][keyof Spec_[TypeId]];
 
-const Proto = {
-  [TypeId]: TypeId,
+/**
+ * The group record stored by a spec, with its precise member types.
+ */
+export const groups = <Spec_ extends AnyWithProps>(
+  self: Spec_,
+): Spec_[TypeId] => self[TypeId];
 
-  add<Group extends GroupSpec.AnyWithProps>(this: AnyWithProps, group: Group) {
-    return makeProto({
-      groups: Record.set(this.groups, group.name, group),
-    });
+const makeRecord = <
+  Groups_ extends Record.ReadonlyRecord<string, GroupSpec.AnyWithProps>,
+>(
+  record: Groups_,
+): Spec<Groups_> => ({
+  [TypeId]: record,
+  add<Group extends GroupSpec.AnyWithProps>(group: Group) {
+    return makeRecord(
+      Struct.assign(
+        record,
+        Record.singleton<GroupSpec.Name<Group>, Group>(group.name, group),
+      ),
+    );
   },
-
-  addAt<Group extends GroupSpec.AnyWithProps>(
-    this: AnyWithProps,
-    name: string,
+  addAt<const Name extends string, Group extends GroupSpec.AnyWithProps>(
+    name: Name,
     group: Group,
   ) {
-    return makeProto({
-      groups: Record.set(this.groups, name, GroupSpec.withName(name, group)),
-    });
+    return makeRecord(
+      Struct.assign(
+        record,
+        Record.singleton(name, GroupSpec.withName(name, group)),
+      ),
+    );
   },
-};
-
-const makeProto = <Groups_ extends GroupSpec.AnyWithProps>({
-  groups,
-}: {
-  groups: Record.ReadonlyRecord<string, Groups_>;
-}): Spec<Groups_> =>
-  Object.assign(Object.create(Proto), {
-    groups,
-  });
+});
 
-export const make = (): Spec => makeProto({ groups: {} });
+export const make = (): Spec => makeRecord({});

package/src/SystemFields.ts

@@ -13,12 +13,13 @@ import * as Struct from "effect/Struct";
 import * as GenericId from "./GenericId";
 
 /**
- * Produces a schema for Convex system fields. In Confect, system fields include `_id`.
+ * Produces a schema for Convex system fields. In Confect, system fields include
+ * `_id`.
  */
 export const SystemFields = <TableName extends string>(tableName: TableName) =>
   Schema.Struct({
     _id: GenericId.GenericId(tableName),
-    _creationTime: Schema.Number,
+    _creationTime: Schema.Finite,
   });
 
 /**
@@ -58,23 +59,21 @@ const splitSystemFields = (input: { [key: PropertyKey]: unknown }) => {
  * output. Transformations construct fresh objects, so without this the system
  * fields would be dropped at every transformation step.
  */
-const wrapGetter = (
-  getter: SchemaGetter.Getter<any, any, any>,
-): SchemaGetter.Getter<any, any, any> =>
-  new SchemaGetter.Getter((input, options) => {
+const wrapGetter = <R>(
+  getter: SchemaGetter.Getter<any, any, R>,
+): SchemaGetter.Getter<any, any, R> =>
+  SchemaGetter.transformOptionalEffect((input, options) => {
     if (Option.isNone(input) || !Predicate.isObject(input.value)) {
-      return getter.run(input, options);
+      return SchemaGetter.run(getter, input, options);
     }
     const { system, rest } = splitSystemFields(input.value);
-    return getter
-      .run(Option.some(rest), options)
-      .pipe(
-        Effect.map(
-          Option.map((output) =>
-            Predicate.isObject(output) ? Struct.assign(output, system) : output,
-          ),
+    return SchemaGetter.run(getter, Option.some(rest), options).pipe(
+      Effect.map(
+        Option.map((output) =>
+          Predicate.isObject(output) ? Struct.assign(output, system) : output,
         ),
-      );
+      ),
+    );
   });
 
 const wrapTransformation = (
@@ -93,8 +92,8 @@ const wrapTransformation = (
 
 /**
  * Builds an AST walker that adds the given system-field property signatures to
- * every object node of a schema's AST — including each step of its encoding
- * chain — wrapping transformations so the fields survive them.
+ * every object node of a schema's AST—including each step of its encoding
+ * chain—wrapping transformations so the fields survive them.
  */
 const makeExtendAst = (
   systemPropertySignatures: ReadonlyArray<SchemaAST.PropertySignature>,
@@ -113,7 +112,7 @@ const makeExtendAst = (
     if (SchemaAST.isUnion(ast)) {
       return new SchemaAST.Union(
         Array.map(ast.types, extendAst),
-        ast.mode,
+        ast.options,
         ast.annotations,
         ast.checks,
         ast.encoding === undefined ? undefined : extendEncoding(ast.encoding),
@@ -154,15 +153,15 @@ const makeExtendAst = (
 /**
  * Extend a table schema with Convex system fields.
  *
- * A plain `Struct` gains the fields via `Schema.fieldsAssign` and a `Union`
- * has them distributed across its members, preserving the schema's
- * `Struct`/`Union` structure. Any other object-shaped schema — one built with
- * `Schema.decodeTo`/`Schema.encodeKeys`, a branded struct, a suspended schema
- * — is extended at the AST level: every object node in its encoding chain
- * gains the system fields, and each transformation is wrapped so the fields
- * bypass the user-defined getters. Schemas that do not resolve to an object
- * shape at every step (such as `Schema.Class`, whose decoded values are class
- * instances) are rejected with a descriptive error.
+ * A plain `Struct` gains the fields via `mapFields` and a `Union` has them
+ * distributed across its members via `mapMembers`, preserving the schema's
+ * checks and `Struct`/`Union` structure. Any other object-shaped schema—one
+ * built with `Schema.decodeTo`/`Schema.encodeKeys`, a branded struct, a
+ * suspended schema—is extended at the AST level: every object node in its
+ * encoding chain gains the system fields, and each transformation is wrapped so
+ * the fields bypass the user-defined getters. Schemas that do not resolve to an
+ * object shape at every step (such as `Schema.Class`, whose decoded values are
+ * class instances) are rejected with a descriptive error.
  *
  * Note that struct-level checks on an extended schema observe the value with
  * the system fields attached, and encoding an extended schema emits the system
@@ -193,11 +192,9 @@ export const extendWithSystemFields = <
       SchemaAST.isUnion(s.ast) &&
       Array.isArray((s as { readonly members?: unknown }).members)
     ) {
-      return Schema.Union(
-        Array.map(
-          (s as Schema.Union<ReadonlyArray<Schema.Top>>).members,
-          extend,
-        ),
+      return (s as Schema.Union<ReadonlyArray<Schema.Top>>).mapMembers(
+        Array.map(extend),
+        { unsafePreserveChecks: true },
       );
     }
     if (
@@ -205,8 +202,9 @@ export const extendWithSystemFields = <
       SchemaAST.isObjects(s.ast) &&
       typeof (s as { readonly mapFields?: unknown }).mapFields === "function"
     ) {
-      return Schema.fieldsAssign(system)(
-        s as Schema.Struct<Schema.Struct.Fields>,
+      return (s as Schema.Struct<Schema.Struct.Fields>).mapFields(
+        Struct.assign(system),
+        { unsafePreserveChecks: true },
       );
     }
     return Schema.make(extendAst(s.ast));
@@ -219,9 +217,9 @@ export const extendWithSystemFields = <
 };
 
 /**
- * Applies the system fields to a single struct, mirroring `Schema.fieldsAssign`.
- * Any other (already-extended or opaque) schema falls back to a `Codec` carrying
- * the system-field document shape.
+ * Applies the system fields to a single struct, mirroring
+ * `Schema.fieldsAssign`. Any other (already-extended or opaque) schema falls
+ * back to a `Codec` carrying the system-field document shape.
  */
 type ApplySystemFields<TableName extends string, S> =
   S extends Schema.Struct<infer Fields extends Schema.Struct.Fields>
@@ -241,10 +239,10 @@ type ApplySystemFields<TableName extends string, S> =
  * This mirrors the runtime {@link extendWithSystemFields}: a `Struct` gains the
  * system fields directly (matching `Schema.fieldsAssign`), and a `Union` has
  * them distributed across its members (matching
- * `union.mapMembers(Tuple.map(Schema.fieldsAssign(...)))`). The `Struct`/`Union`
- * structure is preserved rather than collapsed to a bare `Codec`; any other
- * schema falls back to a `Codec` carrying the system-field document shape,
- * matching the runtime's AST-level extension.
+ * `union.mapMembers(Tuple.map(Schema.fieldsAssign(...)))`). The
+ * `Struct`/`Union` structure is preserved rather than collapsed to a bare
+ * `Codec`; any other schema falls back to a `Codec` carrying the system-field
+ * document shape, matching the runtime's AST-level extension.
  */
 export type ExtendWithSystemFields<
   TableName extends string,
@@ -264,7 +262,7 @@ export type ExtendWithSystemFields<
 
 /**
  * The decoded/encoded document shape: a table's fields plus Convex's system
- * fields. Deliberately a bare intersection (no `Expand`/`Simplify`) — flattening
+ * fields. Deliberately a bare intersection (no `Expand`/`Simplify`)—flattening
  * it with a homomorphic mapped type collapses to `{ [x: string]: any }` when
  * `Document` is still an unresolved generic, which breaks structural
  * comparability in the database reader/writer plumbing.