drizzle-kit 0.9.2 → 0.9.3

package/src/cli/machines/resolveTablesMachine.ts

@@ -1,169 +0,0 @@
-import { assign, createMachine, send } from 'xstate';
-import { Named, RenamedObject } from 'cli/commands/migration/migrate';
-
-type Event =
-  | { type: 'CHOICE_ITEM', itemIndex: number }
-  | { type: 'DELETE' }
-  | { type: 'RENAME' }
-  | { type: 'CANCEL' }
-  | { type: 'CONFIRM' }
-  | { type: 'NEXT' }
-  | { type: 'CHOICE_NEW_ITEM'; itemIndex: number };
-
-interface Context extends Props {
-  missingItemIndex: number,
-  newItemIndex: number,
-  createdTables: Named[];
-  renamedTables: RenamedObject<Named>[];
-  deletedTables: Named[];
-}
-
-interface Props {
-  missingTables: Named[],
-  newTables: Named[],
-}
-
-const createResolveTablesMachine = (props: Props) => (
-  createMachine<Context, Event>({
-    id: 'resolveTables',
-    initial: 'table',
-    context: {
-      ...props,
-      missingItemIndex: 0,
-      newItemIndex: 0,
-      createdTables: [],
-      renamedTables: [],
-      deletedTables: [],
-    },
-    states: {
-      table: {
-        entry: send({ type: 'NEXT' }),
-        on: {
-          NEXT: [
-            {
-              target: 'done',
-              cond: 'isMissingTablesResolved',
-              actions: ['resolveRemaining'],
-            },
-            {
-              target: 'done',
-              cond: 'isNewTablesResolved',
-              actions: ['resolveMissing'],
-            },
-          ],
-          CHOICE_ITEM: { target: 'action', actions: ['choseItem'] },
-        },
-      },
-      action: {
-        initial: 'actionChoice',
-        states: {
-          actionChoice: {
-            on: { DELETE: '#resolveTables.confirmationDelete', RENAME: 'rename' },
-          },
-          rename: {
-            on: {
-              CHOICE_NEW_ITEM: { target: '#resolveTables.confirmationRename', actions: ['choseNewItem'] },
-            },
-          },
-        },
-      },
-      confirmationDelete: {
-        on: {
-          CANCEL: 'action.actionChoice',
-          CONFIRM: [
-            { target: 'final', actions: ['delete'] },
-          ],
-        },
-      },
-      confirmationRename: {
-        on: {
-          CANCEL: 'action.actionChoice',
-          CONFIRM: [
-            { target: 'final', actions: ['rename'] },
-          ],
-        },
-      },
-      final: {
-        entry: send({ type: 'NEXT' }),
-        on: {
-          NEXT: [
-            {
-              target: 'done',
-              cond: 'isMissingTablesResolved',
-              actions: ['resolveRemaining'],
-            },
-            {
-              target: 'table',
-            },
-          ],
-        },
-      },
-      done: {},
-    },
-  },
-  {
-    guards: {
-      isMissingTablesResolved: ({ missingTables }) => !missingTables.length,
-      isNewTablesResolved: ({ newTables }) => !newTables.length,
-    },
-    actions: {
-      choseItem: assign({
-        missingItemIndex: (context, event) => (event.type === 'CHOICE_ITEM' ? event.itemIndex : 0),
-      }),
-
-      choseNewItem: assign({
-        newItemIndex: (context, event) => (event.type === 'CHOICE_NEW_ITEM' ? event.itemIndex : 0),
-      }),
-
-      delete: assign({
-        deletedTables: ({
-          missingItemIndex,
-          deletedTables,
-          missingTables,
-        }) => [...deletedTables, missingTables[missingItemIndex]],
-        missingTables: ({
-          missingItemIndex,
-          missingTables,
-        }) => missingTables.filter((_, index) => index !== missingItemIndex),
-      }),
-
-      rename: assign({
-        renamedTables: ({
-          missingItemIndex,
-          newItemIndex,
-          renamedTables,
-          newTables,
-          missingTables,
-        }) => [
-          ...renamedTables,
-          { old: missingTables[missingItemIndex], new: newTables[newItemIndex] },
-        ],
-        missingTables: ({
-          missingItemIndex,
-          missingTables,
-        }) => missingTables.filter((_, index) => index !== missingItemIndex),
-        newTables: ({
-          newItemIndex,
-          newTables,
-        }) => newTables.filter((_, index) => index !== newItemIndex),
-      }),
-
-      resolveRemaining: assign({
-        createdTables: ({
-          newTables,
-          createdTables,
-        }) => [...createdTables, ...newTables],
-        newTables: (context) => [],
-      }),
-
-      resolveMissing: assign({
-        deletedTables: ({
-          missingTables,
-          deletedTables,
-        }) => [...deletedTables, ...missingTables],
-        missingTables: (context) => [],
-      }),
-    },
-  }));
-
-export default createResolveTablesMachine;

package/src/cli/utils/formatDataForTable.ts

@@ -1,36 +0,0 @@
-import { Named, RenamedObject } from 'cli/commands/migration/migrate';
-
-interface ScalarDict {
-  [key: string]: string
-}
-
-export default (
-  data: {
-    title: string;
-    values: Named[] | RenamedObject<Named>[]
-  }[],
-): ScalarDict[] => {
-  const array: ScalarDict[] = [];
-
-  array.length = data.reduce((acc: number, { values }) => {
-    if (acc < values.length) {
-      return values.length;
-    }
-    return acc;
-  },
-  0);
-
-  array.fill({ '': '' });
-
-  return array.map((_, i) => {
-    const temp = {} as ScalarDict;
-
-    data.forEach((item: any, ind: number) => {
-      temp[data[ind].title] = item.values[i]?.old?.name
-        ? `${item.values[i]?.old?.name} -> ${item.values[i]?.new?.name}`
-        : item.values[i]?.name || '';
-    });
-
-    return temp as ScalarDict;
-  });
-};

package/src/cli/utils/valuesForPrompts.ts

@@ -1,35 +0,0 @@
-export enum Action {
-  RENAME = 'RENAME',
-  DELETE = 'DELETE'
-}
-
-export enum Confirmation {
-  CANCEL = 'CANCEL',
-  CONFIRM = 'CONFIRM'
-}
-
-export const actions = [
-  {
-    key: Action.RENAME,
-    label: 'Renamed',
-    value: Action.RENAME,
-  },
-  {
-    key: Action.DELETE,
-    label: 'Deleted',
-    value: Action.DELETE,
-  },
-];
-
-export const confirmations = [
-  {
-    key: Confirmation.CONFIRM,
-    label: 'Yes',
-    value: Confirmation.CONFIRM,
-  },
-  {
-    key: Confirmation.CANCEL,
-    label: 'No',
-    value: Confirmation.CANCEL,
-  },
-];

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 }
-}