drizzle-kit 0.9.41 → 0.9.42

package/src/cli/machines/resolveTablesMachine.ts

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

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

@@ -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,37 +0,0 @@
-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,260 +0,0 @@
-'use-strict';
-
-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]
-    })
-
-    // find any alternations made to a renamed table
-    const altered = renamed.map(pair => {
-        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);
-        }
-    });
-}
-
-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)
-        }
-    })
-}
-const migrateSchema = (json) => {
-    if (json['version'] === '1') {
-        update1to2(json)
-        json['version'] = '2'
-    }
-}
-
-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, 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)
-
-    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])
-            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
-
-    // 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] }
-    })
-    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, 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 alternationsInColumn = (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
-    }).map(it => {
-        if ('type' in it) {
-            // type change
-            return { ...it, type: { type: 'changed', old: it.type.__old, new: it.type.__new } }
-        }
-        return it
-    }).map(it => {
-        if ('defaultValue' in it) {
-            return { ...it, defaultValue: { type: 'changed', old: it.defaultValue.__old, new: it.defaultValue.__new } }
-        }
-        if ('defaultValue__added' in it) {
-            const { defaultValue__added, ...others } = it
-            return { ...others, defaultValue: { type: 'added', value: it.defaultValue__added } }
-        }
-        if ('defaultValue__deleted' in it) {
-            const { defaultValue__deleted, ...others } = it
-            return { ...others, defaultValue: { type: 'deleted', value: it.defaultValue__deleted } }
-        }
-        return it
-    }).map(it => {
-        if ('notNull' in it) {
-            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 } }
-        }
-        if ('notNull__deleted' in it) {
-            const { notNull__deleted, ...others } = it
-            return { ...others, notNull: { type: 'deleted', value: it.notNull__deleted } }
-        }
-        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]
-}