drizzle-kit 0.9.2 → 0.9.6

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

@@ -1,180 +0,0 @@
-import React from 'react';
-import { Box, Text } from 'ink';
-import SelectInput from 'ink-select-input';
-import Table, { Header } from 'ink-table';
-import { useMachine } from '@xstate/react';
-import { Item } from 'ink-select-input/build/SelectInput';
-
-import { Named, TablesResultData } from 'cli/commands/migration/migrate';
-import createResolveTablesMachine from 'cli/machines/resolveTablesMachine';
-import formatDataForTable from 'cli/utils/formatDataForTable';
-import {
-  Action,
-  Confirmation,
-  actions,
-  confirmations,
-} from 'cli/utils/valuesForPrompts';
-
-export interface RenderTablesSelectProps<T extends Named> {
-  missingTables: T[],
-  newTables: T[],
-}
-
-interface Props<T extends Named> extends RenderTablesSelectProps<T> {
-  onDone: (value: TablesResultData<T>) => void;
-}
-
-const PromptTablesConflicts: React.FC<Props<any>> = ({
-  onDone,
-  newTables: newProps,
-  missingTables: missingProps,
-}) => {
-  const [current, send] = useMachine(createResolveTablesMachine({
-    missingTables: missingProps,
-    newTables: newProps,
-  }));
-
-  const {
-    missingItemIndex,
-    newTables,
-    missingTables,
-    createdTables,
-    renamedTables,
-    deletedTables,
-  } = current.context;
-
-  const selectItemIndex = (item: Item<number>) => {
-    send({ type: 'CHOICE_ITEM', itemIndex: item.value });
-  };
-
-  const selectNewItemIndex = (item: Item<number>) => {
-    send({ type: 'CHOICE_NEW_ITEM', itemIndex: item.value });
-  };
-
-  const selectAction = (action: Item<Action>) => {
-    send({ type: action.value });
-  };
-
-  const confirm = (confirmationItem: Item<Confirmation>) => {
-    send({ type: confirmationItem.value });
-  };
-
-  const renderDOM = () => {
-    if (current.matches('table')) {
-      return (
-        <>
-          <Box display="flex" flexDirection="column">
-            <Box display="flex">
-              <Box flexDirection="column">
-                <Header>Missing tables:</Header>
-                <SelectInput
-                  items={missingTables!.map((table, i: number) => ({
-                    key: String(i),
-                    label: table.name,
-                    value: i,
-                  }))}
-                  onSelect={selectItemIndex}
-                />
-              </Box>
-              {!!newTables?.length && (
-                <Box flexDirection="column" paddingLeft={5}>
-                  <Header>New tables:</Header>
-                  <Box display="flex" flexDirection="column">
-                    {newTables.map(({ name }, i) => <Text key={name + i}>{name}</Text>)}
-                  </Box>
-                </Box>
-              )}
-            </Box>
-          </Box>
-        </>
-      );
-    }
-
-    if (current.matches('action.actionChoice')) {
-      const tempActions = !newTables!.length
-        ? actions.filter(({ value }) => value !== Action.RENAME)
-        : actions;
-
-      return (
-        <>
-          <Header>{`${missingTables![missingItemIndex]?.name} is:`}</Header>
-          <SelectInput items={tempActions} onSelect={selectAction} />
-        </>
-      );
-    }
-
-    if (current.matches('confirmationDelete')) {
-      return (
-        <>
-          <Header>!!! Data in table will be lost !!!</Header>
-          <Text>Are you sure?</Text>
-          <SelectInput items={confirmations} onSelect={confirm} />
-        </>
-      );
-    }
-
-    if (current.matches('confirmationRename')) {
-      return (
-        <>
-          <Header>Are you sure?</Header>
-          <SelectInput items={confirmations} onSelect={confirm} />
-        </>
-      );
-    }
-
-    if (current.matches('action.rename')) {
-      return (
-        <>
-          <Header>{`${missingTables![missingItemIndex]?.name} was renamed to:`}</Header>
-          <SelectInput
-            items={newTables!.map((table, i: number) => ({
-              key: String(i),
-              label: table.name,
-              value: i,
-            }))}
-            onSelect={selectNewItemIndex}
-          />
-        </>
-      );
-    }
-
-    if (current.matches('done')) {
-      onDone({
-        created: createdTables,
-        renamed: renamedTables,
-        deleted: deletedTables,
-      });
-    }
-
-    return (<></>);
-  };
-
-  return (!!deletedTables.length
-      || !!renamedTables.length
-      || !!createdTables.length) ? (
-        <Box flexDirection="column" margin={1}>
-          <Box flexDirection="column" marginBottom={0}>
-            <Header>Tables: </Header>
-            <Table
-              data={formatDataForTable([
-                {
-                  title: 'Deleted',
-                  values: deletedTables,
-                },
-                {
-                  title: 'Renamed',
-                  values: renamedTables,
-                },
-                {
-                  title: 'Created',
-                  values: createdTables,
-                },
-              ])}
-            />
-          </Box>
-          {renderDOM()}
-        </Box>
-    ) : renderDOM();
-};
-
-export default PromptTablesConflicts;

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

@@ -1,85 +0,0 @@
-import React, { useEffect, useState } from 'react';
-import { Box, Newline, Text } from 'ink';
-import Spinner from 'ink-spinner';
-import { CreateTaskParams } from 'cli/components-api/index';
-
-enum StepState {
-  IN_PROGRESS,
-  SUCCESS,
-  FAIL
-}
-
-export interface CallbackProps {
-  setTitle: React.Dispatch<React.SetStateAction<string>>
-  setError: React.Dispatch<React.SetStateAction<any>>
-}
-
-interface Props<T> {
-  func: (props: CallbackProps) => T;
-  onDone: (result: T) => T;
-  titleStr: string;
-}
-
-const Task: React.FC<Props<any>> = <T extends unknown>(props: Props<T>) => {
-  const {
-    func,
-    onDone,
-    titleStr,
-  } = props;
-  const [title, setTitle] = useState<string>(titleStr);
-  const [state, setState] = useState<StepState>(StepState.IN_PROGRESS);
-  const [error, setError] = useState<any>(null);
-
-  useEffect(() => {
-    (async () => {
-      try {
-        const result = await func({ setTitle, setError });
-        setState(StepState.SUCCESS);
-        onDone(result);
-      } catch (e) {
-        setError(e);
-        setState(StepState.FAIL);
-      }
-    })();
-  }, []);
-
-  return (
-    <Box flexDirection="row">
-      <Box marginRight={1}>
-        {state === StepState.IN_PROGRESS ? (
-          <Text>
-            [
-            <Spinner type="dots" />
-            ]
-          </Text>
-        ) : state === StepState.SUCCESS ? (
-          <Text>
-            [
-            <Text color="green">✓</Text>
-            ]
-          </Text>
-        ) : (
-          <Text>
-            [
-            <Text color="red">×</Text>
-            ]
-          </Text>
-        )}
-
-        {state === StepState.FAIL ? (
-          <Text>
-            {title}
-            <Newline />
-            <Text color="red">{error!.message}</Text>
-          </Text>
-        ) : (
-          <>
-            <Text>{title}</Text>
-          </>
-        )}
-      </Box>
-    </Box>
-  );
-};
-
-export default Task;

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;