drizzle-kit 0.9.41 → 0.9.42

package/src/snapshotsDiffer.ts

@@ -1,267 +0,0 @@
-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

@@ -1,323 +0,0 @@
-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;
-`