@confect/core 10.0.0-next.8 → 10.0.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,11 +153,11 @@ 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
+ * 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
@@ -191,9 +190,7 @@ export const extendWithSystemFields = <
     if (
       s.ast.encoding === undefined &&
       SchemaAST.isUnion(s.ast) &&
-      Array.isArray(
-        (s as Partial<Schema.Union<ReadonlyArray<Schema.Top>>>).members,
-      )
+      Array.isArray((s as { readonly members?: unknown }).members)
     ) {
       return Schema.Union(
         Array.map(
@@ -205,8 +202,7 @@ export const extendWithSystemFields = <
     if (
       s.ast.encoding === undefined &&
       SchemaAST.isObjects(s.ast) &&
-      typeof (s as Partial<Schema.Struct<Schema.Struct.Fields>>).mapFields ===
-        "function"
+      typeof (s as { readonly mapFields?: unknown }).mapFields === "function"
     ) {
       return Schema.fieldsAssign(system)(
         s as Schema.Struct<Schema.Struct.Fields>,
@@ -222,9 +218,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>
@@ -244,10 +240,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,
@@ -267,7 +263,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.

package/src/Table.ts

@@ -0,0 +1,427 @@
+import * as Lazy from "./Lazy";
+import * as SystemFields from "./SystemFields";
+import type { TableSchemaToTableValidator } from "./SchemaToValidator";
+import type {
+  SystemFields as ConvexSystemFields,
+  Expand,
+  GenericTableIndexes,
+  GenericTableSearchIndexes,
+  GenericTableVectorIndexes,
+  IndexTiebreakerField,
+  SearchIndexConfig,
+  VectorIndexConfig,
+} from "convex/server";
+import type { GenericValidator, Validator } from "convex/values";
+import * as Predicate from "effect/Predicate";
+import type * as Schema from "effect/Schema";
+
+export const TypeId = "~@confect/core/Table";
+export type TypeId = typeof TypeId;
+
+// -----------------------------------------------------------------------------
+// Predicates
+// -----------------------------------------------------------------------------
+//
+// Both bound `Table`s and `UnnamedTable` callables share the same `[TypeId]`
+// brand. They disambiguate by whether a `tableName` property is set: bound
+// tables have one, unnamed callables do not.
+//
+// The discriminator is `tableName` (not `name`) so it does not collide with
+// the built-in `Function.prototype.name` that every JS function carries.
+
+export const isTable = (u: unknown): u is Any =>
+  Predicate.hasProperty(u, TypeId) && Predicate.hasProperty(u, "tableName");
+
+export const isUnnamedTable = (u: unknown): u is UnnamedAny =>
+  Predicate.hasProperty(u, TypeId) && !Predicate.hasProperty(u, "tableName");
+
+// -----------------------------------------------------------------------------
+// Bound Table
+// -----------------------------------------------------------------------------
+//
+// A bound `Table` is the client-safe document schema: `Fields`, `Doc`, and
+// the index metadata records. The Convex deploy `tableDefinition` (which
+// value-imports `convex/server`) is produced separately by
+// `@confect/server/Table.tableDefinition`.
+
+export interface Table<
+  Name_ extends string,
+  TableSchema_ extends Schema.Codec<any, any>,
+  TableValidator_ extends GenericValidator =
+    TableSchemaToTableValidator<TableSchema_>,
+  Indexes_ extends GenericTableIndexes = {},
+  SearchIndexes_ extends GenericTableSearchIndexes = {},
+  VectorIndexes_ extends GenericTableVectorIndexes = {},
+> {
+  readonly [TypeId]: TypeId;
+  readonly tableName: Name_;
+  readonly Fields: TableSchema_;
+  readonly Doc: SystemFields.ExtendWithSystemFields<Name_, TableSchema_>;
+  readonly indexes: Indexes_;
+  readonly searchIndexes: SearchIndexes_;
+  readonly vectorIndexes: VectorIndexes_;
+  readonly "~TableValidator": TableValidator_;
+}
+
+export interface Any {
+  readonly [TypeId]: TypeId;
+  readonly tableName: string;
+}
+
+export type AnyWithProps = Table<
+  any,
+  Schema.Codec<any, any>,
+  GenericValidator,
+  GenericTableIndexes,
+  GenericTableSearchIndexes,
+  GenericTableVectorIndexes
+>;
+
+// -----------------------------------------------------------------------------
+// UnnamedTable (callable)
+// -----------------------------------------------------------------------------
+//
+// `Table.make(lazyFields)` returns an `UnnamedTable`: a callable that
+// produces a fully bound `Table` when invoked with a name. Chaining methods
+// (`.index`, `.searchIndex`, `.vectorIndex`) live here and return new
+// `UnnamedTable`s, accumulating plain index metadata records. The
+// user-supplied `lazyFields` callback is just carried through until first
+// access of `Fields`/`Doc` on a bound table. The codegen pipeline emits a
+// wrapper file per user-authored table that simply invokes the unnamed
+// callable with the filename basename.
+
+export interface UnnamedTable<
+  TableSchema_ extends Schema.Codec<any, any>,
+  TableValidator_ extends GenericValidator =
+    TableSchemaToTableValidator<TableSchema_>,
+  Indexes_ extends GenericTableIndexes = {},
+  SearchIndexes_ extends GenericTableSearchIndexes = {},
+  VectorIndexes_ extends GenericTableVectorIndexes = {},
+> {
+  <const Name_ extends string>(
+    tableName: Name_,
+  ): Table<
+    Name_,
+    TableSchema_,
+    TableValidator_,
+    Indexes_,
+    SearchIndexes_,
+    VectorIndexes_
+  >;
+
+  readonly [TypeId]: TypeId;
+  readonly indexes: Indexes_;
+  readonly searchIndexes: SearchIndexes_;
+  readonly vectorIndexes: VectorIndexes_;
+  readonly "~TableValidator": TableValidator_;
+
+  index<
+    IndexName extends string,
+    FirstFieldPath extends ExtractFieldPaths<TableValidator_>,
+    RestFieldPaths extends ExtractFieldPaths<TableValidator_>[],
+  >(
+    name: IndexName,
+    fields: [FirstFieldPath, ...RestFieldPaths],
+  ): UnnamedTable<
+    TableSchema_,
+    TableValidator_,
+    Expand<
+      Indexes_ &
+        Record<
+          IndexName,
+          [FirstFieldPath, ...RestFieldPaths, IndexTiebreakerField]
+        >
+    >,
+    SearchIndexes_,
+    VectorIndexes_
+  >;
+
+  searchIndex<
+    IndexName extends string,
+    SearchField extends ExtractFieldPaths<TableValidator_>,
+    FilterFields extends ExtractFieldPaths<TableValidator_> = never,
+  >(
+    name: IndexName,
+    indexConfig: Expand<SearchIndexConfig<SearchField, FilterFields>>,
+  ): UnnamedTable<
+    TableSchema_,
+    TableValidator_,
+    Indexes_,
+    Expand<
+      SearchIndexes_ &
+        Record<
+          IndexName,
+          {
+            searchField: SearchField;
+            filterFields: FilterFields;
+          }
+        >
+    >,
+    VectorIndexes_
+  >;
+
+  vectorIndex<
+    IndexName extends string,
+    VectorField extends ExtractFieldPaths<TableValidator_>,
+    FilterFields extends ExtractFieldPaths<TableValidator_> = never,
+  >(
+    name: IndexName,
+    indexConfig: Expand<VectorIndexConfig<VectorField, FilterFields>>,
+  ): UnnamedTable<
+    TableSchema_,
+    TableValidator_,
+    Indexes_,
+    SearchIndexes_,
+    Expand<
+      VectorIndexes_ &
+        Record<
+          IndexName,
+          {
+            vectorField: VectorField;
+            dimensions: number;
+            filterFields: FilterFields;
+          }
+        >
+    >
+  >;
+}
+
+export interface UnnamedAny {
+  readonly [TypeId]: TypeId;
+}
+
+export type UnnamedAnyWithProps = UnnamedTable<
+  Schema.Codec<any, any>,
+  GenericValidator,
+  GenericTableIndexes,
+  GenericTableSearchIndexes,
+  GenericTableVectorIndexes
+>;
+
+// -----------------------------------------------------------------------------
+// Type extractors
+// -----------------------------------------------------------------------------
+
+export type Name<TableDef extends AnyWithProps> = TableDef["tableName"] &
+  string;
+
+export type TableSchema<TableDef extends AnyWithProps> = TableDef["Fields"];
+
+export type TableValidator<TableDef extends AnyWithProps> =
+  TableDef["~TableValidator"];
+
+export type Indexes<TableDef extends AnyWithProps> = TableDef["indexes"];
+
+export type SearchIndexes<TableDef extends AnyWithProps> =
+  TableDef["searchIndexes"];
+
+export type VectorIndexes<TableDef extends AnyWithProps> =
+  TableDef["vectorIndexes"];
+
+export type Doc<TableDef extends AnyWithProps> = TableDef["Doc"];
+
+export type Fields<TableDef extends AnyWithProps> = TableDef["Fields"];
+
+export type WithName<
+  TableDef extends AnyWithProps,
+  Name_ extends string,
+> = TableDef extends { readonly tableName: Name_ } ? TableDef : never;
+
+export type TablesRecord<Tables extends AnyWithProps> = {
+  readonly [TableName_ in Name<Tables>]: WithName<Tables, TableName_>;
+};
+
+// -----------------------------------------------------------------------------
+// Construction
+// -----------------------------------------------------------------------------
+//
+// `make` only stores the user-supplied `lazyFields` callback alongside any
+// chained index metadata. Neither `Fields` nor `Doc` is constructed until
+// first access on a bound `Table`. Each chain step is O(1) (plain object
+// spread of the metadata records) and never invokes the callback. Binding
+// via `unnamed(tableName)` installs lazy memoised getters for `Fields` and
+// `Doc` via `Lazy.defineProperty`, so the first access materialises the
+// value and replaces the getter with a plain data property—second-and-
+// subsequent accesses are observably indistinguishable from a plain
+// property and avoid all function-call overhead.
+
+interface UnnamedState<
+  TableSchema_ extends Schema.Codec<any, any>,
+  Indexes_ extends GenericTableIndexes,
+  SearchIndexes_ extends GenericTableSearchIndexes,
+  VectorIndexes_ extends GenericTableVectorIndexes,
+> {
+  readonly lazyFields: () => TableSchema_;
+  readonly indexes: Indexes_;
+  readonly searchIndexes: SearchIndexes_;
+  readonly vectorIndexes: VectorIndexes_;
+}
+
+const makeBound = <
+  Name_ extends string,
+  TableSchema_ extends Schema.Codec<any, any>,
+  TableValidator_ extends Validator<any, any, any>,
+  Indexes_ extends GenericTableIndexes,
+  SearchIndexes_ extends GenericTableSearchIndexes,
+  VectorIndexes_ extends GenericTableVectorIndexes,
+>(
+  tableName: Name_,
+  state: UnnamedState<TableSchema_, Indexes_, SearchIndexes_, VectorIndexes_>,
+): Table<
+  Name_,
+  TableSchema_,
+  TableValidator_,
+  Indexes_,
+  SearchIndexes_,
+  VectorIndexes_
+> => {
+  const bound = {
+    [TypeId]: TypeId as TypeId,
+    tableName,
+    indexes: state.indexes,
+    searchIndexes: state.searchIndexes,
+    vectorIndexes: state.vectorIndexes,
+  } as Table<
+    Name_,
+    TableSchema_,
+    TableValidator_,
+    Indexes_,
+    SearchIndexes_,
+    VectorIndexes_
+  >;
+
+  Lazy.defineProperty(bound, "Fields", () => state.lazyFields());
+
+  Lazy.defineProperty(bound, "Doc", () =>
+    SystemFields.extendWithSystemFields(
+      tableName,
+      (bound as { Fields: TableSchema_ }).Fields,
+    ),
+  );
+
+  return bound;
+};
+
+const makeUnnamed = <
+  TableSchema_ extends Schema.Codec<any, any>,
+  TableValidator_ extends Validator<any, any, any>,
+  Indexes_ extends GenericTableIndexes,
+  SearchIndexes_ extends GenericTableSearchIndexes,
+  VectorIndexes_ extends GenericTableVectorIndexes,
+>(
+  state: UnnamedState<TableSchema_, Indexes_, SearchIndexes_, VectorIndexes_>,
+): UnnamedTable<
+  TableSchema_,
+  TableValidator_,
+  Indexes_,
+  SearchIndexes_,
+  VectorIndexes_
+> => {
+  type UnnamedTable_ = UnnamedTable<
+    TableSchema_,
+    TableValidator_,
+    Indexes_,
+    SearchIndexes_,
+    VectorIndexes_
+  >;
+
+  type UnnamedTableFunction<FunctionName extends keyof UnnamedTable_> =
+    UnnamedTable_[FunctionName];
+
+  const bind = <const Name_ extends string>(
+    tableName: Name_,
+  ): Table<
+    Name_,
+    TableSchema_,
+    TableValidator_,
+    Indexes_,
+    SearchIndexes_,
+    VectorIndexes_
+  > =>
+    makeBound<
+      Name_,
+      TableSchema_,
+      TableValidator_,
+      Indexes_,
+      SearchIndexes_,
+      VectorIndexes_
+    >(tableName, state);
+
+  const index: UnnamedTableFunction<"index"> = (name, fields) =>
+    makeUnnamed({
+      lazyFields: state.lazyFields,
+      indexes: {
+        ...state.indexes,
+        [name]: fields,
+      } as any,
+      searchIndexes: state.searchIndexes,
+      vectorIndexes: state.vectorIndexes,
+    });
+
+  const searchIndex: UnnamedTableFunction<"searchIndex"> = (
+    name,
+    indexConfig,
+  ) =>
+    makeUnnamed({
+      lazyFields: state.lazyFields,
+      indexes: state.indexes,
+      searchIndexes: {
+        ...state.searchIndexes,
+        [name]: indexConfig,
+      } as any,
+      vectorIndexes: state.vectorIndexes,
+    });
+
+  const vectorIndex: UnnamedTableFunction<"vectorIndex"> = (
+    name,
+    indexConfig,
+  ) =>
+    makeUnnamed({
+      lazyFields: state.lazyFields,
+      indexes: state.indexes,
+      searchIndexes: state.searchIndexes,
+      vectorIndexes: {
+        ...state.vectorIndexes,
+        [name]: indexConfig,
+      } as any,
+    });
+
+  return Object.assign(bind, {
+    [TypeId]: TypeId as TypeId,
+    indexes: state.indexes,
+    searchIndexes: state.searchIndexes,
+    vectorIndexes: state.vectorIndexes,
+    index,
+    searchIndex,
+    vectorIndex,
+  }) as UnnamedTable_;
+};
+
+export const make = <const TableSchema_ extends Schema.Codec<any, any>>(
+  lazyFields: () => TableSchema_,
+): UnnamedTable<TableSchema_, TableSchemaToTableValidator<TableSchema_>> => {
+  type TableValidator_ = TableSchemaToTableValidator<TableSchema_>;
+  type UnnamedTable_ = UnnamedTable<TableSchema_, TableValidator_>;
+
+  return makeUnnamed<TableSchema_, TableValidator_, {}, {}, {}>({
+    lazyFields,
+    indexes: {},
+    searchIndexes: {},
+    vectorIndexes: {},
+  }) as UnnamedTable_;
+};
+
+// Vendored types from convex-js, partially modified. Ideally we could use these directly. See https://github.com/get-convex/convex-js/pull/14
+
+/**
+ * Extract all of the index field paths within a Convex `Validator`.
+ *
+ * This is used when declaring table indexes.
+ *
+ * @public
+ */
+type ExtractFieldPaths<T extends Validator<any, any, any>> =
+  // Add in the system fields available in index definitions.
+  // This should be everything except for `_id` because thats added to indexes
+  // automatically.
+  T["fieldPaths"] | keyof ConvexSystemFields;