drizzle-kit 0.9.1 → 0.9.5

package/src/diff.ts

@@ -1,272 +0,0 @@
-import { fromJson } from "./sqlgenerator";
-import resolveTables from "./simulator";
-import { differ, diffForRenamed } from "./differ";
-import fs from 'fs'
-import { prepareAddValuesToEnumJson, prepareAlterTableColumnsJson, prepareCreateEnumJson, prepareCreateIndexesJson, prepareCreateTableJson, prepareDropIndexesJson, prepareDropTableJson, prepareRenameTableJson } from "./jsonStatements";
-
-const json1 = {
-  tables: {
-    items: {
-      name: "items",
-      columns: {
-        id: {
-          name: "id",
-          type: "int",
-          primaryKey: true,
-          autoincrement: true,
-        },
-        name: {
-          name: "name",
-          type: "character varying(256)",
-          defaultValue: "Vetal",
-          notNull: true,
-        },
-        unused: {
-          name: "unused",
-          type: "character varying(256)",
-        },
-        unused2: {
-          name: "unused2",
-          type: "character varying(256)",
-        },
-      },
-      indexes: {
-        index_to_be_deleted: {
-          name: "index_to_be_deleted",
-          columns: {
-            phone: {
-              name: "phone",
-            },
-          },
-        },
-      },
-    },
-    oldItems: {
-      name: "old_items",
-      columns: {},
-    },
-    items2: {
-      name: "items2",
-      columns: {},
-    },
-  },
-  enums: {
-    enum0: {
-      name: "enum0",
-      values: {
-        value0: "value0",
-        value1: "value1",
-        value2: "value2",
-      },
-    },
-    enum2: {
-      name: "enum2",
-      values: {
-        value1: "value1",
-        value2: "value2",
-      },
-    },
-  },
-};
-
-const json2 = {
-  tables: {
-    items: {
-      name: "items",
-      columns: {
-        id: {
-          name: "id",
-          type: "int",
-          primaryKey: true,
-          autoincrement: true,
-        },
-        name: {
-          name: "name",
-          type: "character varying(512)",
-        },
-        secondName: {
-          name: "secondName",
-          type: "character varying(512)",
-          defaultValue: "Vitalik",
-        },
-        ownerId: {
-          name: "owner_id",
-          type: "int",
-          notNull: true,
-          defaultValue: 10,
-        },
-      },
-      indexes: {
-        users_phone_full_name_index: {
-          name: "users_phone_full_name_index",
-          columns: {
-            phone: {
-              name: "phone",
-            },
-            full_name: {
-              name: "full_name",
-            },
-          },
-        },
-        users_phone_index: {
-          name: "users_phone_index",
-          columns: {
-            phone: {
-              name: "phone",
-            },
-          },
-        },
-      },
-    },
-    items3: {
-      name: "items3",
-      columns: {
-        id: {
-          name: "id",
-          type: "int",
-          primaryKey: true,
-          autoincrement: true,
-        },
-        name: {
-          name: "name",
-          type: "character varying(512)",
-          notNull: true,
-          defaultValue: "defaultValue",
-        },
-        ownerId: {
-          name: "owner_id",
-          type: "int",
-        },
-      },
-    },
-    items22: {
-      name: "items22",
-      columns: {},
-    },
-  },
-  enums: {
-    enum0: {
-      name: "enum0",
-      values: {
-        value1: "value1",
-        value2: "value2",
-        value3: "value3",
-      },
-    },
-    enum1: {
-      name: "enum1",
-      values: {
-        value1: "value1",
-        value2: "value2",
-      },
-    },
-  },
-};
-
-const dry = {
-  version: "1",
-  tables: {},
-  enums: {}
-}
-
-// TODO: read snapshots from folder
-
-// const j1 = JSON.parse(fs.readFileSync('./out/v1_1634546745488.json', 'utf8'))
-const j1 = dry
-const j2 = JSON.parse(fs.readFileSync('./out/v2_1634549601361.json', 'utf8'))
-// const j3 = JSON.parse(fs.readFileSync('./out/1634215063491.json', 'utf8'))
-const result = differ(j1, j2)
-
-const { created, deleted, renamed } = resolveTables(result.addedTables, result.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 createNewTables = created.map(it => {
-//   return prepareCreateTable(it)
-// })
-// console.log(createNewTables.join('\n').trim())
-
-// const deleteTables = deleted.map(it => {
-//   return prepareDropTable(it)
-// })
-// console.log(deleteTables.join('\n').trim())
-
-const renamedWithAlternations = diffForRenamed(renamed)
-const allAltered = result.alteredTablesWithColumns.concat(renamedWithAlternations)
-
-// const renameTables = renamed.map(it => {
-//   return prepareRenameTable(it.from, it.to)
-// })
-// console.log(renameTables.join('\n').trim())
-
-const jsonAlterTables = allAltered.map(it => {
-  return prepareAlterTableColumnsJson(it)
-}).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()
-
-// // Enums:
-// // - создание енама ✅
-// // - переименование енама (пока не делаю)⏳
-// // - добавление вэлью к енаму ✅
-// // - ренейм вейлью у енама (пока не делаю, это надо запрашивать опять же через слай)⏳
-// // - удаление енама -> чекать не используется ли где-то енам и сначала ранить миграции и в самом конце удаление енама⏳
-// // - удаление вэлью из енама -> блок ❌
-// const enums = result.addedEnums.map(it => {
-//   return prepareCreateEnum(it.name, it.values)
-// })
-
-const createEnums = result.addedEnums.map(it => {
-  return prepareCreateEnumJson(it.name, it.values)
-})
-
-//todo: block enum rename, enum value rename and enun deletion for now
-const jsonAlterEnumsWithAddedValues = result.alteredEnums.map(it => {
-  return prepareAddValuesToEnumJson(it.name, it.addedValues)
-}).flat()
-
-jsonStatements.push(...createEnums)
-jsonStatements.push(...jsonAlterEnumsWithAddedValues)
-jsonStatements.push(...jsonCreateTables)
-jsonStatements.push(...jsonCreateIndexesForCreatedTables)
-jsonStatements.push(...jsonDropTables)
-jsonStatements.push(...jsonRenameTables)
-jsonStatements.push(...jsonAlterTables)
-jsonStatements.push(...jsonCreateIndexesForAllAlteredTables)
-jsonStatements.push(...jsonDropIndexesForAllAlteredTables)
-
-// console.log(JSON.stringify(jsonStatements, null, 2))
-console.log(jsonStatements)
-
-const sqlStatements = fromJson(jsonStatements)
-console.log(sqlStatements.join('\n'))
-
-
-// console.log(enums.join('\n').trim())
-// console.log(alteredEnums.join('\n').trim())
-
-
-// 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/differ.js

@@ -1,135 +0,0 @@
-'use-strict';
-
-import { diff } from 'json-diff'
-
-
-export function diffForRenamed(pairs) {
-    // raname table1 to name of table2, so we can apply diffs
-    const renamed = pairs.map(it => {
-        const from = it.from || it.old
-        const to = it.to || it.new
-        const newFrom = { ...from, name: to.name }
-        return [newFrom, to]
-    })
-
-    // find any alternations made to a renamed table
-    const altered = renamed.map(pair => {
-        const diffed = diff(pair[0], pair[1]);
-        diffed.name = pair[0].name
-
-        return findAlternationsInTable(diffed)
-    })
-
-    return altered
-}
-export function differ(json1, json2) {
-    const difference = diff(json1, json2);
-
-    difference.tables = difference.tables ? difference.tables : {}
-    difference.enums = difference.enums ? difference.enums : {}
-
-    const tableEntries = Object.entries(difference.tables)
-    const addedTables = tableEntries.filter(it => it[0].includes('__added'))
-        .map(it => it[1])
-        .map(it => {
-            // console.log(it)
-            return {
-                ...it, indexes: Object.entries(it.indexes).map(indexEntry => {
-                    const idx = indexEntry[1]
-                    const name = idx['name']
-                    const columns = Object.values(idx['columns']).map(it => it['name'])
-                    return { name, columns }
-                })
-            }
-        })
-    const deletedTables = tableEntries.filter(it => it[0].includes('__deleted')).map(it => it[1])
-
-    const enumsEntries = Object.entries(difference.enums)
-
-    const addedEnums = enumsEntries.filter(it => it[0].includes('__added'))
-        .map(it => it[1])
-        .map(it => {
-            // values: { val1: 'val1', val2: 'val2' } => values: ['val1', 'val2']
-            const values = Object.entries(it.values).map(ve => ve[1])
-            return { name: it.name, values: values }
-        })
-    const deletedEnums = enumsEntries.filter(it => it[0].includes('__deleted'))
-        .map(it => it[1])
-        .map(it => {
-
-            // values: { val1: 'val1', val2: 'val2' } => values: ['val1', 'val2']
-            const values = Object.entries(it.values).map(ve => ve[1])
-            return { name: it.name, values: values }
-        })
-    const alteredEnums = enumsEntries.filter(it => !(it[0].includes('__added') || it[0].includes('__deleted')))
-        .map(it => {
-            const vals = it[1].values
-            const addedValues = Object.entries(vals).filter(val => val[0].includes('__added')).map(val => val[1])
-            const deletedValues = Object.entries(vals).filter(val => val[0].includes('__deleted')).map(val => val[1])
-            // console.log('values: ', it[1].values)
-            return { name: it[0], addedValues, deletedValues, }
-        })
-
-    const alteredTables = Object.keys(difference.tables)
-        .filter(it => !(it.includes('__added') || it.includes('__deleted')))
-        .map(it => {
-            return { name: it, ...difference.tables[it] }
-        })
-
-    const alteredTablesWithColumns = alteredTables.map(table => findAlternationsInTable(table))
-
-    return {
-        addedTables,
-        deletedTables,
-        alteredTablesWithColumns,
-        addedEnums,
-        deletedEnums,
-        alteredEnums,
-    }
-}
-
-const findAlternationsInTable = (table) => {
-    // map each table to have altered, deleted or renamed columns
-    const columns = table.columns; //in case no columns were altered, but indexes were
-
-    const added = Object.keys(columns).filter(it => it.includes('__added')).map(it => {
-        return { ...columns[it] }
-    })
-    const deleted = Object.keys(columns).filter(it => it.includes('__deleted')).map(it => {
-        return { ...columns[it] }
-    })
-    const altered = Object.keys(columns)
-        .filter(it => !(it.includes('__deleted') || it.includes('__added')))
-        .map(it => {
-            return { name: it, ...columns[it] }
-        })
-
-    const deletedIndexes = Object.values(table.indexes__deleted || {}).map(it => {
-        const name = it['name']
-        const columns = Object.values(it['columns']).map(it => it['name'])
-        return { name, columns }
-    }).concat(
-        Object.keys(table.indexes || {}).filter(it => it.includes('__deleted'))
-            .map(it => {
-                const idx = table.indexes[it]
-                const name = idx['name']
-                const columns = Object.values(idx['columns']).map(it => it['name'])
-                return { name, columns }
-            })
-    );
-
-    const addedIndexes = Object.values(table.indexes__added || {}).map(it => {
-        const name = it['name']
-        const columns = Object.values(it['columns']).map(it => it['name'])
-        return { name, columns }
-    }).concat(
-        Object.keys(table.indexes || {}).filter(it => it.includes('__added'))
-            .map(it => {
-                const idx = table.indexes[it]
-                const name = idx['name']
-                const columns = Object.values(idx['columns']).map(it => it['name'])
-                return { name, columns }
-            })
-    );
-    return { name: table.name, deleted, added, altered, addedIndexes, deletedIndexes }
-}

package/src/jsonStatements.js

@@ -1,176 +0,0 @@
-export class Types {
-    static createTable = 'create_table'
-    static dropTable = 'drop_table'
-    static renameTable = 'rename_table'
-    static alterTableDropColumn = 'alter_table_drop_column'
-    static alterTableAddColumn = 'alter_table_add_column'
-    static alterTableAlterColumnSetType = 'alter_table_alter_column_set_type'
-    static alterTableAlterColumnSetDefault = 'alter_table_alter_column_set_default'
-    static alterTableAlterColumnDropDefault = 'alter_table_alter_column_drop_default'
-    static alterTableAlterColumnSetNotNull = 'alter_table_alter_column_set_notnull'
-    static alterTableAlterColumnDropNotNull = 'alter_table_alter_column_drop_notnull'
-    static createIndex = 'create_index'
-    static dropIndex = 'drop_index'
-    static createTypeEnum = 'create_type_enum'
-    static alterTypeAddValue = 'alter_type_add_value'
-}
-
-export const prepareCreateTableJson = (table) => {
-    const { name, columns } = table
-    const mappedColumns = Object.keys(columns)
-        .map(it => {
-            return { ...columns[it] }
-        })
-
-    return {
-        type: Types.createTable,
-        tableName: name,
-        columns: mappedColumns
-    };
-}
-
-export const prepareDropTableJson = (table) => {
-    return {
-        type: Types.dropTable,
-        tableName: table.name
-    }
-}
-
-export const prepareRenameTableJson = (tableFrom, tableTo) => {
-    return {
-        type: Types.renameTable,
-        from: tableFrom.name,
-        to: tableTo.name
-    }
-}
-
-export const prepareCreateEnumJson = (name, values) => {
-    return {
-        type: Types.createTypeEnum,
-        enumName: name,
-        values
-    }
-}
-
-// https://blog.yo1.dog/updating-enum-values-in-postgresql-the-safe-and-easy-way/
-export const prepareAddValuesToEnumJson = (name, values) => {
-    return values.map(it => {
-        return {
-            type: Types.alterTypeAddValue,
-            enumName: name,
-            enumValue: it
-        }
-    })
-}
-
-export const prepareAlterTableColumnsJson = (table) => {
-    const tableName = table['name'];
-    const statements = []
-
-    const dropColumns = _prepareDropColumns(tableName, table.deleted)
-    const addColumns = _prepareAddColumns(tableName, table.added)
-    const alterColumns = _prepareAlterColumns(tableName, table.altered)
-
-
-    statements.push(...dropColumns)
-    statements.push(...addColumns)
-    statements.push(...alterColumns)
-
-    return statements;
-}
-
-const _prepareDropColumns = (taleName, columns) => {
-    return columns.map(it => {
-        return {
-            type: Types.alterTableDropColumn,
-            tableName: taleName,
-            columnName: it.name
-        }
-    })
-}
-
-const _prepareAddColumns = (tableName, columns) => {
-    
-    return columns.map(it => {
-        return {
-            type: Types.alterTableAddColumn,
-            tableName,
-            column: it
-        }
-    })
-}
-
-const _prepareAlterColumns = (tableName, columns) => {
-    let statements = []
-
-    for (const column of columns) {
-        const columnName = column.name;
-
-        if (column['type']) {
-            const { __new } = column.type
-
-            statements.push({
-                type: Types.alterTableAlterColumnSetType,
-                tableName,
-                columnName,
-                newDataType: __new
-            })
-        }
-
-        if (column['defaultValue'] || column['defaultValue__added']) {
-            const newDefaultValue = column.defaultValue.__new | column.defaultValue__added
-            statements.push({
-                type: Types.alterTableAlterColumnSetDefault,
-                tableName,
-                columnName,
-                newDefault: newDefaultValue
-            })
-        }
-
-        if (column['defaultValue__deleted']) {
-            statements.push({
-                type: Types.alterTableAlterColumnDropDefault,
-                tableName,
-                columnName,
-            })
-        }
-
-        if (column['notNull__added'] || (column['notNull'] && column['notNull']['__new'])) {
-            statements.push({
-                type: Types.alterTableAlterColumnSetNotNull,
-                tableName,
-                columnName
-            })
-        }
-
-        if (column['notNull__deleted'] || (column['notNull'] && !column['notNull']['__new'])) {
-            statements.push({
-                type: Types.alterTableAlterColumnDropNotNull,
-                tableName,
-                columnName
-            })
-        }
-    }
-
-    return statements
-}
-
-export const prepareCreateIndexesJson = (tableName, indexes) => {
-    return indexes.map(index => {
-        return {
-            type: Types.createIndex,
-            tableName,
-            indexName: index.name,
-            indexValue: index.columns.join(', ')
-        }
-    })
-}
-export const prepareDropIndexesJson = (tableName, indexes) => {
-    return indexes.map(index => {
-        return {
-            type: Types.dropIndex,
-            tableName,
-            indexName: index.name,
-        }
-    })
-}

package/src/migrationPreparator.ts

@@ -1,47 +0,0 @@
-import fs from 'fs'
-import serialize from 'serilizer'
-
-// TODO: export as a function w
-
-const dry = {
-    version: "1",
-    tables: {},
-    enums: {}
-}
-
-const prepareMigration = (
-    migrationRootFolderName: string = 'drizzle',
-    dataFolderPath: string
-): { prev: any, cur: any } => {
-    const root = migrationRootFolderName
-    const files = fs.readdirSync('./')
-    const drizzleFolder = files.find((it) => {
-        return it === root
-    })
-
-    if (!drizzleFolder) {
-        fs.mkdirSync(root)
-    }
-
-    const migrationFolders = fs.readdirSync(`./${root}`)
-
-    let prevSnapshot;
-
-    if (migrationFolders.length === 0) {
-        prevSnapshot = dry
-    } else {
-        migrationFolders.sort()
-        const lastSnapshotFolder = migrationFolders[migrationFolders.length - 1]
-        console.log(lastSnapshotFolder)
-        prevSnapshot = JSON.parse(fs.readFileSync(`./${root}/${lastSnapshotFolder}/snapshot.json`).toString())
-    }
-
-    const tbls = `${dataFolderPath}/tables/`
-    const tps = `${dataFolderPath}/types/`
-
-    const result = serialize(tbls, tps)
-
-    return { prev: prevSnapshot, cur: result }
-}
-
-export default prepareMigration;