rake-db 2.4.25 → 2.4.30

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { quote, getRaw, EnumColumn, UnknownColumn, columnTypes, getColumnTypes, getTableData, ColumnType, resetTableData, TransactionAdapter, logParamToLogObject, createDb as createDb$1, Adapter, columnsByType, instantiateColumn, DomainColumn, CustomTypeColumn, ArrayColumn, primaryKeyToCode, indexToCode, foreignKeyToCode, TimestampColumn, foreignKeyArgsToCode } from 'pqb';
+import { quote, getRaw, EnumColumn, columnTypes, getColumnTypes, getTableData, ColumnType, resetTableData, UnknownColumn, TransactionAdapter, logParamToLogObject, createDb as createDb$1, Adapter, columnsByType, instantiateColumn, DomainColumn, CustomTypeColumn, ArrayColumn, getConstraintKind, primaryKeyToCode, indexToCode, constraintToCode, TimestampColumn, referencesArgsToCode, constraintPropsToCode } from 'pqb';
 import { singleQuote, toSnakeCase, isRaw, toArray, snakeCaseKey, nameKey, emptyObject, pathToLog, raw, toCamelCase, codeToString, addCode, rawToCode, quoteObjectKey } from 'orchid-core';
 import path from 'path';
 import { readdir, mkdir, writeFile } from 'fs/promises';
@@ -294,7 +294,7 @@ const columnToSql = (name, item, values, hasMultiplePrimaryKeys, snakeCase) => {
     line.push("NOT NULL");
   }
   if (item.data.check) {
-    line.push(`CHECK (${getRaw(item.data.check, values)})`);
+    line.push(checkToSql(item.data.check, values));
   }
   if (item.data.default !== void 0) {
     if (typeof item.data.default === "object" && item.data.default && isRaw(item.data.default)) {
@@ -306,18 +306,17 @@ const columnToSql = (name, item, values, hasMultiplePrimaryKeys, snakeCase) => {
   const { foreignKeys } = item.data;
   if (foreignKeys) {
     for (const foreignKey of foreignKeys) {
-      const [schema, table] = getForeignKeyTable(
-        "fn" in foreignKey ? foreignKey.fn : foreignKey.table
-      );
       if (foreignKey.name) {
         line.push(`CONSTRAINT "${foreignKey.name}"`);
       }
       line.push(
         referencesToSql(
-          schema,
-          table,
-          foreignKey.columns,
-          foreignKey,
+          {
+            columns: foreignKey.columns,
+            fnOrTable: "fn" in foreignKey ? foreignKey.fn : foreignKey.table,
+            foreignColumns: foreignKey.columns,
+            options: foreignKey
+          },
           snakeCase
         )
       );
@@ -347,40 +346,53 @@ const getForeignKeyTable = (fnOrTable) => {
   const item = new (fnOrTable())();
   return [item.schema, item.table];
 };
-const getForeignKeyName = (table, columns) => {
-  return `${table}_${columns.join("_")}_fkey`;
+const getConstraintName = (table, constraint) => {
+  if (constraint.references)
+    return `${table}_${constraint.references.columns.join("_")}_fkey`;
+  if (constraint.check)
+    return `${table}_check`;
+  return `${table}_constraint`;
 };
-const constraintToSql = ({ name }, up, foreignKey, snakeCase) => {
-  const constraintName = foreignKey.options.name || getForeignKeyName(name, foreignKey.columns);
+const constraintToSql = ({ name }, up, constraint, values, snakeCase) => {
+  const constraintName = constraint.name || getConstraintName(name, constraint);
   if (!up) {
-    const { dropMode } = foreignKey.options;
+    const { dropMode } = constraint;
     return `CONSTRAINT "${constraintName}"${dropMode ? ` ${dropMode}` : ""}`;
   }
-  const [schema, table] = getForeignKeyTable(foreignKey.fnOrTable);
-  return `CONSTRAINT "${constraintName}" FOREIGN KEY (${joinColumns(
-    foreignKey.columns
-  )}) ${referencesToSql(
-    schema,
-    table,
-    foreignKey.foreignColumns,
-    foreignKey.options,
+  const sql = [`CONSTRAINT "${constraintName}"`];
+  if (constraint.references) {
+    sql.push(foreignKeyToSql(constraint.references, snakeCase));
+  }
+  if (constraint.check) {
+    sql.push(checkToSql(constraint.check, values));
+  }
+  return sql.join(" ");
+};
+const checkToSql = (check, values) => {
+  return `CHECK (${getRaw(check, values)})`;
+};
+const foreignKeyToSql = (item, snakeCase) => {
+  return `FOREIGN KEY (${joinColumns(item.columns)}) ${referencesToSql(
+    item,
     snakeCase
   )}`;
 };
-const referencesToSql = (schema, table, columns, foreignKey, snakeCase) => {
+const referencesToSql = (references, snakeCase) => {
+  const [schema, table] = getForeignKeyTable(references.fnOrTable);
   const sql = [
     `REFERENCES ${quoteWithSchema({ schema, name: table })}(${joinColumns(
-      snakeCase ? columns.map(toSnakeCase) : columns
+      snakeCase ? references.foreignColumns.map(toSnakeCase) : references.foreignColumns
     )})`
   ];
-  if (foreignKey.match) {
-    sql.push(`MATCH ${foreignKey.match.toUpperCase()}`);
+  const { options } = references;
+  if (options == null ? void 0 : options.match) {
+    sql.push(`MATCH ${options == null ? void 0 : options.match.toUpperCase()}`);
   }
-  if (foreignKey.onDelete) {
-    sql.push(`ON DELETE ${foreignKey.onDelete.toUpperCase()}`);
+  if (options == null ? void 0 : options.onDelete) {
+    sql.push(`ON DELETE ${options == null ? void 0 : options.onDelete.toUpperCase()}`);
   }
-  if (foreignKey.onUpdate) {
-    sql.push(`ON UPDATE ${foreignKey.onUpdate.toUpperCase()}`);
+  if (options == null ? void 0 : options.onUpdate) {
+    sql.push(`ON UPDATE ${options == null ? void 0 : options.onUpdate.toUpperCase()}`);
   }
   return sql.join(" ");
 };
@@ -465,9 +477,6 @@ const primaryKeyToSql = (primaryKey) => {
 const tableMethods = {
   enum(name) {
     return new EnumColumn(this, name, []);
-  },
-  check(value) {
-    return new UnknownColumn(this).check(value);
   }
 };
 
@@ -578,6 +587,7 @@ You can suppress this error by setting { noPrimaryKey: true } after a table name
   }
 };
 const astToQueries$1 = (ast, snakeCase) => {
+  var _a, _b;
   const queries = [];
   const { shape } = ast;
   for (const key in shape) {
@@ -617,27 +627,30 @@ const astToQueries$1 = (ast, snakeCase) => {
       })}`
     );
   }
-  ast.foreignKeys.forEach((foreignKey) => {
+  (_a = ast.constraints) == null ? void 0 : _a.forEach((item) => {
     lines.push(
       `
   ${constraintToSql(
         ast,
         true,
-        __spreadProps$3(__spreadValues$4({}, foreignKey), {
-          columns: foreignKey.columns.map(
-            (column) => getColumnName(shape[column], column, snakeCase)
-          )
+        __spreadProps$3(__spreadValues$4({}, item), {
+          references: item.references ? __spreadProps$3(__spreadValues$4({}, item.references), {
+            columns: item.references.columns.map(
+              (column) => getColumnName(shape[column], column, snakeCase)
+            )
+          }) : void 0
         }),
+        values,
         snakeCase
       )}`
     );
   });
   indexes.push(
-    ...ast.indexes.map((index) => __spreadProps$3(__spreadValues$4({}, index), {
+    ...((_b = ast.indexes) == null ? void 0 : _b.map((index) => __spreadProps$3(__spreadValues$4({}, index), {
       columns: index.columns.map((item) => __spreadValues$4(__spreadValues$4({}, item), "column" in item ? {
         column: getColumnName(shape[item.column], item.column, snakeCase)
       } : {}))
-    }))
+    }))) || []
   );
   queries.push(
     {
@@ -676,8 +689,8 @@ var __spreadValues$3 = (a, b) => {
 };
 var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
 const newChangeTableData = () => ({
-  add: { indexes: [], foreignKeys: [] },
-  drop: { indexes: [], foreignKeys: [] }
+  add: {},
+  drop: {}
 });
 let changeTableData = newChangeTableData();
 const resetChangeTableData = () => {
@@ -694,8 +707,8 @@ const mergeTableData = (a, b) => {
       };
     }
   }
-  a.indexes = [...a.indexes, ...b.indexes];
-  a.foreignKeys = [...a.foreignKeys, ...b.foreignKeys];
+  a.indexes = [...a.indexes || [], ...b.indexes || []];
+  a.constraints = [...a.constraints || [], ...b.constraints || []];
 };
 function add(item, options) {
   if (item instanceof ColumnType) {
@@ -920,20 +933,14 @@ const astToQueries = (ast, snakeCase) => {
   }
   const alterTable = [];
   const values = [];
-  const addIndexes = mapIndexesForSnakeCase(
-    ast.add.indexes,
+  const addIndexes = mapIndexesForSnakeCase(ast.add.indexes, snakeCase);
+  const dropIndexes = mapIndexesForSnakeCase(ast.drop.indexes, snakeCase);
+  const addConstraints = mapConstraintsToSnakeCase(
+    ast.add.constraints,
     snakeCase
   );
-  const dropIndexes = mapIndexesForSnakeCase(
-    ast.drop.indexes,
-    snakeCase
-  );
-  const addForeignKeys = mapForeignKeysForSnakeCase(
-    ast.add.foreignKeys,
-    snakeCase
-  );
-  const dropForeignKeys = mapForeignKeysForSnakeCase(
-    ast.drop.foreignKeys,
+  const dropConstraints = mapConstraintsToSnakeCase(
+    ast.drop.constraints,
     snakeCase
   );
   const comments = [];
@@ -1007,19 +1014,27 @@ const astToQueries = (ast, snakeCase) => {
         const toFkey = (_d = to.foreignKeys) == null ? void 0 : _d[i];
         if ((fromFkey || toFkey) && (!fromFkey || !toFkey || fromFkey.name !== toFkey.name || fromFkey.match !== toFkey.match || fromFkey.onUpdate !== toFkey.onUpdate || fromFkey.onDelete !== toFkey.onDelete || fromFkey.dropMode !== toFkey.dropMode || fromFkey.table !== toFkey.table || fromFkey.columns.join(",") !== toFkey.columns.join(","))) {
           if (fromFkey) {
-            dropForeignKeys.push({
-              columns: [name],
-              fnOrTable: fromFkey.table,
-              foreignColumns: snakeCase ? fromFkey.columns.map(toSnakeCase) : fromFkey.columns,
-              options: fromFkey
+            dropConstraints.push({
+              name: fromFkey.name,
+              dropMode: fromFkey.dropMode,
+              references: {
+                columns: [name],
+                fnOrTable: fromFkey.table,
+                foreignColumns: snakeCase ? fromFkey.columns.map(toSnakeCase) : fromFkey.columns,
+                options: fromFkey
+              }
             });
           }
           if (toFkey) {
-            addForeignKeys.push({
-              columns: [name],
-              fnOrTable: toFkey.table,
-              foreignColumns: snakeCase ? toFkey.columns.map(toSnakeCase) : toFkey.columns,
-              options: toFkey
+            addConstraints.push({
+              name: toFkey.name,
+              dropMode: toFkey.dropMode,
+              references: {
+                columns: [name],
+                fnOrTable: toFkey.table,
+                foreignColumns: snakeCase ? toFkey.columns.map(toSnakeCase) : toFkey.columns,
+                options: toFkey
+              }
             });
           }
         }
@@ -1069,9 +1084,9 @@ const astToQueries = (ast, snakeCase) => {
     prependAlterTable.push(`DROP CONSTRAINT "${name}"`);
   }
   prependAlterTable.push(
-    ...dropForeignKeys.map(
+    ...dropConstraints.map(
       (foreignKey) => `
- DROP ${constraintToSql(ast, false, foreignKey, snakeCase)}`
+ DROP ${constraintToSql(ast, false, foreignKey, values, snakeCase)}`
     )
   );
   alterTable.unshift(...prependAlterTable);
@@ -1086,9 +1101,9 @@ const astToQueries = (ast, snakeCase) => {
     );
   }
   alterTable.push(
-    ...addForeignKeys.map(
+    ...addConstraints.map(
       (foreignKey) => `
- ADD ${constraintToSql(ast, true, foreignKey, snakeCase)}`
+ ADD ${constraintToSql(ast, true, foreignKey, values, snakeCase)}`
     )
   );
   if (alterTable.length) {
@@ -1107,17 +1122,19 @@ const getChangeColumnName = (change, key, snakeCase) => {
   return change.name || (change.to.column ? getColumnName(change.to.column, key, snakeCase) : snakeCase ? toSnakeCase(key) : key);
 };
 const mapIndexesForSnakeCase = (indexes, snakeCase) => {
-  return indexes.map((index) => ({
+  return (indexes == null ? void 0 : indexes.map((index) => ({
     options: index.options,
     columns: snakeCase ? index.columns.map(
       (item) => "column" in item ? __spreadProps$2(__spreadValues$3({}, item), { column: toSnakeCase(item.column) }) : item
     ) : index.columns
-  }));
+  }))) || [];
 };
-const mapForeignKeysForSnakeCase = (foreignKeys, snakeCase) => {
-  return foreignKeys.map((foreignKey) => __spreadProps$2(__spreadValues$3({}, foreignKey), {
-    columns: snakeCase ? foreignKey.columns.map(toSnakeCase) : foreignKey.columns
-  }));
+const mapConstraintsToSnakeCase = (foreignKeys, snakeCase) => {
+  return (foreignKeys == null ? void 0 : foreignKeys.map((item) => __spreadProps$2(__spreadValues$3({}, item), {
+    references: item.references ? snakeCase ? __spreadProps$2(__spreadValues$3({}, item.references), {
+      columns: item.references.columns.map(toSnakeCase)
+    }) : item.references : void 0
+  }))) || [];
 };
 
 var __defProp$2 = Object.defineProperty;
@@ -1238,6 +1255,18 @@ class MigrationBase {
   dropPrimaryKey(tableName, columns, options) {
     return addPrimaryKey(this, !this.up, tableName, columns, options);
   }
+  addCheck(tableName, check) {
+    return addCheck(this, this.up, tableName, check);
+  }
+  dropCheck(tableName, check) {
+    return addCheck(this, !this.up, tableName, check);
+  }
+  addConstraint(tableName, constraint) {
+    return addConstraint(this, this.up, tableName, constraint);
+  }
+  dropConstraint(tableName, constraint) {
+    return addConstraint(this, !this.up, tableName, constraint);
+  }
   renameColumn(tableName, from, to) {
     return this.changeTable(tableName, (t) => ({
       [from]: t.rename(to)
@@ -1316,6 +1345,12 @@ const addForeignKey = (migration, up, tableName, columns, foreignTable, foreignC
 const addPrimaryKey = (migration, up, tableName, columns, options) => {
   return changeTable(migration, up, tableName, {}, (t) => __spreadValues$2({}, t.add(t.primaryKey(columns, options))));
 };
+const addCheck = (migration, up, tableName, check) => {
+  return changeTable(migration, up, tableName, {}, (t) => __spreadValues$2({}, t.add(t.check(check))));
+};
+const addConstraint = (migration, up, tableName, constraint) => {
+  return changeTable(migration, up, tableName, {}, (t) => __spreadValues$2({}, t.add(t.constraint(constraint))));
+};
 const createSchema$1 = async (migration, up, name) => {
   const ast = {
     type: "schema",
@@ -1925,57 +1960,78 @@ ORDER BY ic.relname`
     );
     return rows;
   }
-  async getForeignKeys() {
+  async getConstraints() {
     const { rows } = await this.db.query(
       `SELECT
   s.nspname AS "schemaName",
   t.relname AS "tableName",
-  fs.nspname AS "foreignTableSchemaName",
-  ft.relname AS "foreignTableName",
   c.conname AS "name",
   (
     SELECT json_agg(ccu.column_name)
-    FROM information_schema.key_column_usage ccu
-    WHERE ccu.constraint_name = c.conname
-      AND ccu.table_schema = cs.nspname
-  ) AS "columnNames",
+    FROM information_schema.constraint_column_usage ccu
+    WHERE contype = 'p'
+      AND ccu.constraint_name = c.conname
+      AND ccu.table_schema = s.nspname
+  ) AS "primaryKey",
   (
-    SELECT json_agg(ccu.column_name)
+    SELECT
+      json_build_object(
+        'foreignSchema',
+        fs.nspname,
+        'foreignTable',
+        ft.relname,
+        'columns',
+        (
+          SELECT json_agg(ccu.column_name)
+          FROM information_schema.key_column_usage ccu
+          WHERE ccu.constraint_name = c.conname
+            AND ccu.table_schema = cs.nspname
+        ),
+        'foreignColumns',
+        (
+          SELECT json_agg(ccu.column_name)
+          FROM information_schema.constraint_column_usage ccu
+          WHERE ccu.constraint_name = c.conname
+            AND ccu.table_schema = cs.nspname
+        ),
+        'match',
+        c.confmatchtype,
+        'onUpdate',
+        c.confupdtype,
+        'onDelete',
+        c.confdeltype
+      )
+    FROM pg_class ft
+    JOIN pg_catalog.pg_namespace fs ON fs.oid = ft.relnamespace
+    JOIN pg_catalog.pg_namespace cs ON cs.oid = c.connamespace
+    WHERE contype = 'f' AND ft.oid = confrelid
+  ) AS "references",
+  (
+    SELECT
+      CASE conbin IS NULL
+      WHEN false THEN
+        json_build_object(
+          'columns',
+          json_agg(ccu.column_name),
+          'expression',
+          pg_get_expr(conbin, conrelid)
+        )
+      END
     FROM information_schema.constraint_column_usage ccu
-    WHERE ccu.constraint_name = c.conname
-      AND ccu.table_schema = cs.nspname
-  ) AS "foreignColumnNames",
-  c.confmatchtype AS match,
-  c.confupdtype AS "onUpdate",
-  c.confdeltype AS "onDelete"
+    WHERE conbin IS NOT NULL
+      AND ccu.constraint_name = c.conname
+      AND ccu.table_schema = s.nspname
+  ) AS "check"
 FROM pg_catalog.pg_constraint c
 JOIN pg_class t ON t.oid = conrelid
-JOIN pg_catalog.pg_namespace s ON s.oid = t.relnamespace
-JOIN pg_class ft ON ft.oid = confrelid
-JOIN pg_catalog.pg_namespace fs ON fs.oid = ft.relnamespace
-JOIN pg_catalog.pg_namespace cs ON cs.oid = c.connamespace
-WHERE contype = 'f'
+JOIN pg_catalog.pg_namespace s
+  ON s.oid = t.relnamespace
+ AND contype IN ('p', 'f', 'c')
+ AND ${filterSchema("s.nspname")}
 ORDER BY c.conname`
     );
     return rows;
   }
-  async getPrimaryKeys() {
-    const { rows } = await this.db.query(
-      `SELECT tc.table_schema AS "schemaName",
-  tc.table_name AS "tableName",
-  tc.constraint_name AS "name",
-  json_agg(ccu.column_name) "columnNames"
-FROM information_schema.table_constraints tc
-JOIN information_schema.constraint_column_usage ccu
-  ON ccu.constraint_name = tc.constraint_name
- AND ccu.table_schema = tc.table_schema
-WHERE tc.constraint_type = 'PRIMARY KEY'
-  AND ${filterSchema("tc.table_schema")}
-GROUP BY "schemaName", "tableName", "name"
-ORDER BY "name"`
-    );
-    return rows;
-  }
   async getTriggers() {
     const { rows } = await this.db.query(
       `SELECT event_object_schema AS "schemaName",
@@ -2019,31 +2075,6 @@ GROUP BY n.nspname, t.typname`
     );
     return rows;
   }
-  async getChecks() {
-    const { rows } = await this.db.query(`SELECT
-  s.nspname AS "schemaName",
-  t.relname AS "tableName",
-  c.conname AS "name",
-  (
-    SELECT json_agg(ccu.column_name)
-    FROM information_schema.constraint_column_usage ccu
-    WHERE ccu.constraint_name = c.conname
-      AND ccu.table_schema = cs.nspname
-  ) AS "columnNames",
-  pg_get_expr(conbin, conrelid) AS "expression"
-FROM pg_catalog.pg_constraint c
-JOIN pg_class t ON t.oid = conrelid
-JOIN pg_catalog.pg_namespace s ON s.oid = t.relnamespace
-JOIN pg_catalog.pg_namespace cs ON cs.oid = c.connamespace
-WHERE contype = 'c'
-ORDER BY c.conname`);
-    for (const row of rows) {
-      if (row.expression[0] === "(" && row.expression[row.expression.length - 1] === ")") {
-        row.expression = row.expression.slice(1, -1);
-      }
-    }
-    return rows;
-  }
   async getDomains() {
     const { rows } = await this.db.query(`SELECT
   n.nspname AS "schemaName",
@@ -2137,10 +2168,11 @@ const structureToAst = async (ctx, db) => {
   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)
+    for (const fk of data.constraints) {
+      const { references } = fk;
+      if (!references || fk.schemaName !== table.schemaName || fk.tableName !== table.name)
         continue;
-      const otherKey = `${fk.foreignTableSchemaName}.${fk.foreignTableName}`;
+      const otherKey = `${references.foreignSchema}.${references.foreignTable}`;
       if (otherKey !== key) {
         dependsOn.add(otherKey);
       }
@@ -2164,7 +2196,7 @@ const structureToAst = async (ctx, db) => {
       pushTableAst(ctx, ast, data, domains, table, pendingTables);
     }
   }
-  const outerFKeys = [];
+  const outerConstraints = [];
   for (const it of data.extensions) {
     ast.push({
       type: "extension",
@@ -2197,23 +2229,31 @@ const structureToAst = async (ctx, db) => {
     });
   }
   for (const key in pendingTables) {
-    const innerFKeys = [];
+    const innerConstraints = [];
     const { table } = pendingTables[key];
-    for (const fkey of data.foreignKeys) {
+    for (const fkey of data.constraints) {
       if (fkey.schemaName !== table.schemaName || fkey.tableName !== table.name)
         continue;
-      const otherKey = `${fkey.foreignTableSchemaName}.${fkey.foreignTableName}`;
-      if (!pendingTables[otherKey] || otherKey === key) {
-        innerFKeys.push(fkey);
+      const otherKey = fkey.references && `${fkey.references.foreignSchema}.${fkey.references.foreignTable}`;
+      if (!otherKey || !pendingTables[otherKey] || otherKey === key) {
+        innerConstraints.push(fkey);
       } else {
-        outerFKeys.push([fkey, table]);
+        outerConstraints.push([fkey, table]);
       }
     }
-    pushTableAst(ctx, ast, data, domains, table, pendingTables, innerFKeys);
+    pushTableAst(
+      ctx,
+      ast,
+      data,
+      domains,
+      table,
+      pendingTables,
+      innerConstraints
+    );
   }
-  for (const [fkey, table] of outerFKeys) {
-    ast.push(__spreadProps(__spreadValues({}, foreignKeyToAst(fkey)), {
-      type: "foreignKey",
+  for (const [fkey, table] of outerConstraints) {
+    ast.push(__spreadProps(__spreadValues({}, constraintToAst(fkey)), {
+      type: "constraint",
       action: "create",
       tableSchema: table.schemaName === "public" ? void 0 : table.schemaName,
       tableName: fkey.tableName
@@ -2226,35 +2266,29 @@ const getData = async (db) => {
     schemas,
     tables,
     columns,
-    primaryKeys,
+    constraints,
     indexes,
-    foreignKeys,
     extensions,
     enums,
-    checks,
     domains
   ] = await Promise.all([
     db.getSchemas(),
     db.getTables(),
     db.getColumns(),
-    db.getPrimaryKeys(),
+    db.getConstraints(),
     db.getIndexes(),
-    db.getForeignKeys(),
     db.getExtensions(),
     db.getEnums(),
-    db.getChecks(),
     db.getDomains()
   ]);
   return {
     schemas,
     tables,
     columns,
-    primaryKeys,
+    constraints,
     indexes,
-    foreignKeys,
     extensions,
     enums,
-    checks,
     domains
   };
 };
@@ -2317,23 +2351,61 @@ const getColumnType = (type, isSerial) => {
     return type;
   return type === "int2" ? "smallserial" : type === "int4" ? "serial" : "bigserial";
 };
-const pushTableAst = (ctx, ast, data, domains, table, pendingTables, innerFKeys = data.foreignKeys) => {
-  const { schemaName, name } = table;
+const pushTableAst = (ctx, ast, data, domains, table, pendingTables, innerConstraints = data.constraints) => {
+  var _a;
+  const { schemaName, name: tableName } = table;
   const key = `${schemaName}.${table.name}`;
   delete pendingTables[key];
-  if (name === "schemaMigrations")
+  if (tableName === "schemaMigrations")
     return;
-  const belongsToTable = makeBelongsToTable(schemaName, name);
+  const belongsToTable = makeBelongsToTable(schemaName, tableName);
   const columns = data.columns.filter(belongsToTable);
-  const primaryKey = data.primaryKeys.find(belongsToTable);
-  const tableIndexes = data.indexes.filter(belongsToTable);
-  const tableForeignKeys = innerFKeys.filter(belongsToTable);
-  const columnChecks = {};
-  for (const check of data.checks) {
-    if (check.columnNames.length === 1) {
-      columnChecks[check.columnNames[0]] = check;
-    }
+  let primaryKey;
+  for (const item of data.constraints) {
+    if (belongsToTable(item) && item.primaryKey)
+      primaryKey = { columns: item.primaryKey, name: item.name };
   }
+  const tableIndexes = data.indexes.filter(belongsToTable);
+  const tableConstraints = innerConstraints.reduce(
+    (acc, item) => {
+      var _a2;
+      const { references, check } = item;
+      if (belongsToTable(item) && (references || check && !isColumnCheck(item))) {
+        const constraint = {
+          references: references ? {
+            columns: references.columns,
+            fnOrTable: getReferencesTable(references),
+            foreignColumns: references.foreignColumns,
+            options: {
+              match: matchMap[references.match],
+              onUpdate: fkeyActionMap[references.onUpdate],
+              onDelete: fkeyActionMap[references.onDelete]
+            }
+          } : void 0,
+          check: check ? raw(check.expression) : void 0
+        };
+        const name = item.name && item.name !== getConstraintName(tableName, constraint) ? item.name : void 0;
+        if (name) {
+          constraint.name = name;
+          if ((_a2 = constraint.references) == null ? void 0 : _a2.options) {
+            constraint.references.options.name = name;
+          }
+        }
+        acc.push(constraint);
+      }
+      return acc;
+    },
+    []
+  );
+  const columnChecks = innerConstraints.reduce(
+    (acc, item) => {
+      if (belongsToTable(item) && isColumnCheck(item)) {
+        acc[item.check.columns[0]] = item.check.expression;
+      }
+      return acc;
+    },
+    {}
+  );
   const shape = {};
   for (let item of columns) {
     const isSerial = getIsSerial(item);
@@ -2345,7 +2417,7 @@ const pushTableAst = (ctx, ast, data, domains, table, pendingTables, innerFKeys
       isArray: item.isArray,
       isSerial
     }));
-    if ((primaryKey == null ? void 0 : primaryKey.columnNames.length) === 1 && (primaryKey == null ? void 0 : primaryKey.columnNames[0]) === item.name) {
+    if (((_a = primaryKey == null ? void 0 : primaryKey.columns) == null ? void 0 : _a.length) === 1 && (primaryKey == null ? void 0 : primaryKey.columns[0]) === item.name) {
       column = column.primaryKey();
     }
     const indexes = tableIndexes.filter(
@@ -2357,7 +2429,7 @@ const pushTableAst = (ctx, ast, data, domains, table, pendingTables, innerFKeys
         collate: options.collate,
         opclass: options.opclass,
         order: options.order,
-        name: index.name !== getIndexName(name, index.columns) ? index.name : void 0,
+        name: index.name !== getIndexName(tableName, index.columns) ? index.name : void 0,
         using: index.using === "btree" ? void 0 : index.using,
         unique: index.isUnique,
         include: index.include,
@@ -2366,24 +2438,18 @@ const pushTableAst = (ctx, ast, data, domains, table, pendingTables, innerFKeys
         where: index.where
       });
     }
-    const foreignKeys = tableForeignKeys.filter(
-      (it) => it.columnNames.length === 1 && it.columnNames[0] === item.name
-    );
-    for (const foreignKey of foreignKeys) {
+    for (const it of tableConstraints) {
+      if (!isColumnFkey(it) || it.references.columns[0] !== item.name)
+        continue;
       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]
-        }
+        it.references.fnOrTable,
+        it.references.foreignColumns[0],
+        it.references.options
       );
     }
     const check = columnChecks[item.name];
     if (check) {
-      column.data.check = raw(check.expression);
+      column.data.check = raw(check);
     }
     const camelCaseName = toCamelCase(item.name);
     if (ctx.snakeCase) {
@@ -2399,12 +2465,12 @@ const pushTableAst = (ctx, ast, data, domains, table, pendingTables, innerFKeys
     action: "create",
     schema: schemaName === "public" ? void 0 : schemaName,
     comment: table.comment,
-    name,
+    name: tableName,
     shape,
     noPrimaryKey: primaryKey ? "error" : "ignore",
-    primaryKey: primaryKey && primaryKey.columnNames.length > 1 ? {
-      columns: primaryKey.columnNames,
-      options: primaryKey.name === `${name}_pkey` ? void 0 : { name: primaryKey.name }
+    primaryKey: primaryKey && primaryKey.columns.length > 1 ? {
+      columns: primaryKey.columns,
+      options: primaryKey.name === `${tableName}_pkey` ? void 0 : { name: primaryKey.name }
     } : void 0,
     indexes: tableIndexes.filter(
       (index) => index.columns.length > 1 || index.columns.some((it) => "expression" in it)
@@ -2415,7 +2481,7 @@ const pushTableAst = (ctx, ast, data, domains, table, pendingTables, innerFKeys
         order: it.order
       })),
       options: {
-        name: index.name !== getIndexName(name, index.columns) ? index.name : void 0,
+        name: index.name !== getIndexName(tableName, index.columns) ? index.name : void 0,
         using: index.using === "btree" ? void 0 : index.using,
         unique: index.isUnique,
         include: index.include,
@@ -2424,7 +2490,9 @@ const pushTableAst = (ctx, ast, data, domains, table, pendingTables, innerFKeys
         where: index.where
       }
     })),
-    foreignKeys: tableForeignKeys.filter((it) => it.columnNames.length > 1).map(foreignKeyToAst)
+    constraints: tableConstraints.filter(
+      (it) => getConstraintKind(it) === "constraint" || !isColumnFkey(it)
+    )
   });
   for (const otherKey in pendingTables) {
     const item = pendingTables[otherKey];
@@ -2433,32 +2501,55 @@ const pushTableAst = (ctx, ast, data, domains, table, pendingTables, innerFKeys
     }
   }
 };
-const foreignKeyToAst = (fkey) => {
-  const result = {
-    columns: fkey.columnNames,
-    fnOrTable: fkey.foreignTableName,
-    foreignColumns: fkey.foreignColumnNames,
-    options: {}
-  };
-  if (fkey.name && fkey.name !== getForeignKeyName(fkey.tableName, fkey.columnNames)) {
-    result.options.name = fkey.name;
-  }
-  const match = matchMap[fkey.match];
-  if (match)
-    result.options.match = match;
-  const onUpdate = fkeyActionMap[fkey.onUpdate];
-  if (onUpdate)
-    result.options.onUpdate = onUpdate;
-  const onDelete = fkeyActionMap[fkey.onDelete];
-  if (onDelete)
-    result.options.onDelete = onDelete;
+const constraintToAst = (item) => {
+  var _a;
+  const result = {};
+  const { references, check } = item;
+  if (references) {
+    const options = {};
+    result.references = {
+      columns: references.columns,
+      fnOrTable: getReferencesTable(references),
+      foreignColumns: references.foreignColumns,
+      options
+    };
+    const match = matchMap[references.match];
+    if (match)
+      options.match = match;
+    const onUpdate = fkeyActionMap[references.onUpdate];
+    if (onUpdate)
+      options.onUpdate = onUpdate;
+    const onDelete = fkeyActionMap[references.onDelete];
+    if (onDelete)
+      options.onDelete = onDelete;
+  }
+  if (check) {
+    result.check = raw(check.expression);
+  }
+  if (item.name && item.name !== getConstraintName(item.tableName, result)) {
+    result.name = item.name;
+    if ((_a = result.references) == null ? void 0 : _a.options) {
+      result.references.options.name = item.name;
+    }
+  }
   return result;
 };
+const getReferencesTable = (references) => {
+  return references.foreignSchema !== "public" ? `${references.foreignSchema}.${references.foreignTable}` : references.foreignTable;
+};
+const isColumnCheck = (it) => {
+  var _a, _b;
+  return !it.references && ((_b = (_a = it.check) == null ? void 0 : _a.columns) == null ? void 0 : _b.length) === 1;
+};
+const isColumnFkey = (it) => {
+  var _a;
+  return !it.check && ((_a = it.references) == null ? void 0 : _a.columns.length) === 1;
+};
 
 const astToMigration = (config, ast) => {
   const first = [];
   const tables = [];
-  const foreignKeys = [];
+  const constraints = [];
   for (const item of ast) {
     if (item.type === "schema" && item.action === "create") {
       first.push(createSchema(item));
@@ -2476,13 +2567,13 @@ const astToMigration = (config, ast) => {
       first.push(...createDomain(item));
     } else if (item.type === "table" && item.action === "create") {
       tables.push(createTable(config, item));
-    } else if (item.type === "foreignKey") {
-      if (foreignKeys.length)
-        foreignKeys.push([]);
-      foreignKeys.push(...createForeignKey(item));
+    } else if (item.type === "constraint") {
+      if (constraints.length)
+        constraints.push([]);
+      constraints.push(...createConstraint(item));
     }
   }
-  if (!first.length && !tables.length && !foreignKeys.length)
+  if (!first.length && !tables.length && !constraints.length)
     return;
   let code = `import { change } from 'rake-db';
 `;
@@ -2502,10 +2593,10 @@ ${codeToString(table, "  ", "  ")}
 `;
     }
   }
-  if (foreignKeys.length) {
+  if (constraints.length) {
     code += `
 change(async (db) => {
-${codeToString(foreignKeys, "  ", "  ")}
+${codeToString(constraints, "  ", "  ")}
 });
 `;
   }
@@ -2583,11 +2674,15 @@ const createTable = (config, ast) => {
   if (ast.primaryKey) {
     code.push([primaryKeyToCode(ast.primaryKey, "t")]);
   }
-  for (const index of ast.indexes) {
-    code.push(indexToCode(index, "t"));
+  if (ast.indexes) {
+    for (const index of ast.indexes) {
+      code.push(indexToCode(index, "t"));
+    }
   }
-  for (const foreignKey of ast.foreignKeys) {
-    code.push(foreignKeyToCode(foreignKey, "t"));
+  if (ast.constraints) {
+    for (const constraint of ast.constraints) {
+      code.push(constraintToCode(constraint, "t"));
+    }
   }
   addCode(code, "}));");
   return code;
@@ -2598,17 +2693,26 @@ const isTimestamp = (column) => {
   const { default: def } = column.data;
   return column instanceof TimestampColumn && !column.data.isNullable && def && typeof def === "object" && isRaw(def) && def.__raw === "now()";
 };
-const createForeignKey = (item) => {
+const createConstraint = (item) => {
+  const kind = getConstraintKind(item);
+  const table = quoteSchemaTable({
+    schema: item.tableSchema,
+    name: item.tableName
+  });
+  if (kind === "foreignKey" && item.references) {
+    return [
+      `await db.addForeignKey(`,
+      [`${table},`, ...referencesArgsToCode(item.references, item.name)],
+      ");"
+    ];
+  }
+  if (kind === "check" && item.check) {
+    return [`await db.addCheck(${table}, ${rawToCode("t", item.check)});`];
+  }
   return [
-    `await db.addForeignKey(`,
-    [
-      `${quoteSchemaTable({
-        schema: item.tableSchema,
-        name: item.tableName
-      })},`,
-      ...foreignKeyArgsToCode(item)
-    ],
-    ");"
+    `await db.addConstraint(${table}, {`,
+    constraintPropsToCode("t", item),
+    "});"
   ];
 };