Fix ModuleDef deserialization

Author: coolreader18

Cargo.lock

@@ -126,7 +126,7 @@ declare global {
 
 const { freeze } = Object;
 
-const _syscalls = {
+const _syscalls = () => ({
   table_id_from_name,
   index_id_from_name,
   datastore_table_row_count,
@@ -143,15 +143,9 @@ const _syscalls = {
   console_timer_start,
   console_timer_end,
   identity,
-};
+});
 
-const sys = freeze(
-  Object.fromEntries(
-    Object.entries(_syscalls).map(([name, syscall]) => {
-      return [name, wrapSyscall(syscall)];
-    })
-  ) as typeof _syscalls
-);
+const sys = {} as ReturnType<typeof _syscalls>;
 
 globalThis.__call_reducer__ = function __call_reducer__(
   reducer_id,
@@ -177,6 +171,11 @@ globalThis.__call_reducer__ = function __call_reducer__(
 };
 
 globalThis.__describe_module__ = function __describe_module__() {
+  for (const [name, syscall] of Object.entries(_syscalls())) {
+    (sys as any)[name] = wrapSyscall(syscall);
+  }
+  freeze(sys);
+
   return RawModuleDef.V9(MODULE_DEF);
 };
 

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

@@ -27,7 +27,7 @@ type ColList = ColId[];
 type TableSchema<
   TableName extends string,
   Row extends Record<string, ColumnBuilder<any, any, any>>,
-  Idx extends readonly PendingIndex<keyof Row & string>[],
+  Idx extends readonly IndexOpts<keyof Row & string>[],
 > = {
   /**
    * The TypeScript phantom type. This is not stored at runtime,
@@ -70,30 +70,27 @@ type CoerceColumn<
 type TableOpts<Row extends RowObj> = {
   name: string;
   public?: boolean;
-  indexes?: PendingIndex<keyof Row & string>[]; // declarative multi‑column indexes
+  indexes?: IndexOpts<keyof Row & string>[]; // declarative multi‑column indexes
   scheduled?: string; // reducer name for cron‑like tables
 };
 
 /**
  * Index helper type used *inside* {@link table} to enforce that only
  * existing column names are referenced.
  */
-type PendingIndex<AllowedCol extends string> = {
+type IndexOpts<AllowedCol extends string> = {
   name?: string;
-  accessor_name?: string;
-  is_unique?: boolean;
-  algorithm:
-    | { tag: 'BTree'; value: { columns: readonly AllowedCol[] } }
-    // | { tag: 'Hash'; value: { columns: readonly AllowedCol[] } }
-    | { tag: 'Direct'; value: { column: AllowedCol } };
-};
+} & (
+  | { algorithm: 'btree'; columns: readonly AllowedCol[] }
+  | { algorithm: 'direct'; column: AllowedCol }
+);
 
 type OptsIndices<Opts extends TableOpts<any>> = Opts extends {
   indexes: infer Ixs extends NonNullable<any[]>;
 }
   ? Ixs
   : CoerceArray<[]>;
-type CoerceArray<X extends PendingIndex<any>[]> = X;
+type CoerceArray<X extends IndexOpts<any>[]> = X;
 
 /**
  * Defines a database table with schema and options
@@ -181,9 +178,9 @@ export function table<Row extends RowObj, const Opts extends TableOpts<Row>>(
     if (meta.isAutoIncrement) {
       sequences.push({
         name: undefined,
-        start: 0n,
-        minValue: 0n,
-        maxValue: 0n,
+        start: undefined,
+        minValue: undefined,
+        maxValue: undefined,
         column: colIds.get(name)!,
         increment: 1n,
       });
@@ -194,22 +191,20 @@ export function table<Row extends RowObj, const Opts extends TableOpts<Row>>(
   }
 
   /** 3. convert explicit multi‑column indexes coming from options.indexes */
-  for (const pending of userIndexes ?? []) {
-    const converted: RawIndexDefV9 = {
-      name: pending.name,
-      accessorName: pending.accessor_name,
-      algorithm:
-        pending.algorithm.tag === 'Direct'
-          ? {
-              tag: 'Direct',
-              value: colIds.get(pending.algorithm.value.column)!,
-            }
-          : {
-              tag: pending.algorithm.tag,
-              value: pending.algorithm.value.columns.map(c => colIds.get(c)!),
-            },
-    };
-    indexes.push(converted);
+  for (const indexOpts of userIndexes ?? []) {
+    let algorithm: RawIndexAlgorithm;
+    switch (indexOpts.algorithm) {
+      case 'btree':
+        algorithm = {
+          tag: 'BTree',
+          value: indexOpts.columns.map(c => colIds.get(c)!),
+        };
+        break;
+      case 'direct':
+        algorithm = { tag: 'Direct', value: colIds.get(indexOpts.column)! };
+        break;
+    }
+    indexes.push({ name: undefined, accessorName: indexOpts.name, algorithm });
   }
 
   // Temporarily set the type ref to 0. We will set this later
@@ -493,7 +488,7 @@ export function reducer<
 export type UntypedTableDef = {
   name: string;
   columns: Record<string, ColumnBuilder<any, any, ColumnMetadata>>;
-  indexes: PendingIndex<any>[];
+  indexes: IndexOpts<any>[];
 };
 
 export type RowType<TableDef extends UntypedTableDef> = InferTypeOfRow<
@@ -540,7 +535,7 @@ export type TableIndexes<TableDef extends UntypedTableDef> = {
   [I in TableDef['indexes'][number] as I['name'] & {}]: {
     name: I['name'];
     unique: AllUnique<TableDef, IndexColumns<I>>;
-    algorithm: Lowercase<I['algorithm']['tag']>;
+    algorithm: Lowercase<I['algorithm']>;
     columns: IndexColumns<I>;
   };
 };
@@ -556,12 +551,10 @@ type AllUnique<
   ? true
   : false;
 
-type IndexColumns<I extends PendingIndex<any>> = I['algorithm'] extends {
-  value: { columns: infer C extends string[] };
-}
-  ? C
-  : I['algorithm'] extends { value: { column: infer C extends string } }
-    ? [C]
+type IndexColumns<I extends IndexOpts<any>> = I extends { columns: string[] }
+  ? I['columns']
+  : I extends { column: string }
+    ? [I['column']]
     : never;
 
 type CollapseTuple<A extends any[]> = A extends [infer T] ? T : A;

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

@@ -1526,7 +1526,7 @@ export class SumColumnBuilder<
  *
  * @see {@link TypeBuilder}
  */
-const t = {
+export const t = {
   /**
    * Creates a new `Bool` {@link AlgebraicType} to be used in table definitions
    * Represented as `boolean` in TypeScript.

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

@@ -120,6 +120,7 @@ export default defineConfig([
     platform: 'neutral', // flip to 'node' if you actually rely on Node builtins
     treeshake: 'smallest',
     external: ['undici'],
+    noExternal: ['base64-js'],
     outExtension,
     esbuildOptions: commonEsbuildTweaks(),
   },

crates/bindings-typescript/tsup.config.ts

@@ -49,6 +49,7 @@ bytemuck.workspace = true
 bytes.workspace = true
 bytestring.workspace = true
 chrono.workspace = true
+convert_case.workspace = true
 crossbeam-channel.workspace = true
 crossbeam-queue.workspace = true
 derive_more.workspace = true

crates/core/Cargo.toml

@@ -3,6 +3,7 @@
 use super::error::{exception_already_thrown, ExcResult, ExceptionThrown, ExceptionValue, Throwable, TypeError};
 use super::from_value::{cast, FromValue};
 use super::string_const::{TAG, VALUE};
+use convert_case::{Case, Casing};
 use core::fmt;
 use core::iter::{repeat_n, RepeatN};
 use core::marker::PhantomData;
@@ -132,6 +133,10 @@ impl<'de, 'this, 'scope: 'de> de::Deserializer<'de> for Deserializer<'this, 'sco
     deserialize_primitive!(deserialize_f32, f32);
 
     fn deserialize_product<V: ProductVisitor<'de>>(self, visitor: V) -> Result<V::Output, Self::Error> {
+        if visitor.product_len() == 0 && self.input.is_null_or_undefined() {
+            return visitor.visit_seq_product(de::UnitAccess::new());
+        }
+
         let object = cast!(
             self.common.scope,
             self.input,
@@ -150,6 +155,15 @@ impl<'de, 'this, 'scope: 'de> de::Deserializer<'de> for Deserializer<'this, 'sco
 
     fn deserialize_sum<V: SumVisitor<'de>>(self, visitor: V) -> Result<V::Output, Self::Error> {
         let scope = &*self.common.scope;
+
+        if visitor.is_option() {
+            return if self.input.is_null_or_undefined() {
+                visitor.visit_sum(de::NoneAccess::new())
+            } else {
+                visitor.visit_sum(de::SomeAccess::new(self))
+            };
+        }
+
         let sum_name = visitor.sum_name().unwrap_or("<unknown>");
 
         // We expect a canonical representation of a sum value in JS to be
@@ -230,8 +244,8 @@ pub(super) fn intern_field_name<'scope>(
     index: usize,
 ) -> Local<'scope, Name> {
     let field = match field {
-        Some(field) => Cow::Borrowed(field),
-        None => Cow::Owned(format!("{index}")),
+        Some(field) => field.to_case(Case::Camel),
+        None => format!("{index}"),
     };
     v8_interned_string(scope, &field).into()
 }

crates/core/src/host/v8/de.rs

@@ -719,12 +719,7 @@ impl<'de, E: Error> SumAccess<'de> for NoneAccess<E> {
 impl<'de, E: Error> VariantAccess<'de> for NoneAccess<E> {
     type Error = E;
     fn deserialize_seed<T: DeserializeSeed<'de>>(self, seed: T) -> Result<T::Output, Self::Error> {
-        use crate::algebraic_value::de::*;
-        seed.deserialize(ValueDeserializer::new(crate::AlgebraicValue::unit()))
-            .map_err(|err| match err {
-                ValueDeserializeError::MismatchedType => E::custom("mismatched type"),
-                ValueDeserializeError::Custom(err) => E::custom(err),
-            })
+        seed.deserialize(UnitAccess::new())
     }
 }
 
@@ -753,3 +748,126 @@ impl<'de, D: Deserializer<'de>> VariantAccess<'de> for SomeAccess<D> {
         seed.deserialize(self.0)
     }
 }
+
+pub struct UnitAccess<E>(PhantomData<E>);
+
+impl<E: Error> UnitAccess<E> {
+    /// Returns a new [`UnitAccess`].
+    pub fn new() -> Self {
+        Self(PhantomData)
+    }
+}
+
+impl<E: Error> Default for UnitAccess<E> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<'de, E: Error> SeqProductAccess<'de> for UnitAccess<E> {
+    type Error = E;
+
+    fn next_element_seed<T: DeserializeSeed<'de>>(&mut self, _seed: T) -> Result<Option<T::Output>, Self::Error> {
+        Ok(None)
+    }
+}
+
+impl<'de, E: Error> NamedProductAccess<'de> for UnitAccess<E> {
+    type Error = E;
+
+    fn get_field_ident<V: FieldNameVisitor<'de>>(&mut self, _visitor: V) -> Result<Option<V::Output>, Self::Error> {
+        Ok(None)
+    }
+
+    fn get_field_value_seed<T: DeserializeSeed<'de>>(&mut self, _seed: T) -> Result<T::Output, Self::Error> {
+        unreachable!()
+    }
+}
+
+impl<'de, E: Error> Deserializer<'de> for UnitAccess<E> {
+    type Error = E;
+
+    fn deserialize_product<V: ProductVisitor<'de>>(self, visitor: V) -> Result<V::Output, Self::Error> {
+        visitor.visit_seq_product(self)
+    }
+
+    fn deserialize_sum<V: SumVisitor<'de>>(self, _visitor: V) -> Result<V::Output, Self::Error> {
+        Err(E::custom("invalid type"))
+    }
+
+    fn deserialize_bool(self) -> Result<bool, Self::Error> {
+        Err(E::custom("invalid type"))
+    }
+
+    fn deserialize_u8(self) -> Result<u8, Self::Error> {
+        Err(E::custom("invalid type"))
+    }
+
+    fn deserialize_u16(self) -> Result<u16, Self::Error> {
+        Err(E::custom("invalid type"))
+    }
+
+    fn deserialize_u32(self) -> Result<u32, Self::Error> {
+        Err(E::custom("invalid type"))
+    }
+
+    fn deserialize_u64(self) -> Result<u64, Self::Error> {
+        Err(E::custom("invalid type"))
+    }
+
+    fn deserialize_u128(self) -> Result<u128, Self::Error> {
+        Err(E::custom("invalid type"))
+    }
+
+    fn deserialize_u256(self) -> Result<u256, Self::Error> {
+        Err(E::custom("invalid type"))
+    }
+
+    fn deserialize_i8(self) -> Result<i8, Self::Error> {
+        Err(E::custom("invalid type"))
+    }
+
+    fn deserialize_i16(self) -> Result<i16, Self::Error> {
+        Err(E::custom("invalid type"))
+    }
+
+    fn deserialize_i32(self) -> Result<i32, Self::Error> {
+        Err(E::custom("invalid type"))
+    }
+
+    fn deserialize_i64(self) -> Result<i64, Self::Error> {
+        Err(E::custom("invalid type"))
+    }
+
+    fn deserialize_i128(self) -> Result<i128, Self::Error> {
+        Err(E::custom("invalid type"))
+    }
+
+    fn deserialize_i256(self) -> Result<i256, Self::Error> {
+        Err(E::custom("invalid type"))
+    }
+
+    fn deserialize_f32(self) -> Result<f32, Self::Error> {
+        Err(E::custom("invalid type"))
+    }
+
+    fn deserialize_f64(self) -> Result<f64, Self::Error> {
+        Err(E::custom("invalid type"))
+    }
+
+    fn deserialize_str<V: SliceVisitor<'de, str>>(self, _visitor: V) -> Result<V::Output, Self::Error> {
+        Err(E::custom("invalid type"))
+    }
+
+    fn deserialize_bytes<V: SliceVisitor<'de, [u8]>>(self, _visitor: V) -> Result<V::Output, Self::Error> {
+        Err(E::custom("invalid type"))
+    }
+
+    fn deserialize_array_seed<V: ArrayVisitor<'de, T::Output>, T: DeserializeSeed<'de> + Clone>(
+        self,
+        _visitor: V,
+        _seed: T,
+    ) -> Result<V::Output, Self::Error> {
+        Err(E::custom("invalid type"))
+    }
+}