Fix for multi-column indexes in typescript modules (#3589)

# Description of Changes

This updates a bunch of types to make sure we generate the right
functions for indexes with multiple columns. Most of the changes are
making the array of column names readonly.

This also has a fix for `AllUnique`, because we were treating composite
indexes as unique when the first field had a unique index. FWIW, we
should also make sure that the range scanning functions still exist in
that case, but I didn't try to add that here.


# API and ABI breaking changes

Any change to these types is probably technically a breaking API change,
but no one should consider these types stable.

# Expected complexity level and risk

1.5. I'm still not super confident with some of these types, but this
shouldn't change any runtime behavior.

# Testing

I added some uses of indexes in `schema.test-d.ts`, so `pnpm run
build:types` would throw errors if this were broken.

Author: jsdt

crates/bindings-typescript/src/server/constraints.ts

@@ -6,14 +6,15 @@ import type { ColumnMetadata } from './type_builders';
  */
 export type AllUnique<
   TableDef extends UntypedTableDef,
-  Columns extends Array<keyof TableDef['columns']>,
-> = {
-  [i in keyof Columns]: ColumnIsUnique<
-    TableDef['columns'][Columns[i]]['columnMetadata']
-  >;
-} extends true[]
-  ? true
-  : false;
+  Columns extends ReadonlyArray<keyof TableDef['columns']>,
+> = Columns extends readonly [
+  infer Head extends keyof TableDef['columns'],
+  ...infer Tail extends ReadonlyArray<keyof TableDef['columns']>,
+]
+  ? ColumnIsUnique<TableDef['columns'][Head]['columnMetadata']> extends true
+    ? AllUnique<TableDef, Tail>
+    : false
+  : true;
 
 /**
  * A helper type to determine if a column is unique based on its metadata.

crates/bindings-typescript/src/server/indexes.ts

@@ -18,22 +18,22 @@ export type IndexOpts<AllowedCol extends string> = {
 /**
  * An untyped representation of an index definition.
  */
-type UntypedIndex<AllowedCol extends string> = {
+export type UntypedIndex<AllowedCol extends string> = {
   name: string;
   unique: boolean;
   algorithm: 'btree' | 'direct';
-  columns: AllowedCol[];
+  columns: readonly AllowedCol[];
 };
 
 /**
  * A helper type to extract the column names from an index definition.
  */
 export type IndexColumns<I extends IndexOpts<any>> = I extends {
-  columns: string[];
+  columns: readonly string[];
 }
-  ? I['columns']
-  : I extends { column: string }
-    ? [I['column']]
+  ? readonly [...I['columns']]
+  : I extends { column: infer Name extends string }
+    ? readonly [Name]
     : never;
 
 /**
@@ -95,9 +95,18 @@ export type IndexVal<
 /**
  * A helper type to extract the types of the columns that make up an index.
  */
-type _IndexVal<TableDef extends UntypedTableDef, Columns extends string[]> = {
-  [i in keyof Columns]: TableDef['columns'][Columns[i]]['typeBuilder']['type'];
-};
+type _IndexVal<
+  TableDef extends UntypedTableDef,
+  Columns extends readonly string[],
+> = Columns extends readonly [
+  infer Head extends string,
+  ...infer Tail extends readonly string[],
+]
+  ? [
+      TableDef['columns'][Head]['typeBuilder']['type'],
+      ..._IndexVal<TableDef, Tail>,
+    ]
+  : [];
 
 /**
  * A helper type to define the bounds for scanning an index.
@@ -115,7 +124,9 @@ export type IndexScanRangeBounds<
  * It supports omitting trailing columns if the index is multi-column.
  * This version only allows omitting the array if the index is single-column to avoid ambiguity.
  */
-type _IndexScanRangeBounds<Columns extends any[]> = Columns extends [infer Term]
+type _IndexScanRangeBounds<Columns extends readonly any[]> = Columns extends [
+  infer Term,
+]
   ? Term | Range<Term>
   : _IndexScanRangeBoundsCase<Columns>;
 
@@ -124,12 +135,10 @@ type _IndexScanRangeBounds<Columns extends any[]> = Columns extends [infer Term]
  * This type allows for specifying exact values or ranges for each column in the index.
  * It supports omitting trailing columns if the index is multi-column.
  */
-type _IndexScanRangeBoundsCase<Columns extends any[]> = Columns extends [
-  ...infer Prefix,
-  infer Term,
-]
-  ? [...Prefix, Term | Range<Term>] | _IndexScanRangeBounds<Prefix>
-  : never;
+type _IndexScanRangeBoundsCase<Columns extends readonly any[]> =
+  Columns extends [...infer Prefix, infer Term]
+    ? readonly [...Prefix, Term | Range<Term>] | _IndexScanRangeBounds<Prefix>
+    : never;
 
 /**
  * A helper type representing a column index definition.
@@ -141,7 +150,7 @@ export type ColumnIndex<
   {
     name: Name;
     unique: ColumnIsUnique<M>;
-    columns: [Name];
+    columns: readonly [Name];
     algorithm: 'btree' | 'direct';
   } & (M extends {
     indexType: infer I extends NonNullable<IndexTypes>;

crates/bindings-typescript/src/server/schema.test-d.ts

@@ -0,0 +1,48 @@
+import { schema } from './schema';
+import { table } from './table';
+import t from './type_builders';
+
+const person = table(
+  {
+    name: 'person',
+    indexes: [
+      {
+        name: 'id_name_idx',
+        algorithm: 'btree',
+        columns: ['id', 'name'] as const,
+      },
+      {
+        name: 'id_name2_idx',
+        algorithm: 'btree',
+        columns: ['id', 'name2'] as const,
+      },
+      {
+        name: 'name_idx',
+        algorithm: 'btree',
+        columns: ['name'] as const,
+      },
+    ],
+  },
+  {
+    id: t.u32().primaryKey(),
+    name: t.string(),
+    name2: t.string().unique(),
+    married: t.bool(),
+    id2: t.identity(),
+    age: t.u32(),
+    age2: t.u16(),
+  }
+);
+
+const spacetimedb = schema(person);
+
+spacetimedb.init(ctx => {
+  ctx.db.person.id_name_idx.filter(1);
+  ctx.db.person.id_name_idx.filter([1, 'aname']);
+  // ctx.db.person.id_name2_idx.find
+
+  // @ts-expect-error id2 is not indexed, so this should not exist at all.
+  const _id2 = ctx.db.person.id2;
+
+  ctx.db.person.id.find(2);
+});

crates/bindings-typescript/src/server/table.ts

@@ -54,26 +54,49 @@ type CoerceArray<X extends IndexOpts<any>[]> = X;
 export type UntypedTableDef = {
   name: string;
   columns: Record<string, ColumnBuilder<any, any, ColumnMetadata<any>>>;
-  indexes: IndexOpts<any>[];
+  indexes: readonly IndexOpts<any>[];
 };
 
 /**
  * A type representing the indexes defined on a table.
  */
 export type TableIndexes<TableDef extends UntypedTableDef> = {
-  [k in keyof TableDef['columns'] & string]: ColumnIndex<
-    k,
-    TableDef['columns'][k]['columnMetadata']
-  >;
+  [K in keyof TableDef['columns'] & string as ColumnIndex<
+    K,
+    TableDef['columns'][K]['columnMetadata']
+  > extends never
+    ? never
+    : K]: ColumnIndex<K, TableDef['columns'][K]['columnMetadata']>;
 } & {
-  [I in TableDef['indexes'][number] as I['name'] & {}]: {
-    name: I['name'];
-    unique: AllUnique<TableDef, IndexColumns<I>>;
-    algorithm: Lowercase<I['algorithm']>;
-    columns: IndexColumns<I>;
-  };
+  [I in TableDef['indexes'][number] as I['name'] & {}]: TableIndexFromDef<
+    TableDef,
+    I
+  >;
 };
 
+type TableIndexFromDef<
+  TableDef extends UntypedTableDef,
+  I extends IndexOpts<keyof TableDef['columns'] & string>,
+> =
+  NormalizeIndexColumns<TableDef, I> extends infer Cols extends ReadonlyArray<
+    keyof TableDef['columns'] & string
+  >
+    ? {
+        name: I['name'];
+        unique: AllUnique<TableDef, Cols>;
+        algorithm: Lowercase<I['algorithm']>;
+        columns: Cols;
+      }
+    : never;
+
+type NormalizeIndexColumns<
+  TableDef extends UntypedTableDef,
+  I extends IndexOpts<keyof TableDef['columns'] & string>,
+> =
+  IndexColumns<I> extends ReadonlyArray<keyof TableDef['columns'] & string>
+    ? IndexColumns<I>
+    : never;
+
 /**
  * Options for configuring a database table.
  * - `name`: The name of the table.