drizzle-kit 0.9.40 → 0.9.41

package/src/cli/machines/resolveTablesMachine.ts

@@ -0,0 +1,167 @@
+import { assign, createMachine, send } from 'xstate';
+import { Named, RenamedObject } from '../components-api';
+
+type Event =
+  | { type: 'CHOICE_ITEM', itemIndex: number }
+  | { type: 'DELETED' }
+  | { type: 'RENAMED' }
+  | { type: 'CANCEL' }
+  | { type: 'CONFIRM' }
+  | { type: 'NEXT' }
+  | { type: 'CHOICE_NEW_ITEM'; itemIndex: number };
+
+interface Context<T extends Named> extends CreateTablesMachineProps<T> {
+  missingItemIndex: number,
+  newItemIndex: number,
+  createdTables: T[];
+  renamedTables: RenamedObject<T>[];
+  deletedTables: T[];
+}
+
+export interface CreateTablesMachineProps<T> {
+  missingTables: T[],
+  newTables: T[],
+}
+
+const createResolveTablesMachine = <T extends Named>(props: CreateTablesMachineProps<T>) => (
+  createMachine<Context<T>, Event>({
+    id: 'resolveTables',
+    initial: 'idle',
+    context: {
+      ...props,
+      missingItemIndex: 0,
+      newItemIndex: 0,
+      createdTables: [],
+      renamedTables: [],
+      deletedTables: [],
+    },
+    states: {
+      idle: {
+        entry: send({ type: 'NEXT' }),
+        on: {
+          NEXT: [
+            {
+              target: 'done',
+              cond: 'isResolved',
+              actions: ['resolveRemaining'],
+            },
+            {
+              target: 'table',
+            },
+          ],
+        },
+      },
+      table: {
+        on: {
+          CHOICE_ITEM: { target: 'action', actions: ['choseItem'] },
+        },
+      },
+      action: {
+        initial: 'actionChoice',
+        states: {
+          actionChoice: {
+            on: { DELETED: '#resolveTables.confirmationDelete', RENAMED: 'rename' },
+          },
+          rename: {
+            on: {
+              CHOICE_NEW_ITEM: { target: '#resolveTables.confirmationRename', actions: ['choseNewItem'] },
+            },
+          },
+        },
+      },
+      confirmationDelete: {
+        on: {
+          CANCEL: 'action.actionChoice',
+          CONFIRM: [
+            { target: 'check', actions: ['delete'] },
+          ],
+        },
+      },
+      confirmationRename: {
+        on: {
+          CANCEL: 'action.actionChoice',
+          CONFIRM: [
+            { target: 'check', actions: ['rename'] },
+          ],
+        },
+      },
+      check: {
+        entry: send({ type: 'NEXT' }),
+        on: {
+          NEXT: [
+            {
+              target: 'done',
+              cond: 'isResolved',
+              actions: ['resolveRemaining'],
+            },
+            {
+              target: 'table',
+            },
+          ],
+        },
+      },
+      done: {},
+    },
+  },
+  {
+    guards: {
+      isResolved: ({ missingTables, newTables }) => !missingTables.length || !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,
+          {from: missingTables[missingItemIndex], to: 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],
+        deletedTables: ({
+          missingTables,
+          deletedTables,
+        }) => [...deletedTables, ...missingTables],
+        missingTables: (context) => [],
+        newTables: (context) => [],
+      }),
+    }
+  }));
+
+export default createResolveTablesMachine;

package/src/cli/utils/formatDataForTable.ts

@@ -0,0 +1,29 @@
+import { Named, RenamedObject } from '../components-api';
+
+const transpose = <T>(matrix: T[][]) => {
+  let [row] = matrix
+  return row.map((value, column) => matrix.map(row => row[column]))
+}
+
+export default <T extends Named>(
+  created: Named[],
+  renamed: RenamedObject<T>[],
+  deleted: Named[],
+): string[][] => {
+  const columns: string[][] = [[],[],[]];
+
+  columns[0] = created.map(({name}) => name);
+  columns[1] = renamed.map(({from, to}) => `${from.name} -> ${to.name}`);
+  columns[2] = deleted.map(({name}) => name);
+
+  const maxColumnLength = Math.max(columns[0].length, columns[1].length, columns[2].length)
+
+  const filledColumns = columns.map((column) => {
+    const columnLength = column.length;
+    column.length = maxColumnLength;
+    column.fill('', columnLength)
+    return column;
+  })
+
+  return transpose(filledColumns);
+};

package/src/cli/utils/valuesForPrompts.ts

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

@@ -0,0 +1,37 @@
+import fs from 'fs'
+import { resolveColumns, resolveTables } from './simulator'
+import {
+    applySnapshotsDiff,
+    Column,
+    ColumnsResolverInput,
+    ColumnsResolverOutput,
+    Table,
+    TablesResolverInput,
+    TablesResolverOutput
+} from './snapshotsDiffer'
+
+export const dry = {
+    version: "1",
+    tables: {},
+    enums: {}
+}
+
+const simulatedTablesResolver = async (input: TablesResolverInput<Table>): Promise<TablesResolverOutput<Table>> => {
+    return resolveTables(input.created, input.deleted)
+}
+
+const simulatedColumnsResolver = async (input: ColumnsResolverInput<Column>): Promise<ColumnsResolverOutput<Column>> => {
+    return resolveColumns(input.tableName, input.created, input.deleted)
+}
+
+
+
+// const j3 = JSON.parse(fs.readFileSync('./out/1634215063491.json', 'utf8'))
+const main = async () => {
+    const j1 = dry
+    // const j1 = JSON.parse(fs.readFileSync('./out/leha1.json', 'utf8'))
+    const j2 = JSON.parse(fs.readFileSync('./out/leha2.json', 'utf8'))
+    console.log(await applySnapshotsDiff(j1, j2, simulatedTablesResolver, simulatedColumnsResolver))
+}
+
+main()

package/src/jsonDiffer.js

@@ -1,87 +1,146 @@
-"use strict";
 'use-strict';
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyJsonDiff = exports.diffForRenamedColumn = exports.diffForRenamedTable = exports.diffForRenamedTables = void 0;
-const json_diff_1 = require("json-diff");
-function diffForRenamedTables(pairs) {
+
+import { diff } from 'json-diff'
+
+export function diffForRenamedTables(pairs) {
     // raname table1 to name of table2, so we can apply diffs
     const renamed = pairs.map(it => {
-        const from = it.from;
-        const to = it.to;
-        const newFrom = { ...from, name: to.name };
-        return [newFrom, to];
-    });
+        const from = it.from
+        const to = it.to
+        const newFrom = { ...from, name: to.name }
+        return [newFrom, to]
+    })
+
     // find any alternations made to a renamed table
     const altered = renamed.map(pair => {
-        return diffForRenamedTable(pair[0], pair[1]);
+        return diffForRenamedTable(pair[0], pair[1])
+    })
+
+    return altered
+}
+
+export function diffForRenamedTable(t1, t2) {
+    t1.name = t2.name
+    const diffed = diff(t1, t2);
+    diffed.name = t2.name
+
+    return findAlternationsInTable(diffed)
+}
+
+export function diffForRenamedColumn(t1, t2) {
+    const renamed = { ...t1, name: t2.name }
+    const diffed = diff(renamed, t2) || {};
+    diffed.name = t2.name
+
+    return alternationsInColumn(diffed)
+}
+
+const renameNestedObjects = (obj, keyFrom, keyTo) => {
+    Object.entries(obj).forEach(([key, value]) => {
+        if ((key === keyFrom || (key.includes(keyFrom) && key !== keyFrom)) && 'object' !== typeof value) {
+            const newKey = key.replace(keyFrom, keyTo)
+            obj[newKey] = value;
+            delete obj[key];
+        }
+
+        if ('object' === typeof value) {
+            renameNestedObjects(obj[key], keyFrom, keyTo);
+        }
     });
-    return altered;
 }
-exports.diffForRenamedTables = diffForRenamedTables;
-function diffForRenamedTable(t1, t2) {
-    t1.name = t2.name;
-    const diffed = json_diff_1.diff(t1, t2);
-    diffed.name = t2.name;
-    return findAlternationsInTable(diffed);
+
+const update1to2 = (json) => {
+    Object.entries(json).forEach(([key, val]) => {
+        if ('object' !== typeof val) return
+
+        if (val.hasOwnProperty('references')) {
+            const ref = val['references']
+            const fkName = ref['foreignKeyName']
+            const table = ref['table']
+            const column = ref['column']
+            const onDelete = ref['onDelete']
+            const onUpdate = ref['onUpdate']
+            const newRef = `${fkName};${table};${column};${onDelete ?? ''};${onUpdate ?? ''}`
+            val['references'] = newRef
+        } else {
+            update1to2(val)
+        }
+    })
 }
-exports.diffForRenamedTable = diffForRenamedTable;
-function diffForRenamedColumn(t1, t2) {
-    const renamed = { ...t1, name: t2.name };
-    const diffed = json_diff_1.diff(renamed, t2) || {};
-    diffed.name = t2.name;
-    return alternationsInColumn(diffed);
+const migrateSchema = (json) => {
+    if (json['version'] === '1') {
+        update1to2(json)
+        json['version'] = '2'
+    }
 }
-exports.diffForRenamedColumn = diffForRenamedColumn;
-function applyJsonDiff(json1, json2) {
-    const difference = json_diff_1.diff(json1, json2);
-    difference.tables = difference.tables ? difference.tables : {};
-    difference.enums = difference.enums ? difference.enums : {};
-    const tableEntries = Object.entries(difference.tables);
+
+export function applyJsonDiff(json1, json2) {
+    json1 = JSON.parse(JSON.stringify(json1))
+    json2 = JSON.parse(JSON.stringify(json2))
+
+    migrateSchema(json1)
+    migrateSchema(json2)
+
+    //deep copy, needed because of the bug in diff library
+    const rawDiff = diff(json1, json2)
+    const difference = rawDiff
+
+    difference.tables = difference.tables ? difference.tables : {}
+    difference.enums = difference.enums ? difference.enums : {}
+
+    renameNestedObjects(difference, 'default', 'defaultValue')
+
+    const tableEntries = Object.entries(difference.tables)
     const addedTables = tableEntries.filter(it => it[0].includes('__added'))
         .map(it => it[1])
         .map(it => {
-        return { ...it };
-    })
-        .map(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, isUnique: idx['isUnique'] };
-            })
-        };
-    });
+            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, isUnique: idx['isUnique'] }
+                })
+            }
+        })
+
     const deletedTables = tableEntries.filter(it => it[0].includes('__deleted'))
-        .map(it => it[1]);
-    const enumsEntries = Object.entries(difference.enums);
+        .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 };
-    });
+            // 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 };
-    });
+            // 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]);
-        return { name: it[0], addedValues, deletedValues, };
-    });
+            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])
+            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 { name: it, ...difference.tables[it] }
+        })
+
+    const alteredTablesWithColumns = alteredTables.map(table => findAlternationsInTable(table))
+
     return {
         addedTables,
         deletedTables,
@@ -89,90 +148,113 @@ function applyJsonDiff(json1, json2) {
         addedEnums,
         deletedEnums,
         alteredEnums,
-    };
+    }
 }
-exports.applyJsonDiff = applyJsonDiff;
+
 const findAlternationsInTable = (table) => {
     // map each table to have altered, deleted or renamed columns
+
     // in case no columns were altered, but indexes were
     const columns = table.columns;
+
     const added = Object.keys(columns).filter(it => it.includes('__added')).map(it => {
-        return { ...columns[it] };
-    });
+        return { ...columns[it] }
+    })
     const deleted = Object.keys(columns).filter(it => it.includes('__deleted')).map(it => {
-        return { ...columns[it] };
-    });
+        return { ...columns[it] }
+    })
     const altered = Object.keys(columns)
         .filter(it => !(it.includes('__deleted') || it.includes('__added')))
         .map(it => {
-        return { name: it, ...columns[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, isUnique: it['isUnique'] };
-    }).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, isUnique: idx['isUnique'] };
-    }));
+        const name = it['name']
+        const columns = Object.values(it['columns']).map(it => it['name'])
+        return { name, columns, isUnique: it['isUnique'] }
+    }).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, isUnique: idx['isUnique'] }
+            })
+    );
+
     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, isUnique: idx['isUnique'] };
-    }).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, isUnique: idx['isUnique'] };
-    }));
-    const mappedAltered = altered.map(it => alternationsInColumn(it));
-    return { name: table.name, deleted, added, altered: mappedAltered, addedIndexes, deletedIndexes };
-};
+        const name = it['name']
+        const columns = Object.values(it['columns']).map(it => it['name'])
+        return { name, columns, isUnique: idx['isUnique'] }
+    }).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, isUnique: idx['isUnique'] }
+            })
+    );
+
+    const mappedAltered = altered.map(it => alternationsInColumn(it))
+
+    return { name: table.name, deleted, added, altered: mappedAltered, addedIndexes, deletedIndexes }
+}
+
 const alternationsInColumn = (column) => {
-    const altered = [column];
+    const altered = [column]
     const result = altered.map(it => {
         if (typeof it.name !== 'string' && '__old' in it.name) {
             // rename
-            return { ...it, name: { type: 'changed', old: it.name.__old, new: it.name.__new } };
+            return { ...it, name: { type: 'changed', old: it.name.__old, new: it.name.__new } }
         }
-        return it;
+        return it
     }).map(it => {
         if ('type' in it) {
             // type change
-            return { ...it, type: { type: 'changed', old: it.type.__old, new: it.type.__new } };
+            return { ...it, type: { type: 'changed', old: it.type.__old, new: it.type.__new } }
         }
-        return it;
+        return it
     }).map(it => {
-        if ('default' in it) {
-            return { ...it, defaultValue: { type: 'changed', old: it.default.__old, new: it.default.__new } };
+        if ('defaultValue' in it) {
+            return { ...it, defaultValue: { type: 'changed', old: it.defaultValue.__old, new: it.defaultValue.__new } }
         }
-        if ('default__added' in it) {
-            const { default__added, ...others } = it;
-            return { ...others, defaultValue: { type: 'added', value: it.default__added } };
+        if ('defaultValue__added' in it) {
+            const { defaultValue__added, ...others } = it
+            return { ...others, defaultValue: { type: 'added', value: it.defaultValue__added } }
         }
-        if ('default__deleted' in it) {
-            const { default__deleted, ...others } = it;
-            return { ...others, defaultValue: { type: 'deleted', value: it.default__deleted } };
+        if ('defaultValue__deleted' in it) {
+            const { defaultValue__deleted, ...others } = it
+            return { ...others, defaultValue: { type: 'deleted', value: it.defaultValue__deleted } }
         }
-        return it;
+        return it
     }).map(it => {
         if ('notNull' in it) {
-            return { ...it, notNull: { type: 'changed', old: it.notNull.__old, new: it.notNull.__new } };
+            return { ...it, notNull: { type: 'changed', old: it.notNull.__old, new: it.notNull.__new } }
         }
         if ('notNull__added' in it) {
-            const { notNull__added, ...others } = it;
-            return { ...others, notNull: { type: 'added', value: it.notNull__added } };
+            const { notNull__added, ...others } = it
+            return { ...others, notNull: { type: 'added', value: it.notNull__added } }
         }
         if ('notNull__deleted' in it) {
-            const { notNull__deleted, ...others } = it;
-            return { ...others, notNull: { type: 'deleted', value: it.notNull__deleted } };
+            const { notNull__deleted, ...others } = it
+            return { ...others, notNull: { type: 'deleted', value: it.notNull__deleted } }
         }
-        return it;
-    });
-    return result[0];
-};
-//# sourceMappingURL=jsonDiffer.js.map
+        return it
+    }).map(it => {
+        if ('references' in it) {
+            return { ...it, references: { type: 'changed', old: it.references.__old, new: it.references.__new } }
+        }
+        if ('references__added' in it) {
+            const { references__added, ...others } = it
+            return { ...others, references: { type: 'added', value: it.references__added } }
+        }
+        if ('references__deleted' in it) {
+            const { references__deleted, ...others } = it
+            return { ...others, references: { type: 'deleted', value: it.references__deleted } }
+        }
+        return it
+    })
+    return result[0]
+}