drizzle-kit 0.9.0 → 0.9.1

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

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

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

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

@@ -0,0 +1,41 @@
+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/machines/resolveColumnsMachine.ts

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