typescript: canonical naming for reducer and procedure.

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

@@ -101,12 +101,13 @@ function registerProcedure<
   Ret extends TypeBuilder<any, any>,
 >(
   ctx: SchemaInner,
-  name: string,
+  exportName: string,
   params: Params,
   ret: Ret,
-  fn: ProcedureFn<S, Params, Ret>
+  fn: ProcedureFn<S, Params, Ret>,
+  opts?: ProcedureOpts
 ) {
-  ctx.defineFunction(name);
+  ctx.defineFunction(exportName);
   const paramsType: ProductType = {
     elements: Object.entries(params).map(([n, c]) => ({
       name: n,
@@ -118,12 +119,21 @@ function registerProcedure<
   const returnType = ctx.registerTypesRecursively(ret).algebraicType;
 
   ctx.moduleDef.procedures.push({
-    sourceName: name,
+    sourceName: exportName,
     params: paramsType,
     returnType,
     visibility: FunctionVisibility.ClientCallable,
   });
 
+  if (opts?.name != null) {
+    ctx.moduleDef.explicitNames.entries.push({
+      tag: 'Function',
+      value: {
+        sourceName: exportName,
+        canonicalName: opts.name,
+      },
+    });
+  }
   const { typespace } = ctx;
 
   ctx.procedures.push({

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

@@ -31,15 +31,13 @@ export function makeReducerExport<
   fn: Reducer<any, any>,
   lifecycle?: Lifecycle
 ): ReducerExport<S, Params> {
-  const name = opts?.name;
-
   const reducerExport: ReducerExport<S, Params> = (...args) => fn(...args);
   reducerExport[exportContext] = ctx;
   reducerExport[registerExport] = (ctx, exportName) => {
-    registerReducer(ctx, name ?? exportName, params, fn, lifecycle);
+    registerReducer(ctx, exportName, params, fn, opts, lifecycle);
     ctx.functionExports.set(
       reducerExport as ReducerExport<any, any>,
-      name ?? exportName
+      exportName
     );
   };
 
@@ -56,27 +54,28 @@ export function makeReducerExport<
  */
 export function registerReducer(
   ctx: SchemaInner,
-  name: string,
+  exportName: string,
   params: RowObj | RowBuilder<RowObj>,
   fn: Reducer<any, any>,
+  opts?: ReducerOpts,
   lifecycle?: Lifecycle
 ): void {
-  ctx.defineFunction(name);
+  ctx.defineFunction(exportName);
 
   if (!(params instanceof RowBuilder)) {
     params = new RowBuilder(params);
   }
 
   if (params.typeName === undefined) {
-    params.typeName = toPascalCase(name);
+    params.typeName = toPascalCase(exportName);
   }
 
   const ref = ctx.registerTypesRecursively(params);
   const paramsType = ctx.resolveType(ref).value;
   const isLifecycle = lifecycle != null;
 
   ctx.moduleDef.reducers.push({
-    sourceName: name,
+    sourceName: exportName,
     params: paramsType,
     //ModuleDef validation code is responsible to mark private reducers
     visibility: FunctionVisibility.ClientCallable,
@@ -85,17 +84,27 @@ export function registerReducer(
     errReturnType: AlgebraicType.String,
   });
 
+  if (opts?.name != null) {
+    ctx.moduleDef.explicitNames.entries.push({
+      tag: 'Function',
+      value: {
+        sourceName: exportName,
+        canonicalName: opts.name,
+      },
+    });
+  }
+
   if (isLifecycle) {
     ctx.moduleDef.lifeCycleReducers.push({
       lifecycleSpec: lifecycle,
-      functionName: name,
+      functionName: exportName,
     });
   }
 
   // If the function isn't named (e.g. `function foobar() {}`), give it the same
   // name as the reducer so that it's clear what it is in in backtraces.
   if (!fn.name) {
-    Object.defineProperty(fn, 'name', { value: name, writable: false });
+    Object.defineProperty(fn, 'name', { value: exportName, writable: false });
   }
 
   ctx.reducers.push(fn);

crates/codegen/src/rust.rs

@@ -735,7 +735,7 @@ pub struct {cols_ix} {{"
             .iter()
             .find(|col| col.col_id == cols.as_singleton().expect("singleton column"))
             .unwrap();
-        let field_name = column.accessor_name.deref();
+        let field_name = column.accessor_name.deref().to_case(Case::Snake);
         let field_type = type_name(module, &column.ty_for_generate);
 
         writeln!(
@@ -763,7 +763,7 @@ impl __sdk::__query_builder::HasIxCols for {struct_name} {{
             .iter()
             .find(|col| col.col_id == cols.as_singleton().expect("singleton column"))
             .expect("singleton column");
-        let field_name = column.accessor_name.deref();
+        let field_name = column.accessor_name.deref().to_case(Case::Snake);
         let col_name = column.name.deref();
 
         writeln!(