@confect/server 9.0.0-next.5 → 9.0.0-next.6

package/src/Table.ts

@@ -1,3 +1,4 @@
+import * as Lazy from "@confect/core/Lazy";
 import * as SystemFields from "@confect/core/SystemFields";
 import {
   defineTable,
@@ -21,8 +22,26 @@ import {
 export const TypeId = "@confect/server/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, TypeId) && Predicate.hasProperty(u, "tableName");
+
+export const isUnnamedTable = (u: unknown): u is UnnamedAny =>
+  Predicate.hasProperty(u, TypeId) && !Predicate.hasProperty(u, "tableName");
+
+// -----------------------------------------------------------------------------
+// Bound Table
+// -----------------------------------------------------------------------------
 
 export interface Table<
   Name_ extends string,
@@ -34,18 +53,65 @@ export interface Table<
   VectorIndexes_ extends GenericTableVectorIndexes = {},
 > {
   readonly [TypeId]: TypeId;
+  readonly tableName: Name_;
   readonly tableDefinition: TableDefinition<
     TableValidator_,
     Indexes_,
     SearchIndexes_,
     VectorIndexes_
   >;
-
-  readonly name: Name_;
-
   readonly Fields: TableSchema_;
   readonly Doc: SystemFields.ExtendWithSystemFields<Name_, TableSchema_>;
+  readonly indexes: Indexes_;
+}
+
+export interface Any {
+  readonly [TypeId]: TypeId;
+  readonly tableName: string;
+}
+
+export type AnyWithProps = Table<
+  any,
+  Schema.Schema.AnyNoContext,
+  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. Neither the
+// field-schema nor the deploy-time `tableDefinition` is constructed at this
+// stage — the user-supplied `lazyFields` callback is just carried through.
+// 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.Schema.AnyNoContext,
+  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_;
 
   index<
@@ -55,8 +121,7 @@ export interface Table<
   >(
     name: IndexName,
     fields: [FirstFieldPath, ...RestFieldPaths],
-  ): Table<
-    Name_,
+  ): UnnamedTable<
     TableSchema_,
     TableValidator_,
     Expand<
@@ -77,8 +142,7 @@ export interface Table<
   >(
     name: IndexName,
     indexConfig: Expand<SearchIndexConfig<SearchField, FilterFields>>,
-  ): Table<
-    Name_,
+  ): UnnamedTable<
     TableSchema_,
     TableValidator_,
     Indexes_,
@@ -102,8 +166,7 @@ export interface Table<
   >(
     name: IndexName,
     indexConfig: Expand<VectorIndexConfig<VectorField, FilterFields>>,
-  ): Table<
-    Name_,
+  ): UnnamedTable<
     TableSchema_,
     TableValidator_,
     Indexes_,
@@ -122,12 +185,11 @@ export interface Table<
   >;
 }
 
-export interface Any {
+export interface UnnamedAny {
   readonly [TypeId]: TypeId;
 }
 
-export type AnyWithProps = Table<
-  any,
+export type UnnamedAnyWithProps = UnnamedTable<
   Schema.Schema.AnyNoContext,
   GenericValidator,
   GenericTableIndexes,
@@ -135,6 +197,10 @@ export type AnyWithProps = Table<
   GenericTableVectorIndexes
 >;
 
+// -----------------------------------------------------------------------------
+// Type extractors
+// -----------------------------------------------------------------------------
+
 export type Name<TableDef extends AnyWithProps> =
   TableDef extends Table<
     infer TableName,
@@ -234,162 +300,217 @@ export type Fields<TableDef extends AnyWithProps> =
 export type WithName<
   TableDef extends AnyWithProps,
   Name_ extends string,
-> = TableDef extends { readonly name: Name_ } ? TableDef : never;
+> = TableDef extends { readonly tableName: Name_ } ? TableDef : never;
 
 export type TablesRecord<Tables extends AnyWithProps> = {
   readonly [TableName_ in Name<Tables>]: WithName<Tables, TableName_>;
 };
 
-const Proto = {
-  [TypeId]: TypeId,
-
-  index<
-    IndexName extends string,
-    FirstFieldPath extends string,
-    RestFieldPaths extends string[],
-  >(
-    this: AnyWithProps,
-    name: IndexName,
-    fields: [FirstFieldPath, ...RestFieldPaths],
-  ) {
-    return makeProto({
-      name: this.name,
-      Fields: this.Fields,
-      Doc: this.Doc,
-      tableDefinition: this.tableDefinition.index(name, fields as any),
-      indexes: {
-        ...this.indexes,
-        [name]: fields,
-      },
-    });
-  },
-
-  searchIndex<IndexName extends string, SearchField extends string>(
-    this: AnyWithProps,
-    name: IndexName,
-    indexConfig: SearchIndexConfig<SearchField, any>,
-  ) {
-    return makeProto({
-      name: this.name,
-      Fields: this.Fields,
-      Doc: this.Doc,
-      tableDefinition: this.tableDefinition.searchIndex(name, indexConfig),
-      indexes: this.indexes,
-    });
-  },
-
-  vectorIndex<IndexName extends string, VectorField extends string>(
-    this: AnyWithProps,
-    name: IndexName,
-    indexConfig: {
-      vectorField: VectorField;
-      dimensions: number;
-      filterFields?: string[] | undefined;
-    },
-  ) {
-    return makeProto({
-      name: this.name,
-      Fields: this.Fields,
-      Doc: this.Doc,
-      tableDefinition: this.tableDefinition.vectorIndex(name, {
-        vectorField: indexConfig.vectorField,
-        dimensions: indexConfig.dimensions,
-        ...(indexConfig.filterFields
-          ? { filterFields: indexConfig.filterFields }
-          : {}),
-      }),
-      indexes: this.indexes,
-    });
-  },
-};
+// -----------------------------------------------------------------------------
+// Construction
+// -----------------------------------------------------------------------------
+//
+// `make` only stores the user-supplied `lazyFields` callback alongside any
+// chained index metadata. Neither `Fields` nor `Doc` nor `tableDefinition`
+// 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`, `Doc`, and `tableDefinition` 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.Schema.AnyNoContext,
+  Indexes_ extends GenericTableIndexes,
+  SearchIndexes_ extends GenericTableSearchIndexes,
+  VectorIndexes_ extends GenericTableVectorIndexes,
+> {
+  readonly lazyFields: () => TableSchema_;
+  readonly indexes: Indexes_;
+  readonly searchIndexes: SearchIndexes_;
+  readonly vectorIndexes: VectorIndexes_;
+}
 
-const makeProto = <
+const makeBound = <
   Name_ extends string,
   TableSchema_ extends Schema.Schema.AnyNoContext,
   TableValidator_ extends Validator<any, any, any>,
   Indexes_ extends GenericTableIndexes,
   SearchIndexes_ extends GenericTableSearchIndexes,
   VectorIndexes_ extends GenericTableVectorIndexes,
->({
-  name,
-  Fields,
-  Doc,
-  tableDefinition,
-  indexes,
-}: {
-  name: Name_;
-  Fields: TableSchema_;
-  Doc: SystemFields.ExtendWithSystemFields<Name_, TableSchema_>;
-  tableDefinition: TableDefinition<
-    TableValidator_,
-    Indexes_,
-    SearchIndexes_,
-    VectorIndexes_
-  >;
-  indexes: Indexes_;
-}): Table<
+>(
+  tableName: Name_,
+  state: UnnamedState<TableSchema_, Indexes_, SearchIndexes_, VectorIndexes_>,
+): Table<
   Name_,
   TableSchema_,
   TableValidator_,
   Indexes_,
   SearchIndexes_,
   VectorIndexes_
-> =>
-  Object.assign(Object.create(Proto), {
-    name,
-    Fields,
-    Doc,
-    tableDefinition,
-    indexes,
+> => {
+  const bound = {
+    [TypeId]: TypeId as TypeId,
+    tableName,
+    indexes: state.indexes,
+  } 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,
+    ),
+  );
+
+  Lazy.defineProperty(bound, "tableDefinition", () => {
+    const fields = (bound as { Fields: TableSchema_ }).Fields;
+    let definition: TableDefinition<any, any, any, any> = defineTable(
+      compileTableSchema(fields),
+    );
+    for (const [name, indexFields] of Object.entries(
+      state.indexes as Record<string, any>,
+    )) {
+      definition = definition.index(name, indexFields);
+    }
+    for (const [name, config] of Object.entries(
+      state.searchIndexes as Record<string, any>,
+    )) {
+      definition = definition.searchIndex(name, config);
+    }
+    for (const [name, config] of Object.entries(
+      state.vectorIndexes as Record<string, any>,
+    )) {
+      definition = definition.vectorIndex(name, config);
+    }
+    return definition;
   });
 
-/**
- * Create a table.
- */
-export const make = <
-  const Name_ extends string,
+  return bound;
+};
+
+const makeUnnamed = <
   TableSchema_ extends Schema.Schema.AnyNoContext,
-  TableValidator_ extends GenericValidator =
-    TableSchemaToTableValidator<TableSchema_>,
-  Indexes_ extends GenericTableIndexes = {},
-  SearchIndexes_ extends GenericTableSearchIndexes = {},
-  VectorIndexes_ extends GenericTableVectorIndexes = {},
+  TableValidator_ extends Validator<any, any, any>,
+  Indexes_ extends GenericTableIndexes,
+  SearchIndexes_ extends GenericTableSearchIndexes,
+  VectorIndexes_ extends GenericTableVectorIndexes,
 >(
-  name: Name_,
-  fields: TableSchema_,
-): Table<
-  Name_,
+  state: UnnamedState<TableSchema_, Indexes_, SearchIndexes_, VectorIndexes_>,
+): UnnamedTable<
   TableSchema_,
   TableValidator_,
   Indexes_,
   SearchIndexes_,
   VectorIndexes_
 > => {
-  const tableValidator = compileTableSchema(fields) as any;
-  const tableDefinition = defineTable(tableValidator) as any;
+  type UnnamedTable_ = UnnamedTable<
+    TableSchema_,
+    TableValidator_,
+    Indexes_,
+    SearchIndexes_,
+    VectorIndexes_
+  >;
 
-  return makeProto<
+  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,
-    Fields: fields,
-    Doc: SystemFields.extendWithSystemFields(name, fields),
-    tableDefinition,
-    indexes: {} as Indexes_,
-  });
+    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,
+    index,
+    searchIndex,
+    vectorIndex,
+  }) satisfies UnnamedTable_;
+};
+
+export const make = <const TableSchema_ extends Schema.Schema.AnyNoContext>(
+  lazyFields: () => TableSchema_,
+): UnnamedTable<TableSchema_, TableSchemaToTableValidator<TableSchema_>> => {
+  type TableValidator_ = TableSchemaToTableValidator<TableSchema_>;
+  type UnnamedTable_ = UnnamedTable<TableSchema_, TableValidator_>;
+
+  return makeUnnamed<TableSchema_, TableValidator_, {}, {}, {}>({
+    lazyFields,
+    indexes: {},
+    searchIndexes: {},
+    vectorIndexes: {},
+  }) satisfies UnnamedTable_;
 };
 
 // -----------------------------------------------------------------------------
 // System tables
 // -----------------------------------------------------------------------------
 
-export const scheduledFunctionsTable = make(
-  "_scheduled_functions",
+export const scheduledFunctionsTable = make(() =>
   Schema.Struct({
     name: Schema.String,
     args: Schema.Array(Schema.Any),
@@ -406,16 +527,15 @@ export const scheduledFunctionsTable = make(
       Schema.Struct({ kind: Schema.Literal("canceled") }),
     ),
   }),
-);
+)("_scheduled_functions");
 
-export const storageTable = make(
-  "_storage",
+export const storageTable = make(() =>
   Schema.Struct({
     sha256: Schema.String,
     size: Schema.Number,
     contentType: Schema.optionalWith(Schema.String, { exact: true }),
   }),
-);
+)("_storage");
 
 export const systemTables = {
   _scheduled_functions: scheduledFunctionsTable,

package/src/index.ts

@@ -1,6 +1,5 @@
 export * as ActionCtx from "./ActionCtx";
 export * as ActionRunner from "./ActionRunner";
-export * as Api from "./Api";
 export * as Auth from "./Auth";
 export * as BlobNotFoundError from "./BlobNotFoundError";
 export * as ConvexConfigProvider from "./ConvexConfigProvider";

package/dist/Api.d.ts

@@ -1,43 +0,0 @@
-import { AnyWithProps as AnyWithProps$1 } from "./DatabaseSchema.js";
-import { GenericSchema, SchemaDefinition } from "convex/server";
-import { RuntimeAndFunctionType } from "@confect/core";
-import * as GroupSpec from "@confect/core/GroupSpec";
-import * as Spec from "@confect/core/Spec";
-
-//#region src/Api.d.ts
-declare namespace Api_d_exports {
-  export { Any, AnyWithProps, AnyWithPropsWithRuntime, Api, GetSpec, Groups, Schema, TypeId, isApi, make, resolveGroupPathUnsafe };
-}
-declare const TypeId = "@confect/server/Api";
-type TypeId = typeof TypeId;
-declare const isApi: (u: unknown) => u is Any;
-interface Api<DatabaseSchema_ extends AnyWithProps$1, Spec_ extends Spec.AnyWithProps> {
-  readonly [TypeId]: TypeId;
-  readonly spec: Spec_;
-  readonly databaseSchema: DatabaseSchema_;
-  readonly convexSchemaDefinition: SchemaDefinition<GenericSchema, true>;
-}
-interface Any {
-  readonly [TypeId]: TypeId;
-}
-interface AnyWithProps extends Api<AnyWithProps$1, Spec.AnyWithProps> {}
-interface AnyWithPropsWithRuntime<Runtime extends RuntimeAndFunctionType.Runtime> extends Api<AnyWithProps$1, Spec.AnyWithPropsWithRuntime<Runtime>> {}
-type Schema<Api_ extends AnyWithProps> = Api_["databaseSchema"];
-type GetSpec<Api_ extends AnyWithProps> = Api_["spec"];
-type Groups<Api_ extends AnyWithProps> = Spec.Groups<Api_["spec"]>;
-declare const make: <DatabaseSchema_ extends AnyWithProps$1, Spec_ extends Spec.AnyWithProps>(databaseSchema: DatabaseSchema_, spec: Spec_) => Api<DatabaseSchema_, Spec_>;
-/**
- * Resolve the dot-path of `group` within `api.spec` by reading the immutable
- * `paths` mapping that codegen populated in `_generated/spec.ts`. Throws when
- * the spec is not registered, with a message pointing the caller at the
- * place to register it.
- *
- * The legacy identity-based tree walk (`packages/server/src/GroupPath.ts`)
- * was deleted in favor of this O(1) map lookup; both the registration
- * mechanism (`Spec.addPath`) and the lookup key are the same JS reference
- * thanks to ES module dedup between `_generated/spec.ts` and `*.impl.ts`.
- */
-declare const resolveGroupPathUnsafe: (api: AnyWithProps, group: GroupSpec.AnyWithProps) => string;
-//#endregion
-export { Any, AnyWithProps, AnyWithPropsWithRuntime, Api, Api_d_exports, GetSpec, Groups, Schema, TypeId, isApi, make, resolveGroupPathUnsafe };
-//# sourceMappingURL=Api.d.ts.map

package/dist/Api.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Api.d.ts","names":[],"sources":["../src/Api.ts"],"mappings":";;;;;;;;;;cAQa,MAAA;AAAA,KACD,MAAA,UAAgB,MAAA;AAAA,cAEf,KAAA,GAAS,CAAA,cAAa,CAAA,IAAK,GAAA;AAAA,UAEvB,GAAA,yBACS,cAAA,gBACV,IAAA,CAAK,YAAA;EAAA,UAET,MAAA,GAAS,MAAA;EAAA,SACV,IAAA,EAAM,KAAA;EAAA,SACN,cAAA,EAAgB,eAAA;EAAA,SAChB,sBAAA,EAAwB,gBAAA,CAAiB,aAAA;AAAA;AAAA,UAGnC,GAAA;EAAA,UACL,MAAA,GAAS,MAAA;AAAA;AAAA,UAGJ,YAAA,SAAqB,GAAA,CACpC,cAAA,EACA,IAAA,CAAK,YAAA;AAAA,UAGU,uBAAA,iBACC,sBAAA,CAAuB,OAAA,UAC/B,GAAA,CACR,cAAA,EACA,IAAA,CAAK,uBAAA,CAAwB,OAAA;AAAA,KAGnB,MAAA,cAAoB,YAAA,IAAgB,IAAA;AAAA,KAEpC,OAAA,cAAqB,YAAA,IAAgB,IAAA;AAAA,KAErC,MAAA,cAAoB,YAAA,IAAgB,IAAA,CAAK,MAAA,CAAO,IAAA;AAAA,cA0B/C,IAAA,2BACa,cAAA,gBACV,IAAA,CAAK,YAAA,EAEnB,cAAA,EAAgB,eAAA,EAChB,IAAA,EAAM,KAAA,KACL,GAAA,CAAI,eAAA,EAAiB,KAAA;;AAlExB;;;;;AAEA;;;;;cA6Ea,sBAAA,GACX,GAAA,EAAK,YAAA,EACL,KAAA,EAAO,SAAA,CAAU,YAAA"}

package/dist/Api.js

@@ -1,43 +0,0 @@
-import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { Predicate, Record, pipe } from "effect";
-import { defineSchema } from "convex/server";
-
-//#region src/Api.ts
-var Api_exports = /* @__PURE__ */ __exportAll({
-	TypeId: () => TypeId,
-	isApi: () => isApi,
-	make: () => make,
-	resolveGroupPathUnsafe: () => resolveGroupPathUnsafe
-});
-const TypeId = "@confect/server/Api";
-const isApi = (u) => Predicate.hasProperty(u, TypeId);
-const Proto = { [TypeId]: TypeId };
-const makeProto = ({ databaseSchema, spec }) => Object.assign(Object.create(Proto), {
-	databaseSchema,
-	spec,
-	convexSchemaDefinition: pipe(databaseSchema.tables, Record.map(({ tableDefinition }) => tableDefinition), defineSchema)
-});
-const make = (databaseSchema, spec) => makeProto({
-	databaseSchema,
-	spec
-});
-/**
-* Resolve the dot-path of `group` within `api.spec` by reading the immutable
-* `paths` mapping that codegen populated in `_generated/spec.ts`. Throws when
-* the spec is not registered, with a message pointing the caller at the
-* place to register it.
-*
-* The legacy identity-based tree walk (`packages/server/src/GroupPath.ts`)
-* was deleted in favor of this O(1) map lookup; both the registration
-* mechanism (`Spec.addPath`) and the lookup key are the same JS reference
-* thanks to ES module dedup between `_generated/spec.ts` and `*.impl.ts`.
-*/
-const resolveGroupPathUnsafe = (api, group) => {
-	const groupPath = api.spec.paths.get(group);
-	if (groupPath === void 0) throw new Error("GroupSpec has no registered path in this api's spec. Ensure the spec is added via Spec.addPath in _generated/spec.ts (or, in tests, call .addPath(spec, 'dot.path') on the Spec you pass to Api.make).");
-	return groupPath;
-};
-
-//#endregion
-export { Api_exports, TypeId, isApi, make, resolveGroupPathUnsafe };
-//# sourceMappingURL=Api.js.map

package/dist/Api.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Api.js","names":["defineConvexSchema"],"sources":["../src/Api.ts"],"sourcesContent":["import type { RuntimeAndFunctionType } from \"@confect/core\";\nimport type * as GroupSpec from \"@confect/core/GroupSpec\";\nimport type * as Spec from \"@confect/core/Spec\";\nimport type { GenericSchema, SchemaDefinition } from \"convex/server\";\nimport { defineSchema as defineConvexSchema } from \"convex/server\";\nimport { pipe, Predicate, Record } from \"effect\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\n\nexport const TypeId = \"@confect/server/Api\";\nexport type TypeId = typeof TypeId;\n\nexport const isApi = (u: unknown): u is Any => Predicate.hasProperty(u, TypeId);\n\nexport interface Api<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Spec_ extends Spec.AnyWithProps,\n> {\n  readonly [TypeId]: TypeId;\n  readonly spec: Spec_;\n  readonly databaseSchema: DatabaseSchema_;\n  readonly convexSchemaDefinition: SchemaDefinition<GenericSchema, true>;\n}\n\nexport interface Any {\n  readonly [TypeId]: TypeId;\n}\n\nexport interface AnyWithProps extends Api<\n  DatabaseSchema.AnyWithProps,\n  Spec.AnyWithProps\n> {}\n\nexport interface AnyWithPropsWithRuntime<\n  Runtime extends RuntimeAndFunctionType.Runtime,\n> extends Api<\n  DatabaseSchema.AnyWithProps,\n  Spec.AnyWithPropsWithRuntime<Runtime>\n> {}\n\nexport type Schema<Api_ extends AnyWithProps> = Api_[\"databaseSchema\"];\n\nexport type GetSpec<Api_ extends AnyWithProps> = Api_[\"spec\"];\n\nexport type Groups<Api_ extends AnyWithProps> = Spec.Groups<Api_[\"spec\"]>;\n\nconst Proto = {\n  [TypeId]: TypeId,\n};\n\nconst makeProto = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Spec_ extends Spec.AnyWithProps,\n>({\n  databaseSchema,\n  spec,\n}: {\n  databaseSchema: DatabaseSchema.AnyWithProps;\n  spec: Spec_;\n}): Api<DatabaseSchema_, Spec_> =>\n  Object.assign(Object.create(Proto), {\n    databaseSchema,\n    spec,\n    convexSchemaDefinition: pipe(\n      databaseSchema.tables,\n      Record.map(({ tableDefinition }) => tableDefinition),\n      defineConvexSchema,\n    ),\n  });\n\nexport const make = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Spec_ extends Spec.AnyWithProps,\n>(\n  databaseSchema: DatabaseSchema_,\n  spec: Spec_,\n): Api<DatabaseSchema_, Spec_> => makeProto({ databaseSchema, spec });\n\n/**\n * Resolve the dot-path of `group` within `api.spec` by reading the immutable\n * `paths` mapping that codegen populated in `_generated/spec.ts`. Throws when\n * the spec is not registered, with a message pointing the caller at the\n * place to register it.\n *\n * The legacy identity-based tree walk (`packages/server/src/GroupPath.ts`)\n * was deleted in favor of this O(1) map lookup; both the registration\n * mechanism (`Spec.addPath`) and the lookup key are the same JS reference\n * thanks to ES module dedup between `_generated/spec.ts` and `*.impl.ts`.\n */\nexport const resolveGroupPathUnsafe = (\n  api: AnyWithProps,\n  group: GroupSpec.AnyWithProps,\n): string => {\n  const groupPath = api.spec.paths.get(group);\n  if (groupPath === undefined) {\n    throw new Error(\n      \"GroupSpec has no registered path in this api's spec. \" +\n        \"Ensure the spec is added via Spec.addPath in _generated/spec.ts \" +\n        \"(or, in tests, call .addPath(spec, 'dot.path') on the Spec you pass to Api.make).\",\n    );\n  }\n  return groupPath;\n};\n"],"mappings":";;;;;;;;;;;AAQA,MAAa,SAAS;AAGtB,MAAa,SAAS,MAAyB,UAAU,YAAY,GAAG,OAAO;AAkC/E,MAAM,QAAQ,GACX,SAAS,QACX;AAED,MAAM,aAGJ,EACA,gBACA,WAKA,OAAO,OAAO,OAAO,OAAO,MAAM,EAAE;CAClC;CACA;CACA,wBAAwB,KACtB,eAAe,QACf,OAAO,KAAK,EAAE,sBAAsB,gBAAgB,EACpDA,aACD;CACF,CAAC;AAEJ,MAAa,QAIX,gBACA,SACgC,UAAU;CAAE;CAAgB;CAAM,CAAC;;;;;;;;;;;;AAarE,MAAa,0BACX,KACA,UACW;CACX,MAAM,YAAY,IAAI,KAAK,MAAM,IAAI,MAAM;AAC3C,KAAI,cAAc,OAChB,OAAM,IAAI,MACR,yMAGD;AAEH,QAAO"}