rake-db 2.3.10 → 2.3.13

package/src/pull/structureToAst.ts

@@ -6,6 +6,7 @@ import {
   ForeignKeyOptions,
   instantiateColumn,
   singleQuote,
+  TableData,
 } from 'pqb';
 import { getForeignKeyName, getIndexName } from '../migration/migrationUtils';
 
@@ -23,28 +24,27 @@ const fkeyActionMap = {
   d: 'SET DEFAULT',
 };
 
+type Data = {
+  schemas: string[];
+  tables: DbStructure.Table[];
+  columns: DbStructure.Column[];
+  primaryKeys: DbStructure.PrimaryKey[];
+  indexes: DbStructure.Index[];
+  foreignKeys: DbStructure.ForeignKey[];
+  extensions: DbStructure.Extension[];
+};
+
+type PendingTables = Record<
+  string,
+  { table: DbStructure.Table; dependsOn: Set<string> }
+>;
+
 export const structureToAst = async (db: DbStructure): Promise<RakeDbAst[]> => {
   const ast: RakeDbAst[] = [];
 
-  const [
-    schemas,
-    tables,
-    allColumns,
-    allPrimaryKeys,
-    allIndexes,
-    allForeignKeys,
-    extensions,
-  ] = await Promise.all([
-    db.getSchemas(),
-    db.getTables(),
-    db.getColumns(),
-    db.getPrimaryKeys(),
-    db.getIndexes(),
-    db.getForeignKeys(),
-    db.getExtensions(),
-  ]);
+  const data = await getData(db);
 
-  for (const name of schemas) {
+  for (const name of data.schemas) {
     if (name === 'public') continue;
 
     ast.push({
@@ -54,154 +54,63 @@ export const structureToAst = async (db: DbStructure): Promise<RakeDbAst[]> => {
     });
   }
 
-  for (const table of tables) {
-    const { schemaName, name } = table;
-
-    if (name === 'schemaMigrations') continue;
+  const pendingTables: PendingTables = {};
+  for (const table of data.tables) {
+    const key = `${table.schemaName}.${table.name}`;
+    const dependsOn = new Set<string>();
 
-    const belongsToTable = makeBelongsToTable(schemaName, name);
+    for (const fk of data.foreignKeys) {
+      if (fk.schemaName !== table.schemaName || fk.tableName !== table.name)
+        continue;
 
-    const columns = allColumns.filter(belongsToTable);
-    const primaryKey = allPrimaryKeys.find(belongsToTable);
-    const tableIndexes = allIndexes.filter(belongsToTable);
-    const tableForeignKeys = allForeignKeys.filter(belongsToTable);
-
-    const shape: ColumnsShape = {};
-    for (let item of columns) {
-      const isSerial = getIsSerial(item);
-      if (isSerial) {
-        item = { ...item, default: undefined };
+      const otherKey = `${fk.foreignTableSchemaName}.${fk.foreignTableName}`;
+      if (otherKey !== key) {
+        dependsOn.add(otherKey);
       }
+    }
 
-      const klass = columnsByType[getColumnType(item, isSerial)];
-      if (!klass) {
-        throw new Error(`Column type \`${item.type}\` is not supported`);
-      }
+    pendingTables[key] = { table, dependsOn };
+  }
 
-      let column = instantiateColumn(klass, item);
+  for (const key in pendingTables) {
+    const { table, dependsOn } = pendingTables[key];
+    if (!dependsOn.size) {
+      pushTableAst(ast, data, table, pendingTables);
+    }
+  }
 
-      if (
-        primaryKey?.columnNames.length === 1 &&
-        primaryKey?.columnNames[0] === item.name
-      ) {
-        column = column.primaryKey();
-      }
+  const outerFKeys: [DbStructure.ForeignKey, DbStructure.Table][] = [];
 
-      const indexes = tableIndexes.filter(
-        (it) =>
-          it.columns.length === 1 &&
-          'column' in it.columns[0] &&
-          it.columns[0].column === item.name,
-      );
-      for (const index of indexes) {
-        const options = index.columns[0];
-        column = column.index({
-          collate: options.collate,
-          opclass: options.opclass,
-          order: options.order,
-          name:
-            index.name !== getIndexName(name, index.columns)
-              ? index.name
-              : undefined,
-          using: index.using === 'btree' ? undefined : index.using,
-          unique: index.isUnique,
-          include: index.include,
-          with: index.with,
-          tablespace: index.tablespace,
-          where: index.where,
-        });
-      }
+  for (const key in pendingTables) {
+    const innerFKeys: DbStructure.ForeignKey[] = [];
+    const { table } = pendingTables[key];
 
-      const foreignKeys = tableForeignKeys.filter(
-        (it) => it.columnNames.length === 1 && it.columnNames[0] === item.name,
-      );
-      for (const foreignKey of foreignKeys) {
-        column = column.foreignKey(
-          foreignKey.foreignTableName,
-          foreignKey.foreignColumnNames[0],
-          {
-            name:
-              foreignKey.name &&
-              foreignKey.name !==
-                getForeignKeyName(name, foreignKey.columnNames)
-                ? foreignKey.name
-                : undefined,
-            match: matchMap[foreignKey.match],
-            onUpdate: fkeyActionMap[foreignKey.onUpdate],
-            onDelete: fkeyActionMap[foreignKey.onDelete],
-          } as ForeignKeyOptions,
-        );
-      }
+    for (const fkey of data.foreignKeys) {
+      if (fkey.schemaName !== table.schemaName || fkey.tableName !== table.name)
+        continue;
 
-      shape[item.name] = column;
+      const otherKey = `${fkey.foreignTableSchemaName}.${fkey.foreignTableName}`;
+      if (!pendingTables[otherKey] || otherKey === key) {
+        innerFKeys.push(fkey);
+      } else {
+        outerFKeys.push([fkey, table]);
+      }
     }
 
+    pushTableAst(ast, data, table, pendingTables, innerFKeys);
+  }
+
+  for (const [fkey, table] of outerFKeys) {
     ast.push({
-      type: 'table',
+      ...foreignKeyToAst(fkey),
+      type: 'foreignKey',
       action: 'create',
-      schema: schemaName === 'public' ? undefined : schemaName,
-      comment: table.comment,
-      name: name,
-      shape,
-      noPrimaryKey: primaryKey ? 'error' : 'ignore',
-      primaryKey:
-        primaryKey && primaryKey.columnNames.length > 1
-          ? {
-              columns: primaryKey.columnNames,
-              options:
-                primaryKey.name === `${name}_pkey`
-                  ? undefined
-                  : { name: primaryKey.name },
-            }
-          : undefined,
-      indexes: tableIndexes
-        .filter(
-          (index) =>
-            index.columns.length > 1 ||
-            index.columns.some((it) => 'expression' in it),
-        )
-        .map((index) => ({
-          columns: index.columns.map((it) => ({
-            ...('column' in it
-              ? { column: it.column }
-              : { expression: it.expression }),
-            collate: it.collate,
-            opclass: it.opclass,
-            order: it.order,
-          })),
-          options: {
-            name:
-              index.name !== getIndexName(name, index.columns)
-                ? index.name
-                : undefined,
-            using: index.using === 'btree' ? undefined : index.using,
-            unique: index.isUnique,
-            include: index.include,
-            with: index.with,
-            tablespace: index.tablespace,
-            where: index.where,
-          },
-        })),
-      foreignKeys: tableForeignKeys
-        .filter((it) => it.columnNames.length > 1)
-        .map((it) => ({
-          columns: it.columnNames,
-          fnOrTable: it.foreignTableName,
-          foreignColumns: it.foreignColumnNames,
-          options: {
-            name:
-              it.name && it.name !== getForeignKeyName(name, it.columnNames)
-                ? it.name
-                : undefined,
-            match: matchMap[it.match],
-            onUpdate: fkeyActionMap[it.onUpdate],
-            onDelete: fkeyActionMap[it.onDelete],
-          } as ForeignKeyOptions,
-        })),
+      tableSchema: table.schemaName === 'public' ? undefined : table.schemaName,
+      tableName: fkey.tableName,
     });
   }
 
-  for (const it of extensions) {
+  for (const it of data.extensions) {
     ast.push({
       type: 'extension',
       action: 'create',
@@ -214,6 +123,36 @@ export const structureToAst = async (db: DbStructure): Promise<RakeDbAst[]> => {
   return ast;
 };
 
+const getData = async (db: DbStructure): Promise<Data> => {
+  const [
+    schemas,
+    tables,
+    columns,
+    primaryKeys,
+    indexes,
+    foreignKeys,
+    extensions,
+  ] = await Promise.all([
+    db.getSchemas(),
+    db.getTables(),
+    db.getColumns(),
+    db.getPrimaryKeys(),
+    db.getIndexes(),
+    db.getForeignKeys(),
+    db.getExtensions(),
+  ]);
+
+  return {
+    schemas,
+    tables,
+    columns,
+    primaryKeys,
+    indexes,
+    foreignKeys,
+    extensions,
+  };
+};
+
 const makeBelongsToTable =
   (schema: string | undefined, table: string) =>
   (item: { schemaName: string; tableName: string }) =>
@@ -250,3 +189,170 @@ const getColumnType = (item: DbStructure.Column, isSerial: boolean) => {
 
   return item.type;
 };
+
+const pushTableAst = (
+  ast: RakeDbAst[],
+  data: Data,
+  table: DbStructure.Table,
+  pendingTables: PendingTables,
+  innerFKeys = data.foreignKeys,
+) => {
+  const { schemaName, name } = table;
+
+  const key = `${schemaName}.${table.name}`;
+  delete pendingTables[key];
+
+  if (name === 'schemaMigrations') return;
+
+  const belongsToTable = makeBelongsToTable(schemaName, name);
+
+  const columns = data.columns.filter(belongsToTable);
+  const primaryKey = data.primaryKeys.find(belongsToTable);
+  const tableIndexes = data.indexes.filter(belongsToTable);
+  const tableForeignKeys = innerFKeys.filter(belongsToTable);
+
+  const shape: ColumnsShape = {};
+  for (let item of columns) {
+    const isSerial = getIsSerial(item);
+    if (isSerial) {
+      item = { ...item, default: undefined };
+    }
+
+    const klass = columnsByType[getColumnType(item, isSerial)];
+    if (!klass) {
+      throw new Error(`Column type \`${item.type}\` is not supported`);
+    }
+
+    let column = instantiateColumn(klass, item);
+
+    if (
+      primaryKey?.columnNames.length === 1 &&
+      primaryKey?.columnNames[0] === item.name
+    ) {
+      column = column.primaryKey();
+    }
+
+    const indexes = tableIndexes.filter(
+      (it) =>
+        it.columns.length === 1 &&
+        'column' in it.columns[0] &&
+        it.columns[0].column === item.name,
+    );
+    for (const index of indexes) {
+      const options = index.columns[0];
+      column = column.index({
+        collate: options.collate,
+        opclass: options.opclass,
+        order: options.order,
+        name:
+          index.name !== getIndexName(name, index.columns)
+            ? index.name
+            : undefined,
+        using: index.using === 'btree' ? undefined : index.using,
+        unique: index.isUnique,
+        include: index.include,
+        with: index.with,
+        tablespace: index.tablespace,
+        where: index.where,
+      });
+    }
+
+    const foreignKeys = tableForeignKeys.filter(
+      (it) => it.columnNames.length === 1 && it.columnNames[0] === item.name,
+    );
+    for (const foreignKey of foreignKeys) {
+      column = column.foreignKey(
+        foreignKey.foreignTableName,
+        foreignKey.foreignColumnNames[0],
+        {
+          name:
+            foreignKey.name &&
+            foreignKey.name !== getForeignKeyName(name, foreignKey.columnNames)
+              ? foreignKey.name
+              : undefined,
+          match: matchMap[foreignKey.match],
+          onUpdate: fkeyActionMap[foreignKey.onUpdate],
+          onDelete: fkeyActionMap[foreignKey.onDelete],
+        } as ForeignKeyOptions,
+      );
+    }
+
+    shape[item.name] = column;
+  }
+
+  ast.push({
+    type: 'table',
+    action: 'create',
+    schema: schemaName === 'public' ? undefined : schemaName,
+    comment: table.comment,
+    name: name,
+    shape,
+    noPrimaryKey: primaryKey ? 'error' : 'ignore',
+    primaryKey:
+      primaryKey && primaryKey.columnNames.length > 1
+        ? {
+            columns: primaryKey.columnNames,
+            options:
+              primaryKey.name === `${name}_pkey`
+                ? undefined
+                : { name: primaryKey.name },
+          }
+        : undefined,
+    indexes: tableIndexes
+      .filter(
+        (index) =>
+          index.columns.length > 1 ||
+          index.columns.some((it) => 'expression' in it),
+      )
+      .map((index) => ({
+        columns: index.columns.map((it) => ({
+          ...('column' in it
+            ? { column: it.column }
+            : { expression: it.expression }),
+          collate: it.collate,
+          opclass: it.opclass,
+          order: it.order,
+        })),
+        options: {
+          name:
+            index.name !== getIndexName(name, index.columns)
+              ? index.name
+              : undefined,
+          using: index.using === 'btree' ? undefined : index.using,
+          unique: index.isUnique,
+          include: index.include,
+          with: index.with,
+          tablespace: index.tablespace,
+          where: index.where,
+        },
+      })),
+    foreignKeys: tableForeignKeys
+      .filter((it) => it.columnNames.length > 1)
+      .map(foreignKeyToAst),
+  });
+
+  for (const otherKey in pendingTables) {
+    const item = pendingTables[otherKey];
+    if (item.dependsOn.delete(key) && item.dependsOn.size === 0) {
+      pushTableAst(ast, data, item.table, pendingTables);
+    }
+  }
+};
+
+const foreignKeyToAst = (
+  fkey: DbStructure.ForeignKey,
+): TableData.ForeignKey => ({
+  columns: fkey.columnNames,
+  fnOrTable: fkey.foreignTableName,
+  foreignColumns: fkey.foreignColumnNames,
+  options: {
+    name:
+      fkey.name &&
+      fkey.name !== getForeignKeyName(fkey.tableName, fkey.columnNames)
+        ? fkey.name
+        : undefined,
+    match: matchMap[fkey.match],
+    onUpdate: fkeyActionMap[fkey.onUpdate],
+    onDelete: fkeyActionMap[fkey.onDelete],
+  } as ForeignKeyOptions,
+});