add type constraints for various sql fragment functions

packages/lesswrong/lib/make_voteable.ts

@@ -32,9 +32,9 @@ export const apolloCacheVoteablePossibleTypes = () => {
   }
 }
 
-const currentUserVoteResolver = (
-  resolver: SqlResolverJoin["resolver"],
-): SqlResolver => ({field, currentUserField, join}) => join({
+const currentUserVoteResolver = <N extends CollectionNameString>(
+  resolver: SqlResolverJoin<'Votes'>["resolver"],
+): SqlResolver<N> => ({field, currentUserField, join}) => join({
   table: "Votes",
   type: "left",
   on: {

packages/lesswrong/lib/sql/ProjectionContext.ts

@@ -160,10 +160,11 @@ class ProjectionContext<N extends CollectionNameString = CollectionNameString> {
   }
 
   absoluteField(name: string, jsonifyStarSelector = true) {
-    if (name !== "*") {
-      name = `"${name}"`;
+    let absoluteName: string = name;
+    if (absoluteName !== "*") {
+      absoluteName = `"${name}"`;
     }
-    const absoluteField = `"${this.primaryPrefix}".${name}`;
+    const absoluteField = `"${this.primaryPrefix}".${absoluteName}`;
     return name.indexOf("*") > -1 && jsonifyStarSelector
       ? `ROW_TO_JSON(${absoluteField})`
       : absoluteField;
@@ -217,9 +218,9 @@ class ProjectionContext<N extends CollectionNameString = CollectionNameString> {
     }
   }
 
-  addJoin({resolver, ...joinBase}: SqlResolverJoin) {
+  addJoin<J extends CollectionNameString>({resolver, ...joinBase}: SqlResolverJoin<J>) {
     const spec = this.getJoinSpec(joinBase);
-    const subField = (name: string) => `"${spec.prefix}"."${name}"`;
+    const subField = (name: FieldName<J>) => `"${spec.prefix}"."${name}"`;
     return resolver(subField);
   }
 
@@ -245,7 +246,7 @@ class ProjectionContext<N extends CollectionNameString = CollectionNameString> {
    * Get the arguments to pass to `sqlResolver` functions defined in
    * collection schemas.
    */
-  getSqlResolverArgs(): SqlResolverArgs {
+  getSqlResolverArgs(): SqlResolverArgs<N> {
     return {
       field: this.absoluteField.bind(this),
       currentUserField: this.currentUserField.bind(this),
@@ -261,7 +262,7 @@ class ProjectionContext<N extends CollectionNameString = CollectionNameString> {
       : randomId(5, this.randIntCallback);
   }
 
-  private getJoinSpec({table, type, on}: SqlJoinBase): SqlJoinSpec {
+  private getJoinSpec<J extends CollectionNameString>({table, type, on}: SqlJoinBase<J>): SqlJoinSpec {
     for (const join of this.joins) {
       if (
         join.table === table &&
@@ -279,7 +280,7 @@ class ProjectionContext<N extends CollectionNameString = CollectionNameString> {
   private compileJoin({table, type = "inner", on, prefix}: SqlJoinSpec): string {
     const selectors: string[] = [];
     for (const field in on) {
-      selectors.push(`"${prefix}"."${field}" = ${on[field]}`);
+      selectors.push(`"${prefix}"."${field}" = ${on[(field as keyof typeof on)]}`);
     }
     const selector = selectors.join(" AND ");
     return `${type.toUpperCase()} JOIN "${table}" "${prefix}" ON ${selector}`;

packages/lesswrong/lib/sql/tests/testHelpers.ts

@@ -152,7 +152,7 @@ export const TestCollection4 = {
       graphqlArguments: "testCollection2Id: String",
       resolver: async () => null,
       sqlResolver: ({resolverArg, join}) => join({
-        table: "TestCollection2",
+        table: "TestCollection2" as CollectionNameString,
         type: "left",
         on: {
           _id: resolverArg("testCollection2Id"),

packages/lesswrong/lib/types/collectionTypes.ts

@@ -217,6 +217,8 @@ interface HasIdType {
   _id: string
 }
 
+type HasIdCollectionNames = Exclude<Extract<ObjectsByCollectionName[CollectionNameString], HasIdType>['__collectionName'], undefined>;
+
 // Common base type for everything with a userId field
 interface HasUserIdType {
   userId: string | null

packages/lesswrong/lib/types/schemaTypes.ts

@@ -23,31 +23,33 @@ interface CollectionFieldPermissions {
 
 type FormInputType = 'text' | 'number' | 'url' | 'email' | 'textarea' | 'checkbox' | 'checkboxgroup' | 'radiogroup' | 'select' | 'datetime' | 'date' | keyof ComponentTypes;
 
-type SqlFieldFunction = (fieldName: string) => string;
+type FieldName<N extends CollectionNameString> = (keyof ObjectsByCollectionName[N] & string) | '*';
 
-type SqlJoinBase = {
-  table: string,
+type SqlFieldFunction<N extends CollectionNameString> = (fieldName: FieldName<N>) => string;
+
+type SqlJoinBase<N extends CollectionNameString> = {
+  table: N,
   type?: "inner" | "full" | "left" | "right",
-  on: Record<string, string>,
+  on: Partial<Record<FieldName<N>, string>>,
 }
 
-type SqlResolverJoin = SqlJoinBase & {
-  resolver: (field: SqlFieldFunction) => string,
+type SqlResolverJoin<N extends CollectionNameString> = SqlJoinBase<N> & {
+  resolver: (field: SqlFieldFunction<N>) => string,
 };
 
-type SqlJoinSpec = SqlJoinBase & {
+type SqlJoinSpec<N extends CollectionNameString = CollectionNameString> = SqlJoinBase<N> & {
   prefix: string,
 };
 
-type SqlResolverArgs = {
-  field: SqlFieldFunction,
-  currentUserField: SqlFieldFunction,
-  join: (args: SqlResolverJoin) => string,
+type SqlResolverArgs<N extends CollectionNameString> = {
+  field: SqlFieldFunction<N>,
+  currentUserField: SqlFieldFunction<'Users'>,
+  join: <J extends CollectionNameString>(args: SqlResolverJoin<J>) => string,
   arg: (value: unknown) => string,
   resolverArg: (name: string) => string,
 }
 
-type SqlResolver = (args: SqlResolverArgs) => string;
+type SqlResolver<N extends CollectionNameString> = (args: SqlResolverArgs<N>) => string;
 
 interface CollectionFieldSpecification<N extends CollectionNameString> extends CollectionFieldPermissions {
   type?: any,
@@ -65,7 +67,7 @@ interface CollectionFieldSpecification<N extends CollectionNameString> extends C
     addOriginalField?: boolean,
     arguments?: string|null,
     resolver: (root: ObjectsByCollectionName[N], args: any, context: ResolverContext, info?: any)=>any,
-    sqlResolver?: SqlResolver,
+    sqlResolver?: SqlResolver<N>,
   },
   blackbox?: boolean,
   denormalized?: boolean,

packages/lesswrong/lib/utils/schemaUtils.ts

@@ -146,11 +146,11 @@ export const foreignKeyField = <CollectionName extends CollectionNameString>({
         nullable,
       }),
       ...(autoJoin ? {
-        sqlResolver: ({field, join}: SqlResolverArgs) => join({
+        sqlResolver: ({field, join}: SqlResolverArgs<CollectionName>) => join<HasIdCollectionNames>({
           table: collectionName,
           type: nullable ? "left" : "inner",
           on: {
-            _id: field(idFieldName),
+            _id: field(idFieldName as FieldName<CollectionName>),
           },
           resolver: (foreignField) => foreignField("*"),
         })
@@ -207,7 +207,7 @@ export const simplSchemaToGraphQLtype = (type: any): string|null => {
 
 interface ResolverOnlyFieldArgs<N extends CollectionNameString> extends CollectionFieldSpecification<N> {
   resolver: (doc: ObjectsByCollectionName[N], args: any, context: ResolverContext) => any,
-  sqlResolver?: SqlResolver,
+  sqlResolver?: SqlResolver<N>,
   graphQLtype?: string|GraphQLScalarType|null,
   graphqlArguments?: string|null,
 }

packages/lesswrong/unitTests/sql/ProjectionContext.tests.ts

@@ -34,20 +34,20 @@ describe("ProjectionContext", () => {
   });
   it("detects duplicate joins", () => {
     const context = new ProjectionContext(TestCollection);
-    const join1: SqlResolverJoin = {
-      table: "TestTable2",
+    const join1: SqlResolverJoin<CollectionNameString> = {
+      table: "TestTable2" as CollectionNameString,
       type: "left",
       on: {
         _id: "_id",
       },
       resolver: () => "",
     };
-    const join2: SqlResolverJoin = {
-      table: "TestTable2",
+    const join2: SqlResolverJoin<CollectionNameString> = {
+      table: "TestTable2" as CollectionNameString,
       type: "left",
       on: {
         userId: "userId",
-      },
+      } as AnyBecauseHard,
       resolver: () => "",
     };
     expect(context.getJoins()).toHaveLength(0);