drizzle-kit 0.9.1 → 0.9.5

package/src/cli/components-api/index.tsx

@@ -1,76 +0,0 @@
-import React from 'react';
-import { proxy } from 'valtio';
-
-import {
-  ColumnsResultData,
-  Named,
-  TablesResultData,
-} from 'cli/commands/migration/migrate';
-import Task, { CallbackProps } from 'cli/components-api/components/Task';
-import createApp from 'cli/components-api/CreateApp';
-import { TableWithColumn } from 'cli/machines/resolveColumnsMachine';
-import PromptTablesConflicts, { RenderTablesSelectProps } from 'cli/components-api/components/PromptTablesConflicts';
-import PromptColumnsConflicts from 'cli/components-api/components/PromptColumnsConflicts';
-
-const componentsList = proxy<React.ReactElement<any, any>[]>([]);
-let app: ReturnType<typeof createApp>;
-
-export interface CreateTaskParams<In, Cbs> {
-  input: In,
-  run: (cbs: Cbs) => void
-}
-
-const prepareApp = () => {
-  if (!app) {
-    app = createApp(componentsList);
-    componentsList.length = 0;
-  }
-};
-
-export const task = <T extends unknown>(
-  titleStr: string,
-  func: (props: CallbackProps) => T,
-) => new Promise<T>((
-    resolve,
-  ) => {
-    prepareApp();
-
-    componentsList.push(
-      <Task
-        titleStr={titleStr}
-        func={func}
-        onDone={(val: T) => resolve(val)}
-      />,
-    );
-  });
-
-export const promptTablesConflicts = <T extends Named>(
-  { missingTables, newTables }: RenderTablesSelectProps<T>,
-) => new Promise<TablesResultData<T>>((
-  resolve,
-) => {
-  prepareApp();
-
-  componentsList.push(
-    <PromptTablesConflicts
-      onDone={(val) => resolve(val)}
-      missingTables={missingTables}
-      newTables={newTables}
-    />,
-  );
-});
-
-export const promptColumnsConflicts = (
-  tableWithColumns: TableWithColumn,
-) => new Promise<ColumnsResultData<Named>>((
-  resolve,
-) => {
-  prepareApp();
-
-  componentsList.push(
-    <PromptColumnsConflicts
-      onDone={(val) => resolve(val)}
-      tableWithColumns={tableWithColumns}
-    />,
-  );
-});

package/src/cli/enq.ts

@@ -1,41 +0,0 @@
-import { Command } from 'commander'
-import fs from 'fs'
-
-const main = async () => {
-    const program = new Command()
-        .arguments("[input]")
-
-    // const addCommand = new Command('add')
-    // program.addCommand(addCommand)
-    program.parse(process.argv)
-
-
-    if (program.args.length === 0) {
-        return
-    }
-
-    console.log(program.args)
-    const [input] = program.args
-    if (input === 'add') {
-        //todo add item
-        // // const exampleLink = terminalLink('here', 'https://google.com')
-        // console.log(`Example see ${exampleLink}`)
-        // console.log(exampleLink)
-        // try {
-        //     const newEntry = await prepareNewEntry()
-        //     newEntry.secret
-        // } catch (_) { }
-        return
-    }
-
-    if (fs.existsSync(input)) {
-        // handle file
-        console.log('handle file')
-        return
-    }
-
-    console.log('is encoded secret',)
-}
-
-
-main()

package/src/cli/index.tsx

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-import { program } from 'commander';
-import 'source-map-support/register';
-import 'pretty-error/start';
-
-import './commands/migration';
-
-program.parse();

package/src/cli/machines/resolveColumnsMachine.ts

@@ -1,179 +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 };
-
-export interface TableWithColumn {
-  name: string;
-  added: Named[],
-  deleted: Named[],
-}
-
-interface Props {
-  tableWithColumns: TableWithColumn,
-}
-
-interface Context {
-  tableName: string,
-  addedColumns: Named[],
-  deletedColumns: Named[],
-  missingItemIndex: number,
-  newItemIndex: number,
-  created: Named[];
-  renamed: RenamedObject<Named>[];
-  deleted: Named[];
-}
-
-const createResolveColumnsMachine = (props: Props) => (
-  createMachine<Context, Event>({
-    id: 'resolveColumns',
-    initial: 'table',
-    context: {
-      tableName: props.tableWithColumns.name,
-      addedColumns: props.tableWithColumns.added,
-      deletedColumns: props.tableWithColumns.deleted,
-      missingItemIndex: 0,
-      newItemIndex: 0,
-      created: [],
-      renamed: [],
-      deleted: [],
-    },
-    states: {
-      table: {
-        entry: send({ type: 'NEXT' }),
-        on: {
-          NEXT: [
-            {
-              target: 'done',
-              cond: 'isMissingColumnsResolved',
-              actions: ['resolveRemaining'],
-            },
-            {
-              target: 'done',
-              cond: 'isNewColumnsResolved',
-              actions: ['resolveMissing'],
-            },
-          ],
-          CHOICE_ITEM: { target: 'action', actions: ['choseItem'] },
-        },
-      },
-      action: {
-        initial: 'actionChoice',
-        states: {
-          actionChoice: {
-            on: { DELETE: '#resolveColumns.confirmationDelete', RENAME: 'rename' },
-          },
-          rename: {
-            on: {
-              CHOICE_NEW_ITEM: { target: '#resolveColumns.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: 'isMissingColumnsResolved',
-              actions: ['resolveRemaining'],
-            },
-            {
-              target: 'table',
-            },
-          ],
-        },
-      },
-      done: {},
-    },
-  },
-  {
-    guards: {
-      isMissingColumnsResolved: ({ deletedColumns }) => !deletedColumns.length,
-      isNewColumnsResolved: ({ addedColumns }) => !addedColumns.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({
-        deleted: ({
-          missingItemIndex,
-          deleted,
-          deletedColumns,
-        }) => [...deleted, deletedColumns[missingItemIndex]],
-        deletedColumns: ({
-          missingItemIndex,
-          deletedColumns,
-        }) => deletedColumns.filter((_, index) => index !== missingItemIndex),
-      }),
-
-      rename: assign({
-        renamed: ({
-          missingItemIndex,
-          newItemIndex,
-          renamed,
-          addedColumns,
-          deletedColumns,
-        }) => [
-          ...renamed,
-          { old: deletedColumns[missingItemIndex], new: addedColumns[newItemIndex] },
-        ],
-        deletedColumns: ({
-          missingItemIndex,
-          deletedColumns,
-        }) => deletedColumns.filter((_, index) => index !== missingItemIndex),
-        addedColumns: ({
-          newItemIndex,
-          addedColumns,
-        }) => addedColumns.filter((_, index) => index !== newItemIndex),
-      }),
-
-      resolveRemaining: assign({
-        created: ({
-          addedColumns,
-          created,
-        }) => [...created, ...addedColumns],
-        addedColumns: (context) => [],
-      }),
-
-      resolveMissing: assign({
-        deleted: ({
-          deletedColumns,
-          deleted,
-        }) => [...deleted, ...deletedColumns],
-        deletedColumns: (context) => [],
-      }),
-    },
-  }));
-
-export default createResolveColumnsMachine;

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,
-  },
-];