drizzle-kit 0.9.40 → 0.9.41

package/src/snapshotsDiffer.ts

@@ -0,0 +1,267 @@
+import { fromJson } from "./sqlgenerator";
+import { applyJsonDiff, diffForRenamedTables, diffForRenamedColumn } from "./jsonDiffer";
+import { object, string, boolean, mixed } from 'yup';
+
+import {
+  JsonReferenceStatement,
+  JsonRenameColumnStatement,
+  prepareAddValuesToEnumJson,
+  prepareAlterReferencesJson,
+  prepareAlterTableColumnsJson,
+  prepareCreateEnumJson,
+  prepareCreateIndexesJson,
+  prepareCreateReferencesJson,
+  prepareCreateTableJson,
+  prepareDropIndexesJson,
+  prepareDropTableJson,
+  prepareRenameColumns,
+  prepareRenameTableJson
+} from "./jsonStatements";
+
+export interface Column {
+  name: string;
+  type: string;
+  primaryKey?: boolean;
+  unique?: boolean;
+  defaultValue?: string;
+  notNull?: boolean;
+  references?: string;
+}
+
+const columnSchema = object({
+  name: string().required(),
+  type: string().required(),
+  primaryKey: boolean().optional(),
+  unique: boolean().optional(),
+  defaultValue: mixed().optional(),
+  notNull: boolean().optional(),
+  references: string().optional()
+}).noUnknown()
+
+export interface Added<T> {
+  type: 'added';
+  value: T;
+}
+
+export interface Deleted<T> {
+  type: 'deleted';
+  value: T;
+}
+
+export interface Changed<T> {
+  type: 'changed';
+  old: T;
+  new: T;
+}
+
+export type PatchedProperty<T> = Added<T> | Deleted<T> | Changed<T>;
+
+export interface AlteredColumn {
+  name: string | Changed<string>
+  type?: Changed<string>
+  defaultValue?: PatchedProperty<string>,
+  notNull?: PatchedProperty<boolean>
+  references?: PatchedProperty<string>
+}
+
+export interface ColumnsObject {
+  [name: string]: Column;
+}
+
+interface Enum {
+  name: string;
+  values: string[];
+}
+
+export interface Index {
+  name: string;
+  columns: string[];
+  isUnique: boolean;
+}
+
+export interface Table {
+  name: string;
+  columns: ColumnsObject,
+  indexes: Index[]
+}
+
+export interface AlteredTable {
+  name: string;
+  deleted: Column[];
+  added: Column[],
+  altered: AlteredColumn[],
+  addedIndexes: Index[],
+  deletedIndexes: Index[],
+}
+
+export type DiffResult = {
+  addedTables: Table[]
+  deletedTables: Table[]
+  alteredTablesWithColumns: AlteredTable[]
+  addedEnums: Enum[]
+  deletedEnums: Enum[]
+  alteredEnums: any[]
+}
+
+export interface TablesResolverInput<T extends { name: string }> {
+  created: T[],
+  deleted: T[]
+}
+export interface TablesResolverOutput<T extends { name: string }> {
+  created: T[],
+  renamed: { from: T, to: T }[],
+  deleted: T[]
+}
+
+export interface ColumnsResolverInput<T extends { name: string }> {
+  tableName: string,
+  created: T[],
+  deleted: T[]
+}
+
+export interface ColumnsResolverOutput<T extends { name: string }> {
+  tableName: string,
+  created: T[],
+  renamed: { from: T, to: T }[],
+  deleted: T[]
+}
+
+export const applySnapshotsDiff = async (
+  json1: Object,
+  json2: Object,
+  tablesResolver: (input: TablesResolverInput<Table>) => Promise<TablesResolverOutput<Table>>,
+  columnsResolver: (input: ColumnsResolverInput<Column>) => Promise<ColumnsResolverOutput<Column>>
+) => {
+  const diffResult = applyJsonDiff(json1, json2)
+  const typedResult: DiffResult = diffResult
+
+  typedResult.addedTables.forEach(t => {
+    Object.values(t.columns).forEach(column => {
+      columnSchema.validateSync(column, { strict: true })
+    })
+  })
+
+  typedResult.deletedTables.forEach(t => {
+    Object.values(t.columns).forEach(column => {
+      columnSchema.validateSync(column, { strict: true })
+    })
+  })
+
+  typedResult.alteredTablesWithColumns.forEach(t => {
+    t.added.forEach(column => {
+      columnSchema.validateSync(column, { strict: true })
+    })
+    t.deleted.forEach(column => {
+      columnSchema.validateSync(column, { strict: true })
+    })
+  })
+
+
+  const { created, deleted, renamed } = await tablesResolver({ created: typedResult.addedTables, deleted: typedResult.deletedTables })
+
+  const jsonStatements: any[] = []
+  const jsonCreateTables = created.map(it => {
+    return prepareCreateTableJson(it)
+  })
+
+  const jsonCreateIndexesForCreatedTables = created.map(it => {
+    return prepareCreateIndexesJson(it.name, it.indexes)
+  }).flat()
+
+  const jsonDropTables = deleted.map(it => {
+    return prepareDropTableJson(it)
+  })
+
+  const jsonRenameTables = renamed.map(it => {
+    return prepareRenameTableJson(it.from, it.to)
+  })
+
+  const renamedWithAlternations: AlteredTable[] = diffForRenamedTables(renamed)
+  const allAltered = typedResult.alteredTablesWithColumns.concat(renamedWithAlternations)
+
+  const jsonRenameColumnsStatements: JsonRenameColumnStatement[] = []
+
+  const allAlteredResolved: AlteredTable[] = []
+  for (const table of allAltered) {
+    const result = await columnsResolver({ tableName: table.name, created: table.added, deleted: table.deleted });
+    // prepare oldTable and newTable
+
+    jsonRenameColumnsStatements.push(...prepareRenameColumns(table.name, result.renamed))
+
+    const renamedColumnsAltered: AlteredColumn[] = result.renamed.map(it => diffForRenamedColumn(it.from, it.to))
+    const allAltered = table.altered.concat(renamedColumnsAltered)
+
+    const resolved: AlteredTable = {
+      name: table.name,
+      deleted: result.deleted,
+      added: result.created,
+      altered: allAltered,
+      addedIndexes: table.addedIndexes,
+      deletedIndexes: table.deletedIndexes
+    }
+
+    allAlteredResolved.push(resolved)
+  }
+
+  const jsonAlterTables = allAlteredResolved.map(it => {
+    return prepareAlterTableColumnsJson(it.name, it.deleted, it.added, it.altered)
+  }).flat()
+
+  const jsonCreateIndexesForAllAlteredTables = allAltered.map(it => {
+    return prepareCreateIndexesJson(it.name, it.addedIndexes || {})
+  }).flat()
+
+  const jsonDropIndexesForAllAlteredTables = allAltered.map(it => {
+    return prepareDropIndexesJson(it.name, it.deletedIndexes || {})
+  }).flat()
+
+  const jsonReferencesForCreatedTables: JsonReferenceStatement[] = created.map(it => {
+    return prepareCreateReferencesJson(it.name, Object.values(it.columns))
+  }).flat()
+
+  const jsonReferencesForAllAlteredTables: JsonReferenceStatement[] = allAltered.map(it => {
+    const forAdded = prepareCreateReferencesJson(it.name, it.added)
+    const forAltered = prepareAlterReferencesJson(it.name, it.altered)
+    return [...forAdded, ...forAltered]
+  }).flat()
+
+  const jsonCreateReferences: JsonReferenceStatement[] = jsonReferencesForCreatedTables.concat(jsonReferencesForAllAlteredTables)
+
+  // // Enums:
+  // // - создание енама ✅
+  // // - переименование енама (пока не делаю)⏳
+  // // - добавление вэлью к енаму ✅
+  // // - ренейм вейлью у енама (пока не делаю, это надо запрашивать опять же через слай)⏳
+  // // - удаление енама -> чекать не используется ли где-то енам и сначала ранить миграции и в самом конце удаление енама⏳
+  // // - удаление вэлью из енама -> блок ❌
+  // const enums = result.addedEnums.map(it => {
+  //   return prepareCreateEnum(it.name, it.values)
+  // })
+
+  const createEnums = diffResult.addedEnums.map(it => {
+    return prepareCreateEnumJson(it.name, it.values)
+  })
+
+  //todo: block enum rename, enum value rename and enun deletion for now
+  const jsonAlterEnumsWithAddedValues = diffResult.alteredEnums.map(it => {
+    return prepareAddValuesToEnumJson(it.name, it.addedValues)
+  }).flat()
+
+  jsonStatements.push(...createEnums)
+  jsonStatements.push(...jsonAlterEnumsWithAddedValues)
+  jsonStatements.push(...jsonCreateTables)
+  jsonStatements.push(...jsonDropTables)
+  jsonStatements.push(...jsonRenameTables)
+  jsonStatements.push(...jsonRenameColumnsStatements)
+  jsonStatements.push(...jsonAlterTables)
+  jsonStatements.push(...jsonCreateReferences)
+  jsonStatements.push(...jsonCreateIndexesForCreatedTables)
+  jsonStatements.push(...jsonCreateIndexesForAllAlteredTables)
+  jsonStatements.push(...jsonDropIndexesForAllAlteredTables)
+
+  const sqlStatements = fromJson(jsonStatements)
+  return sqlStatements.join('\n')
+}
+
+// explicitely ask if tables were renamed, if yes - add those to altered tables, otherwise - deleted
+// double check if user wants to delete particular table and warn him on data loss

package/src/sqlgenerator.ts

@@ -0,0 +1,323 @@
+import { JsonAddColumnStatement, JsonAddValueToEnumStatement, JsonAlterColumnDropDefaultStatement, JsonAlterColumnDropNotNullStatement, JsonAlterColumnSetDefaultStatement, JsonAlterColumnSetNotNullStatement, JsonAlterColumnTypeStatement, JsonAlterReferenceStatement, JsonCreateEnumStatement, JsonCreateIndexStatement, JsonCreateReferenceStatement, JsonCreateTableStatement, JsonDeleteReferenceStatement, JsonDropColumnStatement, JsonDropIndexStatement, JsonDropTableStatement, JsonRenameColumnStatement, JsonRenameTableStatement, JsonStatement } from "./jsonStatements";
+
+abstract class Convertor {
+    abstract can(statement: JsonStatement): boolean
+    abstract convert(statement: JsonStatement): string
+}
+
+class CreateTableConvertor extends Convertor {
+    can(statement: JsonStatement): boolean {
+        return statement.type === 'create_table'
+    }
+
+    convert(st: JsonCreateTableStatement) {
+        const { tableName, columns } = st
+
+        let statement = ''
+
+        statement += `CREATE TABLE IF NOT EXISTS ${tableName} (\n`
+        for (let i = 0; i < columns.length; i++) {
+            const column = columns[i]
+
+            const primaryKeyStatement = column.primaryKey ? "PRIMARY KEY" : ''
+            const notNullStatement = column.notNull ? "NOT NULL" : "";
+            const defaultStatement = column.defaultValue !== undefined ? `DEFAULT ${column.defaultValue}` : "";
+
+            statement += '\t' + `"${column.name}" ${column.type} ${primaryKeyStatement} ${defaultStatement} ${notNullStatement}`.replace(/  +/g, ' ').trim();
+            statement += (i === columns.length - 1 ? '' : ',') + '\n'
+        }
+        statement += `);`
+        statement += `\n`
+        return statement;
+    }
+}
+
+class CreateTypeEnumConvertor extends Convertor {
+    can(statement: JsonStatement): boolean {
+        return statement.type === 'create_type_enum'
+    }
+
+
+    convert(st: JsonCreateEnumStatement) {
+        const { name, values } = st
+        let valuesStatement = '('
+        valuesStatement += values.map(it => `'${it}'`).join(', ')
+        valuesStatement += ')'
+
+        let statement = "DO $$ BEGIN"
+        statement += "\n"
+        statement += ` CREATE TYPE ${name} AS ENUM${valuesStatement};`
+        statement += "\n"
+        statement += "EXCEPTION"
+        statement += "\n"
+        statement += " WHEN duplicate_object THEN null;"
+        statement += "\n"
+        statement += "END $$;"
+        statement += '\n'
+        return statement
+    }
+}
+
+class AlterTypeAddValueConvertor extends Convertor {
+    can(statement: JsonStatement): boolean {
+        return statement.type === 'alter_type_add_value'
+    }
+
+    convert(st: JsonAddValueToEnumStatement) {
+        const { name, value } = st
+        return `ALTER TYPE ${name} ADD VALUE '${value}';`
+    }
+}
+
+class DropTableConvertor extends Convertor {
+    can(statement: JsonStatement): boolean {
+        return statement.type === 'drop_table'
+    }
+
+    convert(statement: JsonDropTableStatement) {
+        const { tableName } = statement
+        return `DROP TABLE ${tableName};`
+    }
+}
+
+class RenameTableConvertor extends Convertor {
+    can(statement: JsonStatement): boolean {
+        return statement.type === 'rename_table'
+    }
+
+    convert(statement: JsonRenameTableStatement) {
+        const { tableNameFrom, tableNameTo } = statement
+        return `ALTER TABLE ${tableNameFrom} RENAME TO ${tableNameTo};`
+    }
+}
+
+class AlterTableRenameColumnConvertor extends Convertor {
+    can(statement: JsonStatement): boolean {
+        return statement.type === 'alter_table_rename_column'
+    }
+
+    convert(statement: JsonRenameColumnStatement) {
+        const { tableName, oldColumnName, newColumnName } = statement
+        return `ALTER TABLE ${tableName} RENAME COLUMN "${oldColumnName}" TO "${newColumnName}";`
+    }
+}
+
+class AlterTableDropColumnConvertor extends Convertor {
+    can(statement: JsonStatement): boolean {
+        return statement.type === 'alter_table_drop_column'
+    }
+
+    convert(statement: JsonDropColumnStatement) {
+        const { tableName, columnName } = statement
+        return `ALTER TABLE ${tableName} DROP COLUMN IF EXISTS "${columnName}";`
+    }
+}
+
+class AlterTableAddColumnConvertor extends Convertor {
+    can(statement: JsonStatement): boolean {
+        return statement.type === 'alter_table_add_column'
+    }
+
+    convert(statement: JsonAddColumnStatement) {
+        const { tableName, column } = statement
+        const { name, type, notNull } = column;
+        const defaultValue = column.defaultValue
+
+        const defaultStatement = `${defaultValue !== undefined ? `DEFAULT ${defaultValue}` : ''}`
+        const notNullStatement = `${notNull ? 'NOT NULL' : ''}`
+        return `ALTER TABLE ${tableName} ADD COLUMN "${name}" ${type} ${defaultStatement} ${notNullStatement}`.replace(/  +/g, ' ').trim() + ';'
+    }
+}
+
+class AlterTableAlterColumnSetTypeConvertor extends Convertor {
+    can(statement: JsonStatement): boolean {
+        return statement.type === 'alter_table_alter_column_set_type'
+    }
+
+    convert(statement: JsonAlterColumnTypeStatement) {
+        const { tableName, columnName, newDataType } = statement
+        return `ALTER TABLE ${tableName} ALTER COLUMN "${columnName}" SET DATA TYPE ${newDataType};`
+    }
+}
+
+class AlterTableAlterColumnSetDefaultConvertor extends Convertor {
+    can(statement: JsonStatement): boolean {
+        return statement.type === 'alter_table_alter_column_set_default'
+    }
+
+    convert(statement: JsonAlterColumnSetDefaultStatement) {
+        const { tableName, columnName } = statement
+        return `ALTER TABLE ${tableName} ALTER COLUMN "${columnName}" SET DEFAULT ${statement.newDefaultValue};`
+    }
+}
+
+class AlterTableAlterColumnDropDefaultConvertor extends Convertor {
+    can(statement: JsonStatement): boolean {
+        return statement.type === 'alter_table_alter_column_drop_default'
+    }
+
+    convert(statement: JsonAlterColumnDropDefaultStatement) {
+        const { tableName, columnName } = statement
+        return `ALTER TABLE ${tableName} ALTER COLUMN "${columnName}" DROP DEFAULT;`
+    }
+}
+
+class AlterTableAlterColumnSetNotNullConvertor extends Convertor {
+    can(statement: JsonStatement): boolean {
+        return statement.type === 'alter_table_alter_column_set_notnull'
+    }
+
+    convert(statement: JsonAlterColumnSetNotNullStatement) {
+        const { tableName, columnName } = statement
+        return `ALTER TABLE ${tableName} ALTER COLUMN "${columnName}" SET NOT NULL;`
+    }
+}
+
+class AlterTableAlterColumnDropNotNullConvertor extends Convertor {
+    can(statement: JsonStatement): boolean {
+        return statement.type === 'alter_table_alter_column_drop_notnull'
+    }
+
+    convert(statement: JsonAlterColumnDropNotNullStatement) {
+        const { tableName, columnName } = statement
+        return `ALTER TABLE ${tableName} ALTER COLUMN "${columnName}" DROP NOT NULL;`
+    }
+}
+
+class CreateForeignKeyConvertor extends Convertor {
+    can(statement: JsonStatement): boolean {
+        return statement.type === 'create_reference'
+    }
+
+    convert(statement: JsonCreateReferenceStatement) {
+        const { fromTable, toTable, fromColumn, toColumn, foreignKeyName, onDelete, onUpdate } = statement
+        const onDeleteStatement = onDelete || ""
+        const onUpdateStatement = onUpdate || ""
+        const alterStatement = `ALTER TABLE ${fromTable} ADD CONSTRAINT ${foreignKeyName} FOREIGN KEY ("${fromColumn}") REFERENCES ${toTable}(${toColumn}) ${onDeleteStatement} ${onUpdateStatement}`.replace(/  +/g, ' ').trim();
+
+        let sql = "DO $$ BEGIN\n"
+        sql += ' ' + alterStatement + ';\n'
+        sql += "EXCEPTION\n"
+        sql += " WHEN duplicate_object THEN null;\n"
+        sql += "END $$;\n"
+        return sql
+    }
+}
+
+class AlterForeignKeyConvertor extends Convertor {
+    can(statement: JsonStatement): boolean {
+        return statement.type === 'alter_reference'
+    }
+
+    convert(statement: JsonAlterReferenceStatement) {
+        const { fromTable, toTable, fromColumn, toColumn, foreignKeyName, onDelete, onUpdate, oldFkey } = statement
+        const onDeleteStatement = onDelete || ""
+        const onUpdateStatement = onUpdate || ""
+        const alterStatement = `ALTER TABLE ${fromTable} ADD CONSTRAINT ${foreignKeyName} FOREIGN KEY ("${fromColumn}") REFERENCES ${toTable}(${toColumn}) ${onDeleteStatement} ${onUpdateStatement}`.replace(/  +/g, ' ').trim();
+        let sql = `ALTER TABLE ${fromTable} DROP CONSTRAINT ${oldFkey};\n`
+        sql += "DO $$ BEGIN\n"
+        sql += ' ' + alterStatement + ';\n'
+        sql += "EXCEPTION\n"
+        sql += " WHEN duplicate_object THEN null;\n"
+        sql += "END $$;\n"
+        return sql
+    }
+}
+
+class DeleteForeignKeyConvertor extends Convertor {
+    can(statement: JsonStatement): boolean {
+        return statement.type === 'delete_reference'
+    }
+
+    convert(statement: JsonDeleteReferenceStatement) {
+        const { fromTable, foreignKeyName } = statement
+        return `ALTER TABLE ${fromTable} DROP CONSTRAINT ${foreignKeyName};\n`
+    }
+}
+
+class CreateIndexConvertor extends Convertor {
+    can(statement: JsonStatement): boolean {
+        return statement.type === 'create_index'
+    }
+
+    convert(statement: JsonCreateIndexStatement) {
+        const { tableName, indexName, value } = statement
+        // since postgresql 9.5
+        const indexPart = statement.isUnique ? 'UNIQUE INDEX' : 'INDEX'
+        return `CREATE ${indexPart} IF NOT EXISTS ${indexName} ON ${tableName} (${value});`
+    }
+}
+
+class DropIndexConvertor extends Convertor {
+    can(statement: JsonStatement): boolean {
+        return statement.type === 'drop_index'
+    }
+
+    convert(statement: JsonDropIndexStatement) {
+        const { indexName } = statement
+        return `DROP INDEX IF EXISTS ${indexName};`
+    }
+}
+
+const convertors: Convertor[] = []
+convertors.push(new CreateTableConvertor())
+convertors.push(new CreateTypeEnumConvertor())
+convertors.push(new DropTableConvertor())
+convertors.push(new RenameTableConvertor())
+convertors.push(new AlterTableRenameColumnConvertor())
+convertors.push(new AlterTableDropColumnConvertor())
+convertors.push(new AlterTableAddColumnConvertor())
+convertors.push(new AlterTableAlterColumnSetTypeConvertor())
+convertors.push(new CreateIndexConvertor())
+convertors.push(new DropIndexConvertor())
+convertors.push(new AlterTypeAddValueConvertor())
+convertors.push(new AlterTableAlterColumnSetNotNullConvertor())
+convertors.push(new AlterTableAlterColumnDropNotNullConvertor())
+convertors.push(new AlterTableAlterColumnSetDefaultConvertor())
+convertors.push(new AlterTableAlterColumnDropDefaultConvertor())
+convertors.push(new CreateForeignKeyConvertor())
+convertors.push(new AlterForeignKeyConvertor())
+convertors.push(new DeleteForeignKeyConvertor())
+
+export const fromJson = (statements: JsonStatement[]) => {
+    const result = statements.map(statement => {
+        const filtered = convertors.filter(it => {
+            return it.can(statement)
+        })
+        const convertor = filtered.length === 1 ? filtered[0] : undefined
+
+        if (!convertor) {
+            console.log('no convertor:', statement.type)
+            return 'dry run'
+        }
+
+        return convertor.convert(statement)
+    })
+    return result;
+}
+
+https://blog.yo1.dog/updating-enum-values-in-postgresql-the-safe-and-easy-way/
+// test case for enum altering
+`
+create table users (
+	id int,
+    name character varying(128)
+);
+
+create type venum as enum('one', 'two', 'three');
+alter table users add column typed venum;
+
+insert into users(id, name, typed) values (1, 'name1', 'one');
+insert into users(id, name, typed) values (2, 'name2', 'two');
+insert into users(id, name, typed) values (3, 'name3', 'three');
+
+alter type venum rename to __venum;
+create type venum as enum ('one', 'two', 'three', 'four', 'five');
+
+ALTER TABLE users ALTER COLUMN typed TYPE venum USING typed::text::venum;
+
+insert into users(id, name, typed) values (4, 'name4', 'four');
+insert into users(id, name, typed) values (5, 'name5', 'five');
+
+drop type __venum;
+`