fix: do not require table name mapping

Author: gajus

src/types.js

@@ -13,7 +13,7 @@ export type ColumnType = {|
   +dataType: string,
   +isMaterializedView: boolean,
   +isNullable: boolean,
-  +mappedTableName: string,
+  +mappedTableName?: string,
   +name: string,
   +tableName: string
 |};

src/utilities/generateDataLoaderFactory.js

@@ -46,10 +46,18 @@ const createLoaderByIdsUsingJoiningTableDeclaration = (
 
 // eslint-disable-next-line complexity
 export default (
-  columns: $ReadOnlyArray<ColumnType>,
+  unnormalisedColumns: $ReadOnlyArray<ColumnType>,
   indexes: $ReadOnlyArray<IndexType>,
   dataTypeMap: DataTypeMapType,
 ): string => {
+  const columns = unnormalisedColumns
+    .map((column) => {
+      return {
+        ...column,
+        mappedTableName: column.mappedTableName || column.tableName
+      };
+    });
+
   if (columns.length === 0) {
     throw new UnexpectedStateError('Must know multiple columns.');
   }

src/utilities/generateFlowTypeDocument.js

@@ -25,10 +25,18 @@ const generateFlowTypeDeclarationBody = (columns: $ReadOnlyArray<ColumnType>, da
   return propertyDeclarations.join('\n');
 };
 
-export default (columns: $ReadOnlyArray<ColumnType>, dataTypeMap: DataTypeMapType = {}): string => {
+export default (unnormalisedColumns: $ReadOnlyArray<ColumnType>, dataTypeMap: DataTypeMapType = {}): string => {
+  const columns = unnormalisedColumns
+    .map((column) => {
+      return {
+        ...column,
+        mappedTableName: column.mappedTableName || column.tableName
+      };
+    });
+
   const tableNames = columns
     .map((column) => {
-      return column.mappedTableName;
+      return column.mappedTableName || column.tableName;
     })
     .filter((tableName, index, self) => {
       return self.indexOf(tableName) === index;

test/postloader/utilities/generateDataLoaderFactory.js

@@ -7,6 +7,69 @@ import {
 import generateDataLoaderFactory from '../../../src/utilities/generateDataLoaderFactory';
 
 test('creates a loader for unique indexes', (t) => {
+  const actual = trim(generateDataLoaderFactory(
+    [
+      {
+        comment: '',
+        dataType: 'text',
+        isMaterializedView: false,
+        isNullable: false,
+        name: 'bar',
+        tableName: 'foo'
+      }
+    ],
+    [
+      {
+        columnNames: [
+          'bar'
+        ],
+        indexIsUnique: true,
+        indexName: 'quux',
+        tableName: 'foo'
+      }
+    ],
+    {}
+  ));
+
+  const expected = trim(`
+// @flow
+
+import {
+  getByIds,
+  getByIdsUsingJoiningTable
+} from 'postloader';
+import DataLoader from 'dataloader';
+import type {
+  DatabaseConnectionType
+} from 'slonik';
+
+type FooRecordType = {|
+  +bar: string
+|};
+
+export type {
+  FooRecordType
+};
+
+export type LoadersType = {|
+  +FooByBarLoader: DataLoader<string, FooRecordType>
+|};
+
+export const createLoaders = (connection: DatabaseConnectionType, NotFoundError: Class<Error>): LoadersType => {
+  const FooByBarLoader = new DataLoader((ids) => {
+    return getByIds(connection, 'foo', ids, 'bar', '"bar"', false, NotFoundError);
+  });
+
+  return {
+    FooByBarLoader
+  };
+};`);
+
+  // eslint-disable-next-line ava/prefer-power-assert
+  t.is(actual, expected);
+});
+
+test('creates a loader for unique indexes (uses mappedTableName when available)', (t) => {
   const actual = trim(generateDataLoaderFactory(
     [
       {