rake-db 2.4.7 → 2.4.9

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-import { ColumnType, EnumColumn, ColumnTypes, ColumnsShape, DbResult, DefaultColumnTypes, TransactionAdapter, QueryLogObject, IndexColumnOptions, IndexOptions, ForeignKeyOptions, TextColumn, NoPrimaryKeyOption, TableData, SingleColumnIndexOptions, AdapterOptions, QueryLogOptions, Adapter } from 'pqb';
+import { ColumnType, EnumColumn, UnknownColumn, ColumnTypes, ColumnsShape, DbResult, DefaultColumnTypes, TransactionAdapter, QueryLogObject, IndexColumnOptions, IndexOptions, ForeignKeyOptions, TextColumn, NoPrimaryKeyOption, TableData, SingleColumnIndexOptions, AdapterOptions, QueryLogOptions, Adapter } from 'pqb';
+import * as orchid_core from 'orchid-core';
 import { EmptyObject, RawExpression, ColumnTypesBase, raw, MaybeArray } from 'orchid-core';
 
 declare function add(this: ColumnTypesBase, item: ColumnType, options?: {
@@ -24,6 +25,7 @@ declare const tableChangeMethods: {
     comment(comment: string | null): Change;
     rename(name: string): RakeDbAst.ChangeTableItem.Rename;
     enum(this: ColumnTypesBase, name: string): EnumColumn<string, [string, ...string[]]>;
+    check(this: ColumnTypesBase, value: RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>): UnknownColumn;
 };
 declare type TableChanger = MigrationColumnTypes & TableChangeMethods;
 declare type TableChangeData = Record<string, RakeDbAst.ChangeTableItem.Column | RakeDbAst.ChangeTableItem.Rename | Change | EmptyObject>;
@@ -83,14 +85,16 @@ declare class MigrationBase {
     dropSchema(schemaName: string): Promise<void>;
     createExtension(name: string, options?: Omit<RakeDbAst.Extension, 'type' | 'action' | 'name'>): Promise<void>;
     dropExtension(name: string, options?: Omit<RakeDbAst.Extension, 'type' | 'action' | 'name' | 'values'>): Promise<void>;
-    createEnum(name: string, values: [string, ...string[]], options?: Omit<RakeDbAst.Enum, 'type' | 'action' | 'name' | 'values'>): Promise<void>;
-    dropEnum(name: string, values: [string, ...string[]], options?: Omit<RakeDbAst.Enum, 'type' | 'action' | 'name' | 'values'>): Promise<void>;
+    createEnum(name: string, values: [string, ...string[]], options?: Omit<RakeDbAst.Enum, 'type' | 'action' | 'name' | 'values' | 'schema'>): Promise<void>;
+    dropEnum(name: string, values: [string, ...string[]], options?: Omit<RakeDbAst.Enum, 'type' | 'action' | 'name' | 'values' | 'schema'>): Promise<void>;
+    createDomain(name: string, fn: (t: ColumnTypes) => ColumnType, options?: Omit<RakeDbAst.Domain, 'type' | 'action' | 'schema' | 'name' | 'baseType'>): Promise<void>;
+    dropDomain(name: string, fn: (t: ColumnTypes) => ColumnType, options?: Omit<RakeDbAst.Domain, 'type' | 'action' | 'schema' | 'name' | 'baseType'>): Promise<void>;
     tableExists(tableName: string): Promise<boolean>;
     columnExists(tableName: string, columnName: string): Promise<boolean>;
     constraintExists(constraintName: string): Promise<boolean>;
 }
 
-declare type RakeDbAst = RakeDbAst.Table | RakeDbAst.ChangeTable | RakeDbAst.RenameTable | RakeDbAst.Schema | RakeDbAst.Extension | RakeDbAst.Enum | RakeDbAst.ForeignKey;
+declare type RakeDbAst = RakeDbAst.Table | RakeDbAst.ChangeTable | RakeDbAst.RenameTable | RakeDbAst.Schema | RakeDbAst.Extension | RakeDbAst.Enum | RakeDbAst.Domain | RakeDbAst.ForeignKey;
 declare namespace RakeDbAst {
     type Table = {
         type: 'table';
@@ -139,6 +143,7 @@ declare namespace RakeDbAst {
         comment?: string | null;
         compression?: string;
         primaryKey?: boolean;
+        check?: RawExpression;
         foreignKeys?: ({
             table: string;
             columns: string[];
@@ -176,6 +181,18 @@ declare namespace RakeDbAst {
         cascade?: boolean;
         dropIfExists?: boolean;
     };
+    type Domain = {
+        type: 'domain';
+        action: 'create' | 'drop';
+        schema?: string;
+        name: string;
+        baseType: ColumnType;
+        notNull?: boolean;
+        collation?: string;
+        default?: RawExpression;
+        check?: RawExpression;
+        cascade?: boolean;
+    };
     type EnumOptions = {
         createIfNotExists?: boolean;
         dropIfExists?: boolean;

package/dist/index.js

@@ -302,8 +302,11 @@ var __spreadValues$5 = (a, b) => {
   return a;
 };
 var __spreadProps$4 = (a, b) => __defProps$4(a, __getOwnPropDescs$4(b));
+const columnTypeToSql = (item) => {
+  return item.data.isOfCustomType ? `"${item.toSQL()}"` : item.toSQL();
+};
 const columnToSql = (key, item, values, hasMultiplePrimaryKeys) => {
-  const line = [`"${item.data.name || key}" ${item.toSQL()}`];
+  const line = [`"${item.data.name || key}" ${columnTypeToSql(item)}`];
   if (item.data.compression) {
     line.push(`COMPRESSION ${item.data.compression}`);
   }
@@ -315,6 +318,9 @@ const columnToSql = (key, item, values, hasMultiplePrimaryKeys) => {
   } else if (!item.data.isNullable) {
     line.push("NOT NULL");
   }
+  if (item.data.check) {
+    line.push(`CHECK (${pqb.getRaw(item.data.check, values)})`);
+  }
   if (item.data.default !== void 0) {
     if (typeof item.data.default === "object" && item.data.default && orchidCore.isRaw(item.data.default)) {
       line.push(`DEFAULT ${pqb.getRaw(item.data.default, values)}`);
@@ -475,6 +481,9 @@ const primaryKeyToSql = (primaryKey) => {
 const tableMethods = {
   enum(name) {
     return new pqb.EnumColumn(this, name, []);
+  },
+  check(value) {
+    return new pqb.UnknownColumn(this).check(value);
   }
 };
 
@@ -502,7 +511,7 @@ var __spreadValues$4 = (a, b) => {
   return a;
 };
 var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
-var __objRest = (source, exclude) => {
+var __objRest$1 = (source, exclude) => {
   var target = {};
   for (var prop in source)
     if (__hasOwnProp$4.call(source, prop) && exclude.indexOf(prop) < 0)
@@ -530,7 +539,7 @@ const createTable$1 = async (migration, up, tableName, options, fn) => {
   validatePrimaryKey(ast);
   const queries = astToQueries$1(ast);
   for (const _a of queries) {
-    const _b = _a, { then } = _b, query = __objRest(_b, ["then"]);
+    const _b = _a, { then } = _b, query = __objRest$1(_b, ["then"]);
     const result = await migration.adapter.arrays(query);
     then == null ? void 0 : then(result);
   }
@@ -676,14 +685,7 @@ const mergeTableData = (a, b) => {
 };
 function add(item, options) {
   if (item instanceof pqb.ColumnType) {
-    if (this[orchidCore.nameKey]) {
-      item.data.name = this[orchidCore.nameKey];
-    }
-    return {
-      type: "add",
-      item,
-      dropMode: options == null ? void 0 : options.dropMode
-    };
+    return addOrDrop(this, "add", item, options);
   } else if (item === orchidCore.emptyObject) {
     mergeTableData(changeTableData.add, pqb.getTableData());
     pqb.resetTableData();
@@ -702,14 +704,7 @@ function add(item, options) {
 }
 const drop = function(item, options) {
   if (item instanceof pqb.ColumnType) {
-    if (this[orchidCore.nameKey]) {
-      item.data.name = this[orchidCore.nameKey];
-    }
-    return {
-      type: "drop",
-      item,
-      dropMode: options == null ? void 0 : options.dropMode
-    };
+    return addOrDrop(this, "drop", item, options);
   } else if (item === orchidCore.emptyObject) {
     mergeTableData(changeTableData.drop, pqb.getTableData());
     pqb.resetTableData();
@@ -726,6 +721,35 @@ const drop = function(item, options) {
     return result;
   }
 };
+const addOrDrop = (types, type, item, options) => {
+  if (types[orchidCore.nameKey]) {
+    item.data.name = types[orchidCore.nameKey];
+  }
+  if (item instanceof pqb.UnknownColumn) {
+    const empty = columnTypeToColumnChange({
+      type: "change",
+      from: {},
+      to: {}
+    });
+    const add2 = columnTypeToColumnChange({
+      type: "change",
+      from: {},
+      to: {
+        check: item.data.check
+      }
+    });
+    return __spreadValues$3({
+      type: "change",
+      from: type === "add" ? empty : add2,
+      to: type === "add" ? add2 : empty
+    }, options);
+  }
+  return {
+    type,
+    item,
+    dropMode: options == null ? void 0 : options.dropMode
+  };
+};
 const columnTypeToColumnChange = (item) => {
   if (item instanceof pqb.ColumnType) {
     const foreignKeys = item.data.foreignKeys;
@@ -877,12 +901,13 @@ const astToQueries = (ast) => {
   for (const key in ast.shape) {
     const item = ast.shape[key];
     if (item.type === "add") {
-      addColumnIndex(addIndexes, key, item.item);
-      addColumnComment(comments, key, item.item);
+      const column = item.item;
+      addColumnIndex(addIndexes, key, column);
+      addColumnComment(comments, key, column);
       alterTable.push(
         `ADD COLUMN ${columnToSql(
           key,
-          item.item,
+          column,
           values,
           addPrimaryKeys.columns.length > 1
         )}`
@@ -894,9 +919,10 @@ const astToQueries = (ast) => {
       );
     } else if (item.type === "change") {
       const { from, to } = item;
-      if (from.type !== to.type || from.collate !== to.collate) {
+      if (to.type && (from.type !== to.type || from.collate !== to.collate)) {
+        const type = !to.column || to.column.data.isOfCustomType ? `"${to.type}"` : to.type;
         alterTable.push(
-          `ALTER COLUMN "${item.name || key}" TYPE ${to.type}${to.collate ? ` COLLATE ${pqb.quote(to.collate)}` : ""}${item.using ? ` USING ${pqb.getRaw(item.using, values)}` : ""}`
+          `ALTER COLUMN "${item.name || key}" TYPE ${type}${to.collate ? ` COLLATE ${pqb.quote(to.collate)}` : ""}${item.using ? ` USING ${pqb.getRaw(item.using, values)}` : ""}`
         );
       }
       if (from.default !== to.default) {
@@ -914,6 +940,18 @@ const astToQueries = (ast) => {
           `ALTER COLUMN "${item.name || key}" SET COMPRESSION ${to.compression || "DEFAULT"}`
         );
       }
+      if (from.check !== to.check) {
+        const name = `${ast.name}_${item.name || key}_check`;
+        if (from.check) {
+          alterTable.push(`DROP CONSTRAINT "${name}"`);
+        }
+        if (to.check) {
+          alterTable.push(
+            `ADD CONSTRAINT "${name}"
+    CHECK (${pqb.getRaw(to.check, values)})`
+          );
+        }
+      }
       const foreignKeysLen = Math.max(
         ((_a = from.foreignKeys) == null ? void 0 : _a.length) || 0,
         ((_b = to.foreignKeys) == null ? void 0 : _b.length) || 0
@@ -1152,6 +1190,12 @@ class MigrationBase {
   dropEnum(name, values, options) {
     return createEnum$1(this, !this.up, name, values, options);
   }
+  createDomain(name, fn, options) {
+    return createDomain$1(this, this.up, name, fn, options);
+  }
+  dropDomain(name, fn, options) {
+    return createDomain$1(this, !this.up, name, fn, options);
+  }
   async tableExists(tableName) {
     return queryExists(this, {
       text: `SELECT 1 FROM "information_schema"."tables" WHERE "table_name" = $1`,
@@ -1246,6 +1290,34 @@ const createEnum$1 = async (migration, up, name, values, options = {}) => {
   await migration.adapter.query(query);
   migration.migratedAsts.push(ast);
 };
+const createDomain$1 = async (migration, up, name, fn, options) => {
+  const [schema, domainName] = getSchemaAndTableFromName(name);
+  const ast = __spreadValues$2({
+    type: "domain",
+    action: up ? "create" : "drop",
+    schema,
+    name: domainName,
+    baseType: fn(pqb.columnTypes)
+  }, options);
+  let query;
+  const values = [];
+  const quotedName = quoteWithSchema(ast);
+  if (ast.action === "create") {
+    query = `CREATE DOMAIN ${quotedName} AS ${columnTypeToSql(ast.baseType)}${ast.collation ? `
+COLLATION ${orchidCore.singleQuote(ast.collation)}` : ""}${ast.default ? `
+DEFAULT ${pqb.getRaw(ast.default, values)}` : ""}${ast.notNull || ast.check ? "\n" : ""}${[
+      ast.notNull && "NOT NULL",
+      ast.check && `CHECK ${pqb.getRaw(ast.check, values)}`
+    ].filter(Boolean).join(" ")}`;
+  } else {
+    query = `DROP DOMAIN ${quotedName}${ast.cascade ? " CASCADE" : ""}`;
+  }
+  await migration.adapter.query({
+    text: query,
+    values
+  });
+  migration.migratedAsts.push(ast);
+};
 const queryExists = (db, sql) => {
   return db.adapter.query(sql).then(({ rowCount }) => rowCount > 0);
 };
@@ -1864,6 +1936,63 @@ 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",
+  d.typname AS "name",
+  t.typname AS "type",
+  s.nspname AS "typeSchema",
+  .typnotnull AS "notNull",
+  d.typcategory = 'A' AS "isArray",
+  character_maximum_length AS "maxChars",
+  numeric_precision AS "numericPrecision",
+  numeric_scale AS "numericScale",
+  datetime_precision AS "dateTimePrecision",
+  collation_name AS "collation",
+  domain_default AS "default",
+  pg_get_expr(conbin, conrelid) AS "expression"
+FROM pg_catalog.pg_type d
+JOIN pg_catalog.pg_namespace n ON n.oid = d.typnamespace
+JOIN information_schema.domains i
+  ON i.domain_schema = nspname
+ AND i.domain_name = d.typname
+JOIN pg_catalog.pg_type t
+  ON (
+    CASE WHEN d.typcategory = 'A'
+      THEN t.typarray
+      ELSE t.oid
+    END
+  ) = d.typbasetype
+JOIN pg_catalog.pg_namespace s ON s.oid = t.typnamespace
+LEFT JOIN pg_catalog.pg_constraint c ON c.contypid = d.oid
+WHERE d.typtype = 'd' AND ${filterSchema("n.nspname")}`);
+    return rows;
+  }
 }
 
 var __defProp = Object.defineProperty;
@@ -1885,6 +2014,18 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
 class RakeDbEnumColumn extends pqb.EnumColumn {
   toCode(t) {
     return pqb.columnCode(this, t, `enum('${this.enumName}')`);
@@ -1928,10 +2069,21 @@ const structureToAst = async (db) => {
     }
     pendingTables[key] = { table, dependsOn };
   }
+  const domains = {};
+  for (const it of data.domains) {
+    domains[`${it.schemaName}.${it.name}`] = getColumn(data, domains, {
+      schemaName: it.schemaName,
+      name: it.name,
+      type: it.type,
+      typeSchema: it.typeSchema,
+      isArray: it.isArray,
+      isSerial: false
+    });
+  }
   for (const key in pendingTables) {
     const { table, dependsOn } = pendingTables[key];
     if (!dependsOn.size) {
-      pushTableAst(ast, data, table, pendingTables);
+      pushTableAst(ast, data, domains, table, pendingTables);
     }
   }
   const outerFKeys = [];
@@ -1953,6 +2105,19 @@ const structureToAst = async (db) => {
       values: it.values
     });
   }
+  for (const it of data.domains) {
+    ast.push({
+      type: "domain",
+      action: "create",
+      schema: it.schemaName === "public" ? void 0 : it.schemaName,
+      name: it.name,
+      baseType: domains[`${it.schemaName}.${it.name}`],
+      notNull: it.notNull,
+      collation: it.collation,
+      default: it.default ? orchidCore.raw(it.default) : void 0,
+      check: it.check ? orchidCore.raw(it.check) : void 0
+    });
+  }
   for (const key in pendingTables) {
     const innerFKeys = [];
     const { table } = pendingTables[key];
@@ -1966,7 +2131,7 @@ const structureToAst = async (db) => {
         outerFKeys.push([fkey, table]);
       }
     }
-    pushTableAst(ast, data, table, pendingTables, innerFKeys);
+    pushTableAst(ast, data, domains, table, pendingTables, innerFKeys);
   }
   for (const [fkey, table] of outerFKeys) {
     ast.push(__spreadProps(__spreadValues({}, foreignKeyToAst(fkey)), {
@@ -1987,7 +2152,9 @@ const getData = async (db) => {
     indexes,
     foreignKeys,
     extensions,
-    enums
+    enums,
+    checks,
+    domains
   ] = await Promise.all([
     db.getSchemas(),
     db.getTables(),
@@ -1996,7 +2163,9 @@ const getData = async (db) => {
     db.getIndexes(),
     db.getForeignKeys(),
     db.getExtensions(),
-    db.getEnums()
+    db.getEnums(),
+    db.getChecks(),
+    db.getDomains()
   ]);
   return {
     schemas,
@@ -2006,7 +2175,9 @@ const getData = async (db) => {
     indexes,
     foreignKeys,
     extensions,
-    enums
+    enums,
+    checks,
+    domains
   };
 };
 const makeBelongsToTable = (schema, table) => (item) => item.schemaName === schema && item.tableName === table;
@@ -2020,12 +2191,52 @@ const getIsSerial = (item) => {
   }
   return false;
 };
+const getColumn = (data, domains, _a) => {
+  var _b = _a, {
+    schemaName,
+    tableName,
+    name,
+    type,
+    typeSchema,
+    isArray,
+    isSerial
+  } = _b, params = __objRest(_b, [
+    "schemaName",
+    "tableName",
+    "name",
+    "type",
+    "typeSchema",
+    "isArray",
+    "isSerial"
+  ]);
+  let column;
+  const klass = pqb.columnsByType[getColumnType(type, isSerial)];
+  if (klass) {
+    column = pqb.instantiateColumn(klass, params);
+  } else {
+    const domainColumn = domains[`${typeSchema}.${type}`];
+    if (domainColumn) {
+      column = new pqb.DomainColumn({}, type).as(domainColumn);
+    } else {
+      const enumType = data.enums.find(
+        (item) => item.name === type && item.schemaName === typeSchema
+      );
+      if (!enumType) {
+        throw new Error(
+          `Cannot handle ${tableName ? "column" : "domain"} ${schemaName}${tableName ? `.${tableName}` : ""}.${name}: column type \`${type}\` is not supported`
+        );
+      }
+      column = new RakeDbEnumColumn({}, type, enumType.values);
+    }
+  }
+  return isArray ? new pqb.ArrayColumn({}, column) : column;
+};
 const getColumnType = (type, isSerial) => {
   if (!isSerial)
     return type;
   return type === "int2" ? "smallserial" : type === "int4" ? "serial" : "bigserial";
 };
-const pushTableAst = (ast, data, table, pendingTables, innerFKeys = data.foreignKeys) => {
+const pushTableAst = (ast, data, domains, table, pendingTables, innerFKeys = data.foreignKeys) => {
   const { schemaName, name } = table;
   const key = `${schemaName}.${table.name}`;
   delete pendingTables[key];
@@ -2036,32 +2247,24 @@ const pushTableAst = (ast, data, table, pendingTables, innerFKeys = data.foreign
   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;
+    }
+  }
   const shape = {};
   for (let item of columns) {
     const isSerial = getIsSerial(item);
     if (isSerial) {
       item = __spreadProps(__spreadValues({}, item), { default: void 0 });
     }
-    let column;
     const isArray = item.dataType === "ARRAY";
-    const type = isArray ? item.type.slice(1) : item.type;
-    const klass = pqb.columnsByType[getColumnType(type, isSerial)];
-    if (klass) {
-      column = pqb.instantiateColumn(klass, item);
-    } else {
-      const { type: type2, typeSchema } = item;
-      const enumType = data.enums.find(
-        (item2) => item2.name === type2 && item2.schemaName === typeSchema
-      );
-      if (!enumType) {
-        throw new Error(
-          `Cannot handle column ${item.schemaName}.${item.tableName}.${item.name}: column type \`${item.type}\` is not supported`
-        );
-      }
-      column = new RakeDbEnumColumn({}, type2, enumType.values);
-    }
-    if (isArray)
-      column = new pqb.ArrayColumn({}, column);
+    let column = getColumn(data, domains, __spreadProps(__spreadValues({}, item), {
+      type: isArray ? item.type.slice(1) : item.type,
+      isArray,
+      isSerial
+    }));
     if ((primaryKey == null ? void 0 : primaryKey.columnNames.length) === 1 && (primaryKey == null ? void 0 : primaryKey.columnNames[0]) === item.name) {
       column = column.primaryKey();
     }
@@ -2098,6 +2301,10 @@ const pushTableAst = (ast, data, table, pendingTables, innerFKeys = data.foreign
         }
       );
     }
+    const check = columnChecks[item.name];
+    if (check) {
+      column.data.check = orchidCore.raw(check.expression);
+    }
     delete column.data.name;
     shape[item.name] = column;
   }
@@ -2136,7 +2343,7 @@ const pushTableAst = (ast, data, table, pendingTables, innerFKeys = data.foreign
   for (const otherKey in pendingTables) {
     const item = pendingTables[otherKey];
     if (item.dependsOn.delete(key) && item.dependsOn.size === 0) {
-      pushTableAst(ast, data, item.table, pendingTables);
+      pushTableAst(ast, data, domains, item.table, pendingTables);
     }
   }
 };
@@ -2166,7 +2373,11 @@ const astToMigration = (config, ast) => {
     } else if (item.type === "enum" && item.action === "create") {
       if (first.length)
         first.push([]);
-      first.push(...createEnum(item));
+      first.push(createEnum(item));
+    } else if (item.type === "domain" && item.action === "create") {
+      if (first.length)
+        first.push([]);
+      first.push(...createDomain(item));
     } else if (item.type === "table" && item.action === "create") {
       tables.push(createTable(config, item));
     } else if (item.type === "foreignKey") {
@@ -2223,12 +2434,26 @@ const createExtension = (ast) => {
   return code;
 };
 const createEnum = (ast) => {
+  return `await db.createEnum(${quoteSchemaTable(ast)}, [${ast.values.map(orchidCore.singleQuote).join(", ")}]);`;
+};
+const createDomain = (ast) => {
   const code = [
-    `await db.createEnum(${orchidCore.singleQuote(ast.name)}, [${ast.values.map(orchidCore.singleQuote).join(", ")}]`
+    `await db.createDomain(${quoteSchemaTable(
+      ast
+    )}, (t) => ${ast.baseType.toCode("t")}`
   ];
-  if (ast.schema) {
+  if (ast.notNull || ast.collation || ast.default || ast.check) {
+    const props = [];
+    if (ast.notNull)
+      props.push(`notNull: true,`);
+    if (ast.collation)
+      props.push(`collation: ${orchidCore.singleQuote(ast.collation)},`);
+    if (ast.default)
+      props.push(`default: ${pqb.rawToCode("db", ast.default)},`);
+    if (ast.check)
+      props.push(`check: ${pqb.rawToCode("db", ast.check)},`);
     orchidCore.addCode(code, ", {");
-    code.push([`schema: ${orchidCore.singleQuote(ast.schema)},`]);
+    code.push(props);
     orchidCore.addCode(code, "}");
   }
   orchidCore.addCode(code, ");");