rake-db 2.2.4 → 2.2.6

package/src/migration/migrationUtils.ts

@@ -10,7 +10,12 @@ import {
   toArray,
 } from 'pqb';
 import { ColumnComment, Migration } from './migration';
-import { joinColumns, joinWords, quoteTable } from '../common';
+import {
+  getSchemaAndTableFromName,
+  joinColumns,
+  joinWords,
+  quoteWithSchema,
+} from '../common';
 
 export const columnToSql = (
   key: string,
@@ -30,7 +35,7 @@ export const columnToSql = (
 
   if (item.isPrimaryKey && !hasMultiplePrimaryKeys) {
     line.push('PRIMARY KEY');
-  } else if (!item.isNullable) {
+  } else if (!item.data.isNullable) {
     line.push('NOT NULL');
   }
 
@@ -48,7 +53,7 @@ export const columnToSql = (
 
   const { foreignKey } = item.data;
   if (foreignKey) {
-    const table = getForeignKeyTable(
+    const [schema, table] = getForeignKeyTable(
       'fn' in foreignKey ? foreignKey.fn : foreignKey.table,
     );
 
@@ -56,7 +61,7 @@ export const columnToSql = (
       line.push(`CONSTRAINT "${foreignKey.name}"`);
     }
 
-    line.push(referencesToSql(table, foreignKey.columns, foreignKey));
+    line.push(referencesToSql(schema, table, foreignKey.columns, foreignKey));
   }
 
   return line.join(' ');
@@ -89,42 +94,49 @@ export const addColumnComment = (
 
 export const getForeignKeyTable = (
   fnOrTable: (() => ForeignKeyTable) | string,
-) => {
+): [string | undefined, string] => {
   if (typeof fnOrTable === 'string') {
-    return fnOrTable;
+    return getSchemaAndTableFromName(fnOrTable);
   }
 
-  const klass = fnOrTable();
-  return new klass().table;
+  const item = new (fnOrTable())();
+  return [item.schema, item.table];
 };
 
 export const constraintToSql = (
-  tableName: string,
+  { name }: { schema?: string; name: string },
   up: boolean,
   foreignKey: TableData['foreignKeys'][number],
 ) => {
   const constraintName =
-    foreignKey.options.name ||
-    `${tableName}_${foreignKey.columns.join('_')}_fkey`;
+    foreignKey.options.name || `${name}_${foreignKey.columns.join('_')}_fkey`;
 
   if (!up) {
     const { dropMode } = foreignKey.options;
     return `CONSTRAINT "${constraintName}"${dropMode ? ` ${dropMode}` : ''}`;
   }
 
-  const table = getForeignKeyTable(foreignKey.fnOrTable);
+  const [schema, table] = getForeignKeyTable(foreignKey.fnOrTable);
   return `CONSTRAINT "${constraintName}" FOREIGN KEY (${joinColumns(
     foreignKey.columns,
-  )}) ${referencesToSql(table, foreignKey.foreignColumns, foreignKey.options)}`;
+  )}) ${referencesToSql(
+    schema,
+    table,
+    foreignKey.foreignColumns,
+    foreignKey.options,
+  )}`;
 };
 
 export const referencesToSql = (
+  schema: string | undefined,
   table: string,
   columns: string[],
   foreignKey: Pick<ForeignKeyOptions, 'match' | 'onDelete' | 'onUpdate'>,
 ) => {
   const sql: string[] = [
-    `REFERENCES ${quoteTable(table)}(${joinColumns(columns)})`,
+    `REFERENCES ${quoteWithSchema({ schema, name: table })}(${joinColumns(
+      columns,
+    )})`,
   ];
 
   if (foreignKey.match) {
@@ -144,13 +156,13 @@ export const referencesToSql = (
 
 export const indexesToQuery = (
   up: boolean,
-  tableName: string,
+  { schema, name }: { schema?: string; name: string },
   indexes: TableData.Index[],
 ): Sql[] => {
   return indexes.map(({ columns, options }) => {
     const indexName =
       options.name ||
-      joinWords(tableName, ...columns.map(({ column }) => column), 'index');
+      joinWords(name, ...columns.map(({ column }) => column), 'index');
 
     if (!up) {
       return {
@@ -169,7 +181,7 @@ export const indexesToQuery = (
       sql.push('UNIQUE');
     }
 
-    sql.push(`INDEX "${indexName}" ON ${quoteTable(tableName)}`);
+    sql.push(`INDEX "${indexName}" ON ${quoteWithSchema({ schema, name })}`);
 
     if (options.using) {
       sql.push(`USING ${options.using}`);
@@ -234,13 +246,13 @@ export const indexesToQuery = (
 };
 
 export const commentsToQuery = (
-  tableName: string,
+  schemaTable: { schema?: string; name: string },
   comments: ColumnComment[],
 ): Sql[] => {
   return comments.map(({ column, comment }) => ({
-    text: `COMMENT ON COLUMN ${quoteTable(tableName)}."${column}" IS ${quote(
-      comment,
-    )}`,
+    text: `COMMENT ON COLUMN ${quoteWithSchema(
+      schemaTable,
+    )}."${column}" IS ${quote(comment)}`,
     values: [],
   }));
 };

package/src/pull/dbStructure.test.ts

@@ -0,0 +1,158 @@
+import { DbStructure } from './dbStructure';
+import { Adapter } from 'pqb';
+
+const adapter = new Adapter({
+  databaseURL: 'file:path',
+});
+let rows: unknown[][] | Record<string, unknown>[] = [];
+adapter.query = jest.fn().mockImplementation(() => ({ rows }));
+adapter.arrays = jest.fn().mockImplementation(() => ({ rows }));
+const db = new DbStructure(adapter);
+
+describe('dbStructure', () => {
+  describe('getSchemas', () => {
+    it('should return schemas', async () => {
+      rows = [['a'], ['b']];
+      const result = await db.getSchemas();
+      expect(result).toEqual(['a', 'b']);
+    });
+  });
+
+  describe('getTables', () => {
+    it('should return tables', async () => {
+      rows = [{ schemaName: 'schema', name: 'table' }];
+      const result = await db.getTables();
+      expect(result).toEqual(rows);
+    });
+  });
+
+  describe('getViews', () => {
+    it('should return views', async () => {
+      rows = [{ schemaName: 'schema', name: 'view' }];
+      const result = await db.getViews();
+      expect(result).toEqual(rows);
+    });
+  });
+
+  describe('getProcedures', () => {
+    it('should return procedures', async () => {
+      rows = [
+        {
+          schemaName: 'public',
+          name: 'name',
+          returnSet: true,
+          returnType: 'int4',
+          kind: 'f',
+          isTrigger: false,
+          types: ['int4', 'int4', 'int4'],
+          argTypes: [23, 23, 23],
+          argModes: ['i', 'i', 'o'],
+          argNames: ['a', 'b', 'c'],
+        },
+      ];
+      const result = await db.getProcedures();
+      expect(result).toEqual(rows);
+    });
+  });
+
+  describe('getColumns', () => {
+    it('should return columns', async () => {
+      rows = [
+        {
+          schemaName: 'public',
+          tableName: 'table',
+          name: 'name',
+          type: 'int4',
+          default: '123',
+          isNullable: false,
+        },
+      ];
+      const result = await db.getColumns();
+      expect(result).toEqual(rows);
+    });
+  });
+
+  describe('getIndexes', () => {
+    it('should return indexes', async () => {
+      rows = [
+        {
+          schemaName: 'public',
+          tableName: 'table',
+          columnNames: ['column'],
+          name: 'indexName',
+          isUnique: true,
+          isPrimary: true,
+        },
+      ];
+      const result = await db.getIndexes();
+      expect(result).toEqual(rows);
+    });
+  });
+
+  describe('getForeignKeys', () => {
+    it('should return foreignKeys', async () => {
+      rows = [
+        {
+          schemaName: 'public',
+          tableName: 'table',
+          foreignTableSchemaName: 'public',
+          foreignTableName: 'foreignTable',
+          name: 'name',
+          columnNames: ['column'],
+          foreignColumnNames: ['foreignColumn'],
+        },
+      ];
+      const result = await db.getForeignKeys();
+      expect(result).toEqual(rows);
+    });
+  });
+
+  describe('getConstraints', () => {
+    it('should return constraints', async () => {
+      rows = [
+        {
+          schemaName: 'public',
+          tableName: 'table',
+          name: 'name',
+          type: 'PRIMARY KEY',
+          columnNames: ['id'],
+        },
+      ];
+      const result = await db.getConstraints();
+      expect(result).toEqual(rows);
+    });
+  });
+
+  describe('getTriggers', () => {
+    it('should return triggers', async () => {
+      rows = [
+        {
+          schemaName: 'public',
+          tableName: 'table',
+          triggerSchema: 'public',
+          name: 'name',
+          events: ['UPDATE'],
+          activation: 'BEFORE',
+          condition: null,
+          definition: 'EXECUTE FUNCTION name()',
+        },
+      ];
+      const result = await db.getTriggers();
+      expect(result).toEqual(rows);
+    });
+  });
+
+  describe('getExtensions', () => {
+    it('should return extensions', async () => {
+      rows = [
+        {
+          schemaName: 'public',
+          name: 'pg_trgm',
+          version: '1.6',
+        },
+      ];
+      const result = await db.getExtensions();
+      expect(result).toEqual(rows);
+    });
+  });
+});

package/src/pull/dbStructure.ts

@@ -0,0 +1,272 @@
+import { Adapter } from 'pqb';
+
+export namespace DbStructure {
+  export type Table = {
+    schemaName: string;
+    name: string;
+  };
+
+  export type View = {
+    schemaName: string;
+    name: string;
+  };
+
+  export type Procedure = {
+    schemaName: string;
+    name: string;
+    returnSet: boolean;
+    returnType: string;
+    kind: string;
+    isTrigger: boolean;
+    types: string[];
+    argTypes: string[];
+    argModes: ('i' | 'o')[];
+    argNames?: string[];
+  };
+
+  export type Column = {
+    schemaName: string;
+    tableName: string;
+    name: string;
+    type: string;
+    maxChars?: number;
+    numericPrecision?: number;
+    numericScale?: number;
+    dateTimePrecision?: number;
+    default?: string;
+    isNullable: boolean;
+  };
+
+  export type Index = {
+    schemaName: string;
+    tableName: string;
+    columnNames: string[];
+    name: string;
+    isUnique: boolean;
+    isPrimary: boolean;
+  };
+
+  export type ForeignKey = {
+    schemaName: string;
+    tableName: string;
+    foreignTableSchemaName: string;
+    foreignTableName: string;
+    name: string;
+    columnNames: string[];
+    foreignColumnNames: string[];
+  };
+
+  export type Constraint = {
+    schemaName: string;
+    tableName: string;
+    name: string;
+    type: 'CHECK' | 'FOREIGN KEY' | 'PRIMARY KEY' | 'UNIQUE';
+    columnNames: string[];
+  };
+
+  export type Trigger = {
+    schemaName: string;
+    tableName: string;
+    triggerSchema: string;
+    name: string;
+    events: string[];
+    activation: string;
+    condition?: string;
+    definition: string;
+  };
+
+  export type Extension = {
+    schemaName: string;
+    name: string;
+    version?: string;
+  };
+}
+
+const filterSchema = (table: string) =>
+  `${table} !~ '^pg_' AND ${table} != 'information_schema'`;
+
+export class DbStructure {
+  constructor(private db: Adapter) {}
+
+  async getSchemas(): Promise<string[]> {
+    const { rows } = await this.db.arrays<[string]>(
+      `SELECT n.nspname "name"
+FROM pg_catalog.pg_namespace n
+WHERE ${filterSchema('n.nspname')}
+ORDER BY "name"`,
+    );
+    return rows.flat();
+  }
+
+  async getTables() {
+    const { rows } = await this.db.query<DbStructure.Table>(
+      `SELECT
+  table_schema "schemaName",
+  table_name "name"
+FROM information_schema.tables
+WHERE table_type = 'BASE TABLE'
+  AND ${filterSchema('table_schema')}
+ORDER BY table_name`,
+    );
+    return rows;
+  }
+
+  async getViews() {
+    const { rows } = await this.db.query<DbStructure.View[]>(
+      `SELECT
+  table_schema "schemaName",
+  table_name "name"
+FROM information_schema.tables
+WHERE table_type = 'VIEW'
+  AND ${filterSchema('table_schema')}
+ORDER BY table_name`,
+    );
+    return rows;
+  }
+
+  async getProcedures() {
+    const { rows } = await this.db.query<DbStructure.Procedure[]>(
+      `SELECT
+  n.nspname AS "schemaName",
+  proname AS name,
+  proretset AS "returnSet",
+  (
+    SELECT typname FROM pg_type WHERE oid = prorettype
+  ) AS "returnType",
+  prokind AS "kind",
+  coalesce((
+    SELECT true FROM information_schema.triggers
+    WHERE n.nspname = trigger_schema AND trigger_name = proname
+    LIMIT 1
+  ), false) AS "isTrigger",
+  coalesce((
+    SELECT json_agg(pg_type.typname)
+    FROM unnest(coalesce(proallargtypes, proargtypes)) typeId
+    JOIN pg_type ON pg_type.oid = typeId
+  ), '[]') AS "types",
+  coalesce(to_json(proallargtypes::int[]), to_json(proargtypes::int[])) AS "argTypes",
+  coalesce(to_json(proargmodes), '[]') AS "argModes",
+  to_json(proargnames) AS "argNames"
+FROM pg_proc p
+JOIN pg_namespace n ON p.pronamespace = n.oid
+WHERE ${filterSchema('n.nspname')}`,
+    );
+    return rows;
+  }
+
+  async getColumns() {
+    const { rows } = await this.db.query<DbStructure.Column>(
+      `SELECT table_schema "schemaName",
+  table_name "tableName",
+  column_name "name",
+  udt_name "type",
+  character_maximum_length AS "maxChars",
+  numeric_precision AS "numericPrecision",
+  numeric_scale AS "numericScale",
+  datetime_precision AS "dateTimePrecision",
+  column_default "default",
+  is_nullable::boolean "isNullable"
+FROM information_schema.columns
+WHERE ${filterSchema('table_schema')}
+ORDER BY ordinal_position`,
+    );
+    return rows;
+  }
+
+  async getIndexes() {
+    const { rows } = await this.db.query<DbStructure.Index>(
+      `SELECT
+  nspname "schemaName",
+  t.relname "tableName",
+  json_agg(attname) "columnNames",
+  ic.relname "name",
+  indisunique "isUnique",
+  indisprimary "isPrimary"
+FROM pg_index
+JOIN pg_class t ON t.oid = indrelid
+JOIN pg_namespace n ON n.oid = t.relnamespace
+JOIN pg_attribute ON attrelid = t.oid AND attnum = any(indkey)
+JOIN pg_class ic ON ic.oid = indexrelid
+WHERE ${filterSchema('n.nspname')}
+GROUP BY "schemaName", "tableName", "name", "isUnique", "isPrimary"
+ORDER BY "name"`,
+    );
+    return rows;
+  }
+
+  async getForeignKeys() {
+    const { rows } = await this.db.query<DbStructure.ForeignKey>(
+      `SELECT tc.table_schema AS "schemaName",
+  tc.table_name AS "tableName",
+  ccu.table_schema AS "foreignTableSchemaName",
+  ccu.table_name AS "foreignTableName",
+  tc.constraint_name AS "name",
+  (
+    SELECT json_agg(kcu.column_name)
+    FROM information_schema.key_column_usage kcu
+    WHERE kcu.constraint_name = tc.constraint_name
+      AND kcu.table_schema = tc.table_schema
+  ) AS "columnNames",
+  json_agg(ccu.column_name) AS "foreignColumnNames"
+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 = 'FOREIGN KEY'
+  AND ${filterSchema('tc.table_schema')}
+GROUP BY "schemaName", "tableName", "name", "foreignTableSchemaName", "foreignTableName"
+ORDER BY "name"`,
+    );
+    return rows;
+  }
+
+  async getConstraints() {
+    const { rows } = await this.db.query<DbStructure.Constraint>(
+      `SELECT tc.table_schema AS "schemaName",
+  tc.table_name AS "tableName",
+  tc.constraint_name AS "name",
+  tc.constraint_type AS "type",
+  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 != 'FOREIGN KEY'
+  AND ${filterSchema('tc.table_schema')}
+GROUP BY "schemaName", "tableName", "name", "type"
+ORDER BY "name"`,
+    );
+    return rows;
+  }
+
+  async getTriggers() {
+    const { rows } = await this.db.query<DbStructure.Trigger>(
+      `SELECT event_object_schema AS "schemaName",
+  event_object_table AS "tableName",
+  trigger_schema AS "triggerSchema",
+  trigger_name AS name,
+  json_agg(event_manipulation) AS events,
+  action_timing AS activation,
+  action_condition AS condition,
+  action_statement AS definition
+FROM information_schema.triggers
+WHERE ${filterSchema('event_object_schema')}
+GROUP BY event_object_schema, event_object_table, trigger_schema, trigger_name, action_timing, action_condition, action_statement
+ORDER BY trigger_name`,
+    );
+    return rows;
+  }
+
+  async getExtensions() {
+    const { rows } = await this.db.query<DbStructure.Extension>(
+      `SELECT
+  nspname AS "schemaName",
+  extname AS "name",
+  extversion AS version
+FROM pg_extension
+JOIN pg_catalog.pg_namespace n ON n.oid = extnamespace
+ AND ${filterSchema('n.nspname')}`,
+    );
+    return rows;
+  }
+}

package/src/pull/getColumnByType.ts

@@ -0,0 +1,15 @@
+import { ColumnType, ColumnTypesBase } from 'pqb';
+
+export const getColumnsByTypesMap = (types: ColumnTypesBase) => {
+  const map: Record<string, new () => ColumnType> = {};
+  for (const key in types) {
+    const type = types[key] as unknown as new () => ColumnType;
+    if (type instanceof ColumnType) {
+      map[type.dataType] = type;
+      if (type.typeAlias) {
+        map[type.typeAlias] = type;
+      }
+    }
+  }
+  return map;
+};