rake-db 2.3.10 → 2.3.13

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # rake-db
 
+## 2.3.13
+
+### Patch Changes
+
+- ee1961e: Make columnTypes optional in configs
+- Updated dependencies [ee1961e]
+  - pqb@0.9.8
+
+## 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

@@ -1,5 +1,5 @@
 import * as pqb from 'pqb';
-import { EmptyObject, RawExpression, ColumnType, ColumnTypes, raw, ColumnsShape, DbResult, columnTypes, TransactionAdapter, AdapterOptions, TextColumn, MaybeArray, IndexColumnOptions, IndexOptions, ForeignKeyOptions, QueryLogObject, NoPrimaryKeyOption, TableData, SingleColumnIndexOptions, QueryLogOptions } from 'pqb';
+import { EmptyObject, RawExpression, ColumnType, ColumnTypes, raw, ColumnsShape, DbResult, DefaultColumnTypes, TransactionAdapter, AdapterOptions, TextColumn, MaybeArray, IndexColumnOptions, IndexOptions, ForeignKeyOptions, QueryLogObject, NoPrimaryKeyOption, TableData, SingleColumnIndexOptions, QueryLogOptions } from 'pqb';
 
 declare function add(item: ColumnType, options?: {
     dropMode?: DropMode;
@@ -60,7 +60,7 @@ declare type ExtensionOptions = {
     version?: string;
     cascade?: boolean;
 };
-declare type Migration = DbResult<typeof columnTypes> & MigrationBase;
+declare type Migration = DbResult<DefaultColumnTypes> & MigrationBase;
 declare const createMigrationInterface: (tx: TransactionAdapter, up: boolean, options: RakeDbConfig, adapterOptions: AdapterOptions, appCodeUpdaterCache: object) => pqb.Db<string, Record<string, never>, pqb.RelationsBase, {
     smallint: () => pqb.SmallIntColumn;
     integer: () => pqb.IntegerColumn;
@@ -105,7 +105,7 @@ declare const createMigrationInterface: (tx: TransactionAdapter, up: boolean, op
     xml: () => pqb.XMLColumn;
     json: <Type extends pqb.JSONTypeAny>(schemaOrFn: Type | ((j: {
         set: <Value extends pqb.JSONTypeAny>(valueType: Value) => pqb.JSONSet<Value>;
-        tuple: <T_1 extends [] | pqb.JSONTupleItems, Rest extends pqb.JSONTypeAny | null = null>(items: T_1, rest?: Rest) => pqb.JSONTuple<T_1, Rest>;
+        tuple: <T_1 extends pqb.JSONTupleItems | [], Rest extends pqb.JSONTypeAny | null = null>(items: T_1, rest?: Rest) => pqb.JSONTuple<T_1, Rest>;
         union: <T_2 extends [pqb.JSONTypeAny, pqb.JSONTypeAny, ...pqb.JSONTypeAny[]]>(types: T_2) => pqb.JSONUnion<T_2>;
         any: () => pqb.JSONAny;
         bigint: () => pqb.JSONBigInt;
@@ -204,7 +204,7 @@ declare const createMigrationInterface: (tx: TransactionAdapter, up: boolean, op
         xml: () => pqb.XMLColumn;
         json: <Type extends pqb.JSONTypeAny>(schemaOrFn: Type | ((j: {
             set: <Value extends pqb.JSONTypeAny>(valueType: Value) => pqb.JSONSet<Value>;
-            tuple: <T_1 extends [] | pqb.JSONTupleItems, Rest extends pqb.JSONTypeAny | null = null>(items: T_1, rest?: Rest) => pqb.JSONTuple<T_1, Rest>;
+            tuple: <T_1 extends pqb.JSONTupleItems | [], Rest extends pqb.JSONTypeAny | null = null>(items: T_1, rest?: Rest) => pqb.JSONTuple<T_1, Rest>;
             union: <T_2 extends [pqb.JSONTypeAny, pqb.JSONTypeAny, ...pqb.JSONTypeAny[]]>(types: T_2) => pqb.JSONUnion<T_2>;
             any: () => pqb.JSONAny;
             bigint: () => pqb.JSONBigInt;
@@ -258,7 +258,105 @@ declare const createMigrationInterface: (tx: TransactionAdapter, up: boolean, op
             <Table extends pqb.ForeignKeyTableWithColumns, Columns extends [Exclude<keyof InstanceType<Table>["columns"]["shape"], number | symbol>, ...Exclude<keyof InstanceType<Table>["columns"]["shape"], number | symbol>[]]>(columns: string[], fn: () => Table, foreignColumns: Columns, options?: ForeignKeyOptions | undefined): {};
             <Table_1 extends string, Columns_1 extends [string, ...string[]]>(columns: string[], table: Table_1, foreignColumns: Columns_1, options?: ForeignKeyOptions | undefined): {};
         };
-    }) => Shape) | undefined, options?: pqb.DbTableOptions | undefined): pqb.Db<Table_2, Shape, pqb.RelationsBase, pqb.ColumnTypesBase>;
+    }) => Shape) | undefined, options?: pqb.DbTableOptions | undefined): pqb.Db<Table_2, Shape, pqb.RelationsBase, {
+        smallint: () => pqb.SmallIntColumn;
+        integer: () => pqb.IntegerColumn;
+        bigint: () => pqb.BigIntColumn;
+        numeric: <Precision extends number | undefined = undefined, Scale extends number | undefined = undefined>(precision?: Precision | undefined, scale?: Scale | undefined) => pqb.DecimalColumn<Precision, Scale>;
+        decimal: <Precision_1 extends number | undefined = undefined, Scale_1 extends number | undefined = undefined>(precision?: Precision_1 | undefined, scale?: Scale_1 | undefined) => pqb.DecimalColumn<Precision_1, Scale_1>;
+        real: () => pqb.RealColumn;
+        doublePrecision: () => pqb.DoublePrecisionColumn;
+        smallSerial: () => pqb.SmallSerialColumn;
+        serial: () => pqb.SerialColumn;
+        bigSerial: () => pqb.BigSerialColumn;
+        money: () => pqb.MoneyColumn;
+        varchar: <Limit extends number | undefined = undefined>(limit?: Limit | undefined) => pqb.VarCharColumn<Limit>;
+        char: <Limit_1 extends number | undefined = undefined>(limit?: Limit_1 | undefined) => pqb.CharColumn<Limit_1>;
+        text: (min: number, max: number) => TextColumn;
+        string: (min: number, max: number) => TextColumn;
+        bytea: () => pqb.ByteaColumn;
+        date: () => pqb.DateColumn;
+        timestamp: <Precision_2 extends number | undefined = undefined>(precision?: Precision_2 | undefined) => pqb.TimestampColumn<Precision_2>;
+        timestampWithTimeZone: <Precision_3 extends number | undefined = undefined>(precision?: Precision_3 | undefined) => pqb.TimestampWithTimeZoneColumn<Precision_3>;
+        time: <Precision_4 extends number | undefined = undefined>(precision?: Precision_4 | undefined) => pqb.TimeColumn<Precision_4>;
+        timeWithTimeZone: <Precision_5 extends number | undefined = undefined>(precision?: Precision_5 | undefined) => pqb.TimeWithTimeZoneColumn<Precision_5>;
+        interval: <Fields extends string | undefined = undefined, Precision_6 extends number | undefined = undefined>(fields?: Fields | undefined, precision?: Precision_6 | undefined) => pqb.IntervalColumn<Fields, Precision_6>;
+        boolean: () => pqb.BooleanColumn;
+        enum: <U extends string, T extends [U, ...U[]]>(dataType: string, type: T) => pqb.EnumColumn<U, T>;
+        point: () => pqb.PointColumn;
+        line: () => pqb.LineColumn;
+        lseg: () => pqb.LsegColumn;
+        box: () => pqb.BoxColumn;
+        path: () => pqb.PathColumn;
+        polygon: () => pqb.PolygonColumn;
+        circle: () => pqb.CircleColumn;
+        cidr: () => pqb.CidrColumn;
+        inet: () => pqb.InetColumn;
+        macaddr: () => pqb.MacAddrColumn;
+        macaddr8: () => pqb.MacAddr8Column;
+        bit: <Length extends number>(length: Length) => pqb.BitColumn<Length>;
+        bitVarying: <Length_1 extends number | undefined = undefined>(length?: Length_1 | undefined) => pqb.BitVaryingColumn<Length_1>;
+        tsvector: () => pqb.TsVectorColumn;
+        tsquery: () => pqb.TsQueryColumn;
+        uuid: () => pqb.UUIDColumn;
+        xml: () => pqb.XMLColumn;
+        json: <Type extends pqb.JSONTypeAny>(schemaOrFn: Type | ((j: {
+            set: <Value extends pqb.JSONTypeAny>(valueType: Value) => pqb.JSONSet<Value>;
+            tuple: <T_1 extends pqb.JSONTupleItems | [], Rest extends pqb.JSONTypeAny | null = null>(items: T_1, rest?: Rest) => pqb.JSONTuple<T_1, Rest>;
+            union: <T_2 extends [pqb.JSONTypeAny, pqb.JSONTypeAny, ...pqb.JSONTypeAny[]]>(types: T_2) => pqb.JSONUnion<T_2>;
+            any: () => pqb.JSONAny;
+            bigint: () => pqb.JSONBigInt;
+            boolean: () => pqb.JSONBoolean;
+            date: () => pqb.JSONDate;
+            nan: () => pqb.JSONNaN;
+            never: () => pqb.JSONNever;
+            null: () => pqb.JSONNull;
+            number: () => pqb.JSONNumber;
+            string: () => pqb.JSONString;
+            undefined: () => pqb.JSONUndefined;
+            unknown: () => pqb.JSONUnknown;
+            void: () => pqb.JSONVoid;
+            array: <Type_1 extends pqb.JSONTypeAny>(element: Type_1) => pqb.JSONArray<Type_1, "many">;
+            discriminatedUnion: <Discriminator extends string, DiscriminatorValue extends pqb.Primitive, Types extends [pqb.JSONDiscriminatedObject<Discriminator, DiscriminatorValue>, pqb.JSONDiscriminatedObject<Discriminator, DiscriminatorValue>, ...pqb.JSONDiscriminatedObject<Discriminator, DiscriminatorValue>[]]>(discriminator: Discriminator, options: Types) => pqb.JSONDiscriminatedUnion<Discriminator, DiscriminatorValue, Types[number]>;
+            enum: <U_1 extends string, T_3 extends [U_1, ...U_1[]]>(options: T_3) => pqb.JSONEnum<U_1, T_3>;
+            instanceOf: <T_4 extends new (...args: any[]) => any>(cls: T_4) => pqb.JSONInstanceOf<T_4>;
+            intersection: <Left extends pqb.JSONTypeAny, Right extends pqb.JSONTypeAny>(left: Left, right: Right) => pqb.JSONIntersection<Left, Right>;
+            lazy: <T_5 extends pqb.JSONTypeAny>(fn: () => T_5) => pqb.JSONLazy<T_5>;
+            literal: <T_6 extends pqb.Primitive>(value: T_6) => pqb.JSONLiteral<T_6>;
+            map: <Key extends pqb.JSONTypeAny, Value_1 extends pqb.JSONTypeAny>(keyType: Key, valueType: Value_1) => pqb.JSONMap<Key, Value_1>;
+            nativeEnum: <T_7 extends pqb.EnumLike>(givenEnum: T_7) => pqb.JSONNativeEnum<T_7>;
+            nullable: <T_8 extends pqb.JSONTypeAny>(type: T_8) => pqb.JSONNullable<T_8>;
+            nullish: <T_9 extends pqb.JSONTypeAny>(type: T_9) => pqb.JSONNullish<T_9>;
+            object: <T_10 extends pqb.JSONObjectShape, UnknownKeys extends pqb.UnknownKeysParam = "strip", Catchall extends pqb.JSONTypeAny = pqb.JSONTypeAny>(shape: T_10) => pqb.JSONObject<T_10, UnknownKeys, Catchall, pqb.JSONTypeAny extends Catchall ? pqb.addQuestionMarks<{ [k_1 in keyof T_10]: T_10[k_1]["type"]; }> extends infer T_11 extends object ? { [k in keyof T_11]: pqb.addQuestionMarks<{ [k_1 in keyof T_10]: T_10[k_1]["type"]; }>[k]; } : never : (pqb.addQuestionMarks<{ [k_1 in keyof T_10]: T_10[k_1]["type"]; }> extends infer T_11 extends object ? { [k in keyof T_11]: pqb.addQuestionMarks<{ [k_1 in keyof T_10]: T_10[k_1]["type"]; }>[k]; } : never) & {
+                [k: string]: Catchall["type"];
+            } extends infer T_12 extends object ? { [k_2 in keyof T_12]: ((pqb.addQuestionMarks<{ [k_1 in keyof T_10]: T_10[k_1]["type"]; }> extends infer T_11 extends object ? { [k in keyof T_11]: pqb.addQuestionMarks<{ [k_1 in keyof T_10]: T_10[k_1]["type"]; }>[k]; } : never) & {
+                [k: string]: Catchall["type"];
+            })[k_2]; } : never>;
+            optional: <T_13 extends pqb.JSONTypeAny>(type: T_13) => pqb.JSONOptional<T_13>;
+            record: typeof pqb.record;
+        }) => Type)) => pqb.JSONColumn<Type>;
+        jsonText: () => pqb.JSONTextColumn;
+        array: <Item extends ColumnType<unknown, pqb.Operators, unknown>>(item: Item) => pqb.ArrayColumn<Item>;
+        timestamps: <T_14 extends ColumnType<unknown, pqb.Operators, unknown>>(this: {
+            timestamp(): T_14;
+        }) => {
+            createdAt: T_14 & {
+                hasDefault: true;
+            };
+            updatedAt: T_14 & {
+                hasDefault: true;
+            };
+        };
+        primaryKey(columns: string[], options?: {
+            name?: string | undefined;
+        } | undefined): {};
+        index(columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): {};
+        unique(columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): {};
+        foreignKey: {
+            <Table extends pqb.ForeignKeyTableWithColumns, Columns extends [Exclude<keyof InstanceType<Table>["columns"]["shape"], number | symbol>, ...Exclude<keyof InstanceType<Table>["columns"]["shape"], number | symbol>[]]>(columns: string[], fn: () => Table, foreignColumns: Columns, options?: ForeignKeyOptions | undefined): {};
+            <Table_1 extends string, Columns_1 extends [string, ...string[]]>(columns: string[], table: Table_1, foreignColumns: Columns_1, options?: ForeignKeyOptions | undefined): {};
+        };
+    }>;
     adapter: pqb.Adapter;
     close: () => Promise<void>;
 } & MigrationBase & {
@@ -311,7 +409,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,9 +485,15 @@ 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>;
+declare type Db = DbResult<DefaultColumnTypes>;
 declare type RakeDbConfig = {
     migrationsPath: string;
     migrationsTable: string;

package/dist/index.js

@@ -928,7 +928,7 @@ const createMigrationInterface = (tx, up, options, adapterOptions, appCodeUpdate
   adapter.arrays = (q, types) => {
     return wrapWithLog(log, q, () => arrays.call(adapter, q, types));
   };
-  const db = pqb.createDb({ adapter, columnTypes: pqb.columnTypes });
+  const db = pqb.createDb({ adapter });
   const { prototype: proto } = MigrationBase;
   for (const key of Object.getOwnPropertyNames(proto)) {
     db[key] = proto[key];
@@ -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",
@@ -1138,7 +1138,7 @@ var __spreadValues$1 = (a, b) => {
     }
   return a;
 };
-const getDb = (adapter) => pqb.createDb({ adapter, columnTypes: pqb.columnTypes });
+const getDb = (adapter) => pqb.createDb({ adapter });
 const migrateOrRollback = async (options, config, args, up) => {
   var _a, _b, _c, _d, _e;
   config = __spreadValues$1({}, config);
@@ -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);