rake-db 2.3.30 → 2.3.32

package/src/migration/migrationUtils.ts

@@ -1,307 +0,0 @@
-import {
-  ColumnType,
-  ForeignKeyTable,
-  ForeignKeyOptions,
-  getRaw,
-  isRaw,
-  quote,
-  Sql,
-  TableData,
-  toArray,
-} from 'pqb';
-import { ColumnComment, Migration } from './migration';
-import {
-  getSchemaAndTableFromName,
-  joinColumns,
-  quoteWithSchema,
-} from '../common';
-
-export const columnToSql = (
-  key: string,
-  item: ColumnType,
-  values: unknown[],
-  hasMultiplePrimaryKeys: boolean,
-): string => {
-  const line = [`"${key}" ${item.toSQL()}`];
-
-  if (item.data.compression) {
-    line.push(`COMPRESSION ${item.data.compression}`);
-  }
-
-  if (item.data.collate) {
-    line.push(`COLLATE ${quote(item.data.collate)}`);
-  }
-
-  if (item.isPrimaryKey && !hasMultiplePrimaryKeys) {
-    line.push('PRIMARY KEY');
-  } else if (!item.data.isNullable) {
-    line.push('NOT NULL');
-  }
-
-  if (item.data.default !== undefined) {
-    if (
-      typeof item.data.default === 'object' &&
-      item.data.default &&
-      isRaw(item.data.default)
-    ) {
-      line.push(`DEFAULT ${getRaw(item.data.default, values)}`);
-    } else {
-      line.push(`DEFAULT ${quote(item.data.default)}`);
-    }
-  }
-
-  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));
-    }
-  }
-
-  return line.join(' ');
-};
-
-export const addColumnIndex = (
-  indexes: TableData.Index[],
-  key: string,
-  item: ColumnType,
-) => {
-  if (item.data.indexes) {
-    indexes.push(
-      ...item.data.indexes.map((index) => ({
-        columns: [{ ...index, column: key }],
-        options: index,
-      })),
-    );
-  }
-};
-
-export const addColumnComment = (
-  comments: ColumnComment[],
-  key: string,
-  item: ColumnType,
-) => {
-  if (item.data.comment) {
-    comments.push({ column: key, comment: item.data.comment });
-  }
-};
-
-export const getForeignKeyTable = (
-  fnOrTable: (() => ForeignKeyTable) | string,
-): [string | undefined, string] => {
-  if (typeof fnOrTable === 'string') {
-    return getSchemaAndTableFromName(fnOrTable);
-  }
-
-  const item = new (fnOrTable())();
-  return [item.schema, item.table];
-};
-
-export const getForeignKeyName = (table: string, columns: string[]) => {
-  return `${table}_${columns.join('_')}_fkey`;
-};
-
-export const constraintToSql = (
-  { name }: { schema?: string; name: string },
-  up: boolean,
-  foreignKey: TableData['foreignKeys'][number],
-) => {
-  const constraintName =
-    foreignKey.options.name || getForeignKeyName(name, foreignKey.columns);
-
-  if (!up) {
-    const { dropMode } = foreignKey.options;
-    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,
-  )}`;
-};
-
-export const referencesToSql = (
-  schema: string | undefined,
-  table: string,
-  columns: string[],
-  foreignKey: Pick<ForeignKeyOptions, 'match' | 'onDelete' | 'onUpdate'>,
-) => {
-  const sql: string[] = [
-    `REFERENCES ${quoteWithSchema({ schema, name: table })}(${joinColumns(
-      columns,
-    )})`,
-  ];
-
-  if (foreignKey.match) {
-    sql.push(`MATCH ${foreignKey.match.toUpperCase()}`);
-  }
-
-  if (foreignKey.onDelete) {
-    sql.push(`ON DELETE ${foreignKey.onDelete.toUpperCase()}`);
-  }
-
-  if (foreignKey.onUpdate) {
-    sql.push(`ON UPDATE ${foreignKey.onUpdate.toUpperCase()}`);
-  }
-
-  return sql.join(' ');
-};
-
-export const getIndexName = (
-  table: string,
-  columns: TableData.Index['columns'],
-) => {
-  return `${table}_${columns
-    .map((it) =>
-      'column' in it
-        ? it.column
-        : it.expression.match(/\w+/g)?.join('_') || 'expression',
-    )
-    .join('_')}_idx`;
-};
-
-export const indexesToQuery = (
-  up: boolean,
-  { schema, name }: { schema?: string; name: string },
-  indexes: TableData.Index[],
-): Sql[] => {
-  return indexes.map(({ columns, options }) => {
-    const indexName = options.name || getIndexName(name, columns);
-
-    if (!up) {
-      return {
-        text: `DROP INDEX "${indexName}"${
-          options.dropMode ? ` ${options.dropMode}` : ''
-        }`,
-        values: [],
-      };
-    }
-
-    const values: unknown[] = [];
-
-    const sql: string[] = ['CREATE'];
-
-    if (options.unique) {
-      sql.push('UNIQUE');
-    }
-
-    sql.push(`INDEX "${indexName}" ON ${quoteWithSchema({ schema, name })}`);
-
-    if (options.using) {
-      sql.push(`USING ${options.using}`);
-    }
-
-    const columnsSql: string[] = [];
-
-    columns.forEach((column) => {
-      const columnSql: string[] = [
-        'column' in column ? `"${column.column}"` : `(${column.expression})`,
-      ];
-
-      if (column.collate) {
-        columnSql.push(`COLLATE '${column.collate}'`);
-      }
-
-      if (column.opclass) {
-        columnSql.push(column.opclass);
-      }
-
-      if (column.order) {
-        columnSql.push(column.order);
-      }
-
-      columnsSql.push(columnSql.join(' '));
-    });
-
-    sql.push(`(${columnsSql.join(', ')})`);
-
-    if (options.include) {
-      sql.push(
-        `INCLUDE (${toArray(options.include)
-          .map((column) => `"${column}"`)
-          .join(', ')})`,
-      );
-    }
-
-    if (options.with) {
-      sql.push(`WITH (${options.with})`);
-    }
-
-    if (options.tablespace) {
-      sql.push(`TABLESPACE ${options.tablespace}`);
-    }
-
-    if (options.where) {
-      sql.push(
-        `WHERE ${
-          typeof options.where === 'object' &&
-          options.where &&
-          isRaw(options.where)
-            ? getRaw(options.where, values)
-            : options.where
-        }`,
-      );
-    }
-
-    return { text: sql.join(' '), values };
-  });
-};
-
-export const commentsToQuery = (
-  schemaTable: { schema?: string; name: string },
-  comments: ColumnComment[],
-): Sql[] => {
-  return comments.map(({ column, comment }) => ({
-    text: `COMMENT ON COLUMN ${quoteWithSchema(
-      schemaTable,
-    )}."${column}" IS ${quote(comment)}`,
-    values: [],
-  }));
-};
-
-export const primaryKeyToSql = (
-  primaryKey: Exclude<TableData['primaryKey'], undefined>,
-) => {
-  const name = primaryKey.options?.name;
-  return `${name ? `CONSTRAINT "${name}" ` : ''}PRIMARY KEY (${joinColumns(
-    primaryKey.columns,
-  )})`;
-};
-
-export const getPrimaryKeysOfTable = async (
-  db: Migration,
-  tableName: string,
-): Promise<{ name: string; type: string }[]> => {
-  const { rows } = await db.adapter.query<{ name: string; type: string }>(
-    {
-      text: `SELECT
-  pg_attribute.attname AS name,
-  format_type(pg_attribute.atttypid, pg_attribute.atttypmod) AS type
-FROM pg_index, pg_class, pg_attribute, pg_namespace
-WHERE
-  pg_class.oid = $1::regclass AND
-  indrelid = pg_class.oid AND
-  nspname = 'public' AND
-  pg_class.relnamespace = pg_namespace.oid AND
-  pg_attribute.attrelid = pg_class.oid AND
-  pg_attribute.attnum = any(pg_index.indkey) AND
-  indisprimary`,
-      values: [tableName],
-    },
-    db.adapter.types,
-  );
-
-  return rows;
-};

package/src/migration/tableMethods.ts

@@ -1,8 +0,0 @@
-import { EnumColumn, raw } from 'pqb';
-
-export const tableMethods = {
-  raw,
-  enum: (name: string) =>
-    // empty array will be filled during the migration by querying db
-    new EnumColumn(name, [] as unknown as [string, ...string[]]),
-};

package/src/pull/astToMigration.test.ts

@@ -1,275 +0,0 @@
-import { astToMigration } from './astToMigration';
-import { columnTypes } from 'pqb';
-import { RakeDbAst } from '../ast';
-
-const template = (content: string) => `import { change } from 'rake-db';
-
-change(async (db) => {
-${content}
-});
-`;
-
-const schema: RakeDbAst.Schema = {
-  type: 'schema',
-  action: 'create',
-  name: 'schemaName',
-};
-
-const extension: RakeDbAst.Extension = {
-  type: 'extension',
-  action: 'create',
-  name: 'extensionName',
-};
-
-const enumType: RakeDbAst.Enum = {
-  type: 'enum',
-  action: 'create',
-  name: 'mood',
-  values: ['sad', 'ok', 'happy'],
-};
-
-const table: RakeDbAst.Table = {
-  type: 'table',
-  action: 'create',
-  schema: 'schema',
-  name: 'table',
-  noPrimaryKey: 'ignore',
-  indexes: [],
-  foreignKeys: [],
-  shape: {
-    id: columnTypes.serial().primaryKey(),
-  },
-};
-
-const foreignKey: RakeDbAst.ForeignKey = {
-  type: 'foreignKey',
-  action: 'create',
-  tableName: 'table',
-  columns: ['otherId'],
-  fnOrTable: 'otherTable',
-  foreignColumns: ['id'],
-  options: {},
-};
-
-describe('astToMigration', () => {
-  beforeEach(jest.clearAllMocks);
-
-  it('should return undefined when ast is empty', () => {
-    const result = astToMigration([]);
-
-    expect(result).toBe(undefined);
-  });
-
-  it('should put schema, extension, enum to first change, tables to separate changes, foreignKeys in last change', () => {
-    const result = astToMigration([
-      schema,
-      extension,
-      enumType,
-      table,
-      { ...table, name: 'other' },
-      foreignKey,
-    ]);
-
-    expect(result).toBe(`import { change } from 'rake-db';
-
-change(async (db) => {
-  await db.createSchema('schemaName');
-
-  await db.createExtension('extensionName');
-
-  await db.createEnum('mood', ['sad', 'ok', 'happy']);
-});
-
-change(async (db) => {
-  await db.createTable('schema.table', (t) => ({
-    id: t.serial().primaryKey(),
-  }));
-});
-
-change(async (db) => {
-  await db.createTable('schema.other', (t) => ({
-    id: t.serial().primaryKey(),
-  }));
-});
-
-change(async (db) => {
-  await db.addForeignKey(
-    'table',
-    ['otherId'],
-    'otherTable',
-    ['id'],
-  );
-});
-`);
-  });
-
-  it('should create schema', () => {
-    const result = astToMigration([schema]);
-
-    expect(result).toBe(template(`  await db.createSchema('schemaName');`));
-  });
-
-  it('should create extension', () => {
-    const result = astToMigration([
-      {
-        ...extension,
-        schema: 'schema',
-        version: '123',
-      },
-    ]);
-
-    expect(result).toBe(
-      template(`  await db.createExtension('extensionName', {
-    schema: 'schema',
-    version: '123',
-  });`),
-    );
-  });
-
-  it('should create enum', () => {
-    const result = astToMigration([
-      {
-        ...enumType,
-        schema: 'schema',
-      },
-    ]);
-
-    expect(result).toBe(
-      template(`  await db.createEnum('mood', ['sad', 'ok', 'happy'], {
-    schema: 'schema',
-  });`),
-    );
-  });
-
-  describe('table', () => {
-    it('should create table', () => {
-      const result = astToMigration([table]);
-
-      expect(result).toBe(
-        template(`  await db.createTable('schema.table', (t) => ({
-    id: t.serial().primaryKey(),
-  }));`),
-      );
-    });
-
-    it('should add columns with indexes and foreignKeys', () => {
-      const result = astToMigration([
-        {
-          ...table,
-          shape: {
-            someId: columnTypes
-              .integer()
-              .unique({ name: 'indexName' })
-              .foreignKey('otherTable', 'otherId', {
-                name: 'fkey',
-                match: 'FULL',
-                onUpdate: 'CASCADE',
-                onDelete: 'CASCADE',
-              }),
-          },
-        },
-      ]);
-
-      expect(result).toBe(`import { change } from 'rake-db';
-
-change(async (db) => {
-  await db.createTable('schema.table', (t) => ({
-    someId: t.integer().foreignKey('otherTable', 'otherId', {
-      name: 'fkey',
-      match: 'FULL',
-      onUpdate: 'CASCADE',
-      onDelete: 'CASCADE',
-    }).unique({
-      name: 'indexName',
-    }),
-  }));
-});
-`);
-    });
-
-    it('should add composite primaryKeys, indexes, foreignKeys', () => {
-      const result = astToMigration([
-        {
-          ...table,
-          shape: {
-            id: columnTypes.serial().primaryKey(),
-          },
-          primaryKey: { columns: ['id', 'name'], options: { name: 'pkey' } },
-          indexes: [
-            {
-              columns: [{ column: 'id' }, { column: 'name' }],
-              options: { name: 'index', unique: true },
-            },
-          ],
-          foreignKeys: [
-            {
-              columns: ['id', 'name'],
-              fnOrTable: 'otherTable',
-              foreignColumns: ['otherId', 'otherName'],
-              options: {
-                name: 'fkey',
-                match: 'FULL',
-                onUpdate: 'CASCADE',
-                onDelete: 'CASCADE',
-              },
-            },
-          ],
-        },
-      ]);
-
-      expect(result).toBe(
-        template(`  await db.createTable('schema.table', (t) => ({
-    id: t.serial().primaryKey(),
-    ...t.primaryKey(['id', 'name'], { name: 'pkey' }),
-    ...t.index(['id', 'name'], {
-      name: 'index',
-      unique: true,
-    }),
-    ...t.foreignKey(
-      ['id', 'name'],
-      'otherTable',
-      ['otherId', 'otherName'],
-      {
-        name: 'fkey',
-        match: 'FULL',
-        onUpdate: 'CASCADE',
-        onDelete: 'CASCADE',
-      },
-    ),
-  }));`),
-      );
-    });
-  });
-
-  describe('foreignKey', () => {
-    it('should add standalone foreignKey', () => {
-      const result = astToMigration([
-        {
-          ...foreignKey,
-          tableSchema: 'custom',
-          options: {
-            name: 'fkey',
-            match: 'FULL',
-            onUpdate: 'CASCADE',
-            onDelete: 'CASCADE',
-          },
-        },
-      ]);
-
-      expect(result).toBe(
-        template(`  await db.addForeignKey(
-    'custom.table',
-    ['otherId'],
-    'otherTable',
-    ['id'],
-    {
-      name: 'fkey',
-      match: 'FULL',
-      onUpdate: 'CASCADE',
-      onDelete: 'CASCADE',
-    },
-  );`),
-      );
-    });
-  });
-});