rake-db 2.4.8 → 2.4.9

package/dist/index.d.ts

@@ -85,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';
@@ -179,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}`);
   }
@@ -508,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)
@@ -536,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);
   }
@@ -917,8 +920,9 @@ const astToQueries = (ast) => {
     } else if (item.type === "change") {
       const { from, to } = item;
       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) {
@@ -1186,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`,
@@ -1280,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);
 };
@@ -1923,6 +1961,38 @@ ORDER BY c.conname`);
     }
     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;
@@ -1944,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}')`);
@@ -1987,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 = [];
@@ -2012,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];
@@ -2025,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)), {
@@ -2047,7 +2153,8 @@ const getData = async (db) => {
     foreignKeys,
     extensions,
     enums,
-    checks
+    checks,
+    domains
   ] = await Promise.all([
     db.getSchemas(),
     db.getTables(),
@@ -2057,7 +2164,8 @@ const getData = async (db) => {
     db.getForeignKeys(),
     db.getExtensions(),
     db.getEnums(),
-    db.getChecks()
+    db.getChecks(),
+    db.getDomains()
   ]);
   return {
     schemas,
@@ -2068,7 +2176,8 @@ const getData = async (db) => {
     foreignKeys,
     extensions,
     enums,
-    checks
+    checks,
+    domains
   };
 };
 const makeBelongsToTable = (schema, table) => (item) => item.schemaName === schema && item.tableName === table;
@@ -2082,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];
@@ -2110,26 +2259,12 @@ const pushTableAst = (ast, data, table, pendingTables, innerFKeys = data.foreign
     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();
     }
@@ -2208,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);
     }
   }
 };
@@ -2238,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") {
@@ -2295,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, ");");