rake-db 2.3.10 → 2.3.12

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # rake-db
 
+## 2.3.12
+
+### Patch Changes
+
+- Handle table ordering by foreign key when pulling db
+- Updated dependencies
+  - pqb@0.9.7
+
+## 2.3.11
+
+### Patch Changes
+
+- Add generating extension to db pull
+
 ## 2.3.10
 
 ### Patch Changes

package/dist/index.d.ts

@@ -311,7 +311,7 @@ declare class MigrationBase {
 }
 declare const runCodeUpdater: (migration: MigrationBase, ast: RakeDbAst) => Promise<void> | undefined;
 
-declare type RakeDbAst = RakeDbAst.Table | RakeDbAst.ChangeTable | RakeDbAst.RenameTable | RakeDbAst.Schema | RakeDbAst.Extension;
+declare type RakeDbAst = RakeDbAst.Table | RakeDbAst.ChangeTable | RakeDbAst.RenameTable | RakeDbAst.Schema | RakeDbAst.Extension | RakeDbAst.ForeignKey;
 declare namespace RakeDbAst {
     type Table = {
         type: 'table';
@@ -387,6 +387,12 @@ declare namespace RakeDbAst {
         ifExists?: boolean;
         ifNotExists?: boolean;
     };
+    type ForeignKey = {
+        type: 'foreignKey';
+        action: 'create';
+        tableSchema?: string;
+        tableName: string;
+    } & TableData.ForeignKey;
 }
 
 declare type Db = DbResult<typeof columnTypes>;

package/dist/index.js

@@ -1030,10 +1030,10 @@ class MigrationBase {
     return createSchema$1(this, !this.up, schemaName);
   }
   createExtension(name, options = {}) {
-    return createExtension(this, this.up, name, options);
+    return createExtension$1(this, this.up, name, options);
   }
   dropExtension(name, options = {}) {
-    return createExtension(this, !this.up, name, options);
+    return createExtension$1(this, !this.up, name, options);
   }
   async tableExists(tableName) {
     return queryExists(this, {
@@ -1095,7 +1095,7 @@ const createSchema$1 = async (migration, up, name) => {
   );
   await runCodeUpdater(migration, ast);
 };
-const createExtension = async (migration, up, name, options) => {
+const createExtension$1 = async (migration, up, name, options) => {
   const ast = __spreadValues$2({
     type: "extension",
     action: up ? "create" : "drop",
@@ -1718,24 +1718,8 @@ const fkeyActionMap = {
 };
 const structureToAst = async (db) => {
   const ast = [];
-  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()
-  ]);
-  for (const name of schemas) {
+  const data = await getData(db);
+  for (const name of data.schemas) {
     if (name === "public")
       continue;
     ast.push({
@@ -1744,108 +1728,51 @@ const structureToAst = async (db) => {
       name
     });
   }
-  for (const table of tables) {
-    const { schemaName, name } = table;
-    if (name === "schemaMigrations")
-      continue;
-    const belongsToTable = makeBelongsToTable(schemaName, name);
-    const columns = allColumns.filter(belongsToTable);
-    const primaryKey = allPrimaryKeys.find(belongsToTable);
-    const tableIndexes = allIndexes.filter(belongsToTable);
-    const tableForeignKeys = allForeignKeys.filter(belongsToTable);
-    const shape = {};
-    for (let item of columns) {
-      const isSerial = getIsSerial(item);
-      if (isSerial) {
-        item = __spreadProps(__spreadValues({}, item), { default: void 0 });
-      }
-      const klass = pqb.columnsByType[getColumnType(item, isSerial)];
-      if (!klass) {
-        throw new Error(`Column type \`${item.type}\` is not supported`);
+  const pendingTables = {};
+  for (const table of data.tables) {
+    const key = `${table.schemaName}.${table.name}`;
+    const dependsOn = /* @__PURE__ */ new Set();
+    for (const fk of data.foreignKeys) {
+      if (fk.schemaName !== table.schemaName || fk.tableName !== table.name)
+        continue;
+      const otherKey = `${fk.foreignTableSchemaName}.${fk.foreignTableName}`;
+      if (otherKey !== key) {
+        dependsOn.add(otherKey);
       }
-      let column = pqb.instantiateColumn(klass, item);
-      if ((primaryKey == null ? void 0 : primaryKey.columnNames.length) === 1 && (primaryKey == null ? void 0 : 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 : void 0,
-          using: index.using === "btree" ? void 0 : 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 : void 0,
-            match: matchMap[foreignKey.match],
-            onUpdate: fkeyActionMap[foreignKey.onUpdate],
-            onDelete: fkeyActionMap[foreignKey.onDelete]
-          }
-        );
+    }
+    pendingTables[key] = { table, dependsOn };
+  }
+  for (const key in pendingTables) {
+    const { table, dependsOn } = pendingTables[key];
+    if (!dependsOn.size) {
+      pushTableAst(ast, data, table, pendingTables);
+    }
+  }
+  const outerFKeys = [];
+  for (const key in pendingTables) {
+    const innerFKeys = [];
+    const { table } = pendingTables[key];
+    for (const fkey of data.foreignKeys) {
+      if (fkey.schemaName !== table.schemaName || fkey.tableName !== table.name)
+        continue;
+      const otherKey = `${fkey.foreignTableSchemaName}.${fkey.foreignTableName}`;
+      if (!pendingTables[otherKey] || otherKey === key) {
+        innerFKeys.push(fkey);
+      } else {
+        outerFKeys.push([fkey, table]);
       }
-      shape[item.name] = column;
     }
-    ast.push({
-      type: "table",
+    pushTableAst(ast, data, table, pendingTables, innerFKeys);
+  }
+  for (const [fkey, table] of outerFKeys) {
+    ast.push(__spreadProps(__spreadValues({}, foreignKeyToAst(fkey)), {
+      type: "foreignKey",
       action: "create",
-      schema: schemaName === "public" ? void 0 : schemaName,
-      comment: table.comment,
-      name,
-      shape,
-      noPrimaryKey: primaryKey ? "error" : "ignore",
-      primaryKey: primaryKey && primaryKey.columnNames.length > 1 ? {
-        columns: primaryKey.columnNames,
-        options: primaryKey.name === `${name}_pkey` ? void 0 : { name: primaryKey.name }
-      } : void 0,
-      indexes: tableIndexes.filter(
-        (index) => index.columns.length > 1 || index.columns.some((it) => "expression" in it)
-      ).map((index) => ({
-        columns: index.columns.map((it) => __spreadProps(__spreadValues({}, "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 : void 0,
-          using: index.using === "btree" ? void 0 : 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 : void 0,
-          match: matchMap[it.match],
-          onUpdate: fkeyActionMap[it.onUpdate],
-          onDelete: fkeyActionMap[it.onDelete]
-        }
-      }))
-    });
+      tableSchema: table.schemaName === "public" ? void 0 : table.schemaName,
+      tableName: fkey.tableName
+    }));
   }
-  for (const it of extensions) {
+  for (const it of data.extensions) {
     ast.push({
       type: "extension",
       action: "create",
@@ -1856,6 +1783,34 @@ const structureToAst = async (db) => {
   }
   return ast;
 };
+const getData = async (db) => {
+  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, table) => (item) => item.schemaName === schema && item.tableName === table;
 const getIsSerial = (item) => {
   if (item.type === "int2" || item.type === "int4" || item.type === "int8") {
@@ -1873,16 +1828,134 @@ const getColumnType = (item, isSerial) => {
   }
   return item.type;
 };
+const pushTableAst = (ast, data, table, 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 = {};
+  for (let item of columns) {
+    const isSerial = getIsSerial(item);
+    if (isSerial) {
+      item = __spreadProps(__spreadValues({}, item), { default: void 0 });
+    }
+    const klass = pqb.columnsByType[getColumnType(item, isSerial)];
+    if (!klass) {
+      throw new Error(`Column type \`${item.type}\` is not supported`);
+    }
+    let column = pqb.instantiateColumn(klass, item);
+    if ((primaryKey == null ? void 0 : primaryKey.columnNames.length) === 1 && (primaryKey == null ? void 0 : 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 : void 0,
+        using: index.using === "btree" ? void 0 : 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 : void 0,
+          match: matchMap[foreignKey.match],
+          onUpdate: fkeyActionMap[foreignKey.onUpdate],
+          onDelete: fkeyActionMap[foreignKey.onDelete]
+        }
+      );
+    }
+    shape[item.name] = column;
+  }
+  ast.push({
+    type: "table",
+    action: "create",
+    schema: schemaName === "public" ? void 0 : schemaName,
+    comment: table.comment,
+    name,
+    shape,
+    noPrimaryKey: primaryKey ? "error" : "ignore",
+    primaryKey: primaryKey && primaryKey.columnNames.length > 1 ? {
+      columns: primaryKey.columnNames,
+      options: primaryKey.name === `${name}_pkey` ? void 0 : { name: primaryKey.name }
+    } : void 0,
+    indexes: tableIndexes.filter(
+      (index) => index.columns.length > 1 || index.columns.some((it) => "expression" in it)
+    ).map((index) => ({
+      columns: index.columns.map((it) => __spreadProps(__spreadValues({}, "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 : void 0,
+        using: index.using === "btree" ? void 0 : 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) => ({
+  columns: fkey.columnNames,
+  fnOrTable: fkey.foreignTableName,
+  foreignColumns: fkey.foreignColumnNames,
+  options: {
+    name: fkey.name && fkey.name !== getForeignKeyName(fkey.tableName, fkey.columnNames) ? fkey.name : void 0,
+    match: matchMap[fkey.match],
+    onUpdate: fkeyActionMap[fkey.onUpdate],
+    onDelete: fkeyActionMap[fkey.onDelete]
+  }
+});
 
 const astToMigration = (ast) => {
   const code = [];
   for (const item of ast) {
     if (item.type === "schema" && item.action === "create") {
       code.push(createSchema(item));
+    } else if (item.type === "extension" && item.action === "create") {
+      if (code.length)
+        code.push([]);
+      code.push(...createExtension(item));
     } else if (item.type === "table" && item.action === "create") {
       if (code.length)
         code.push([]);
       code.push(...createTable(item));
+    } else if (item.type === "foreignKey") {
+      if (code.length)
+        code.push([]);
+      code.push(...createForeignKey(item));
     }
   }
   if (!code.length)
@@ -1897,6 +1970,21 @@ ${pqb.codeToString(code, "  ", "  ")}
 const createSchema = (ast) => {
   return `await db.createSchema(${pqb.singleQuote(ast.name)});`;
 };
+const createExtension = (ast) => {
+  const code = [`await db.createExtension(${pqb.singleQuote(ast.name)}`];
+  if (ast.schema || ast.version) {
+    pqb.addCode(code, ", {");
+    if (ast.schema) {
+      code.push([`schema: ${pqb.singleQuote(ast.schema)},`]);
+    }
+    if (ast.version) {
+      code.push([`version: ${pqb.singleQuote(ast.version)},`]);
+    }
+    pqb.addCode(code, "}");
+  }
+  pqb.addCode(code, ")");
+  return code;
+};
 const createTable = (ast) => {
   const code = [];
   pqb.addCode(code, `await db.createTable(${quoteSchemaTable(ast)}, (t) => ({`);
@@ -1932,6 +2020,19 @@ const isTimestamp = (column) => {
   const { default: def } = column.data;
   return column instanceof pqb.TimestampColumn && !column.data.isNullable && def && typeof def === "object" && pqb.isRaw(def) && def.__raw === "now()";
 };
+const createForeignKey = (item) => {
+  return [
+    `await db.addForeignKey(`,
+    [
+      `${quoteSchemaTable({
+        schema: item.tableSchema,
+        name: item.tableName
+      })},`,
+      ...pqb.foreignKeyArgsToCode(item)
+    ],
+    ");"
+  ];
+};
 
 const pullDbStructure = async (options, config) => {
   const adapter = new pqb.Adapter(options);