drizzle-kit 0.9.38 → 0.9.41

package/readme.rst

@@ -0,0 +1,2 @@
+## Documentation
+

package/src/cli/commands/migrate.ts

@@ -0,0 +1,79 @@
+import { task, promptTablesConflicts, promptColumnsConflicts } from '../components-api';
+import fs from 'fs';
+import yaml from 'js-yaml'
+import prepareMigration from '../../migrationPreparator';
+import { applySnapshotsDiff, Column, ColumnsResolverInput, ColumnsResolverOutput, Table, TablesResolverInput, TablesResolverOutput } from '../../snapshotsDiffer';
+
+export interface Config {
+  dataFolder: string;
+  migrationRootFolder?: string;
+}
+
+export const prepareAndMigrate = async () => {
+  const drizzleConfig: Config = yaml.load(fs.readFileSync('drizzle.config.yml', { encoding: 'utf-8' })) as Config;
+  const migrationRootFolder = drizzleConfig.migrationRootFolder || 'drizzle' // or from config/params
+  const dataFolder = drizzleConfig.dataFolder
+
+  try {
+    const { prev, cur } = await prepareJsonSnapshots(migrationRootFolder, dataFolder)
+    freeeeeeze(prev);
+    freeeeeeze(cur);
+    const sql = await prepareSQL(prev, cur)
+    // todo: save results to a new migration folder
+    const folderName = prepareSnapshotFolderName()
+    const migrationFolderPath = `./${migrationRootFolder}/${folderName}`
+    fs.mkdirSync(migrationFolderPath)
+    fs.writeFileSync(`${migrationFolderPath}/snapshot.json`, JSON.stringify(cur, null, 2))
+    fs.writeFileSync(`${migrationFolderPath}/migration.sql`, sql)
+  } catch (e) {
+    console.error(e)
+  }
+}
+
+const freeeeeeze = (obj: any) => {
+  Object.freeze(obj)
+  for (let key in obj) {
+    if (obj.hasOwnProperty(key) && typeof obj[key] === 'object') {
+      freeeeeeze(obj[key]);
+    }
+  }
+}
+
+const prepareJsonSnapshots = async (migrationRootFolder: string, dataFolder: string) => {
+  return await task('Preparing data schema json snapshot', async ({ setTitle }) => {
+    return prepareMigration(migrationRootFolder, dataFolder)
+  });
+}
+
+export const prepareSQL = async (prev: object, cur: object) => {
+  const tablesResolver = async (input: TablesResolverInput<Table>): Promise<TablesResolverOutput<Table>> => {
+    try {
+      const { created, deleted, renamed } = await promptTablesConflicts({
+        newTables: input.created,
+        missingTables: input.deleted,
+      })
+
+      return { created: created, deleted: deleted, renamed: renamed };
+
+    } catch (e) {
+      console.error(e)
+      throw e
+    }
+  }
+
+  const columnsResolver = async (input: ColumnsResolverInput<Column>): Promise<ColumnsResolverOutput<Column>> => {
+    const result = await promptColumnsConflicts({ name: input.tableName, added: input.created, deleted: input.deleted })
+    return { tableName: input.tableName, created: result.created, deleted: result.deleted, renamed: result.renamed }
+  }
+
+  return await applySnapshotsDiff(prev, cur, tablesResolver, columnsResolver);
+};
+
+const prepareSnapshotFolderName = () => {
+  const now = new Date()
+  return `${now.getFullYear()}${two(now.getUTCMonth() + 1)}${two(now.getUTCDate())}${two(now.getUTCHours())}${two(now.getUTCMinutes())}${two(now.getUTCSeconds())}`
+}
+
+const two = (input: number): string => {
+  return input.toString().padStart(2, '0')
+}

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

@@ -0,0 +1,287 @@
+import { interpret } from 'xstate';
+
+import createResolveTablesMachine, { CreateTablesMachineProps } from '../machines/resolveTablesMachine';
+import createResolveColumnsMachine, { CreateColumnsMachineProps } from '../machines/resolveColumnsMachine';
+import formatDataForTable from '../utils/formatDataForTable';
+
+const loading = require('loading-cli');
+const { Select, Confirm } = require('enquirer');
+const Table = require('cli-table');
+
+export interface CallbackProps {
+  setTitle: (title: string) => void;
+  setError: (error: any) => void;
+}
+
+export interface Named {
+  name: string
+}
+
+export interface RenamedObject<T> {
+  from: T,
+  to: T
+}
+
+interface TablesResultData<T extends Named> {
+  created: T[],
+  renamed: RenamedObject<T>[],
+  deleted: T[],
+}
+
+interface ColumnsResultData<T extends Named> {
+  created: T[],
+  renamed: RenamedObject<T>[],
+  deleted: T[],
+}
+
+const actions = ['Renamed', 'Deleted'];
+
+const bold = '\x1b[1m';
+const red = '\u001B[31m';
+const blue = '\u001B[34m';
+const reset = '\u001B[0m';
+
+const getElementIndexByName = (
+  array: Named[],
+  elementName: string,
+) => array.findIndex(({ name }) => name === elementName);
+
+const clearLine = () => {
+  process.stdout.moveCursor(0, -1);
+  process.stdout.clearLine(1);
+}
+
+export const task = async <T extends unknown>(
+  titleStr: string,
+  func: (props: CallbackProps) => T,
+): Promise<T> => {
+  const progress = loading({
+    frames: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'],
+    text: `${bold}${titleStr}`,
+
+  }).start();
+  try {
+    const result = await func({
+      setTitle: (title: string) => { progress.text = `${bold}${title}`; },
+      setError: (error: any) => { progress.fail(error.message); },
+    });
+    progress.succeed();
+    return result;
+  } catch (error: any) {
+    progress.fail(`${bold}${error.message}`);
+    throw Error(error);
+  }
+};
+
+export const promptTablesConflicts = <T extends Named>(
+  { missingTables: m, newTables: n }: CreateTablesMachineProps<T>,
+) => new Promise<TablesResultData<T>>((
+    resolve,
+  ) => {
+    const resolveTablesMachine = createResolveTablesMachine({ missingTables: m, newTables: n });
+    const service = interpret(resolveTablesMachine).start();
+    service.subscribe(async (state) => {
+      try {
+        const {
+          missingItemIndex,
+          newItemIndex,
+          newTables,
+          missingTables,
+          createdTables,
+          renamedTables,
+          deletedTables,
+        } = state.context;
+
+        if (state.matches('idle')) {
+          service.send({ type: 'NEXT' });
+        }
+
+        if (state.changed && state.matches('table')) {
+          const tableName = await new Select({
+            name: 'tableName',
+            message: 'Chose missing table:',
+            choices: missingTables.map(({ name }) => name),
+          }).run();
+          clearLine();
+          service.send({ type: 'CHOICE_ITEM', itemIndex: getElementIndexByName(missingTables, tableName) });
+        }
+
+        if (state.changed && state.matches('action.actionChoice')) {
+          const actionName = await new Select({
+            name: 'tableName',
+            message: `Table "${missingTables[missingItemIndex].name}" was:`,
+            choices: actions,
+          }).run();
+          clearLine();
+          service.send({ type: actionName.toUpperCase() });
+        }
+
+        if (state.changed && state.matches('confirmationDelete')) {
+          const confirmation = await new Confirm({
+            name: 'confirm',
+            message: 'Are you sure?',
+            initial: true,
+          }).run();
+          clearLine();
+
+          if (confirmation) console.log(`${bold}Deleted "${missingTables[missingItemIndex].name}" table, ${red}all data will be lost!`)
+          service.send({ type: confirmation ? 'CONFIRM' : 'CANCEL' });
+        }
+
+        if (state.changed && state.matches('confirmationRename')) {
+          const confirmation = await new Confirm({
+            name: 'confirm',
+            message: 'Are you sure?',
+            initial: true,
+          }).run();
+          clearLine();
+
+          if (confirmation) console.log(`${bold}Renamed "${missingTables[missingItemIndex].name}" -> "${newTables[newItemIndex].name}"`)
+
+          service.send({ type: confirmation ? 'CONFIRM' : 'CANCEL' });
+        }
+
+        if (state.changed && state.matches('action.rename')) {
+          const tableName = await new Select({
+            name: 'tableName',
+            message: `Table "${missingTables![missingItemIndex]?.name}" was renamed to:`,
+            choices: newTables.map(({ name }) => name),
+          }).run();
+          clearLine();
+
+          service.send({ type: 'CHOICE_NEW_ITEM', itemIndex: getElementIndexByName(newTables, tableName) });
+        }
+
+        if (state.changed && state.matches('done')) {
+          if (createdTables.length || deletedTables.length || renamedTables.length) {
+            const table = new Table({
+              head: [`${blue}Created`, `${blue}Renamed`, `${blue}Deleted`],
+              rows: formatDataForTable(createdTables, renamedTables, deletedTables)
+            });
+
+            console.log(`${reset}${bold}Tables:`);
+            console.log(table.toString());
+          }
+
+          resolve({
+            created: createdTables,
+            deleted: deletedTables,
+            renamed: renamedTables,
+          });
+
+          service.stop();
+        }
+      } catch (e) {
+        console.error(e);
+      }
+    });
+  });
+
+export const promptColumnsConflicts = <T extends Named>(
+  props: CreateColumnsMachineProps<T>,
+) => new Promise<ColumnsResultData<T>>((
+    resolve,
+  ) => {
+    const resolveColumnsMachine = createResolveColumnsMachine(props);
+    const service = interpret(resolveColumnsMachine).start();
+
+    service.subscribe(async (state) => {
+      try {
+        const {
+          tableName,
+          addedColumns,
+          deletedColumns,
+          missingItemIndex,
+          newItemIndex,
+          created,
+          renamed,
+          deleted,
+        } = state.context;
+
+        if (state.matches('idle')) {
+          service.send({ type: 'NEXT' });
+        }
+
+        if (state.changed && state.matches('table')) {
+          const columnName = await new Select({
+            name: 'columnName',
+            message: `Table "${tableName}" missing columns:`,
+            choices: deletedColumns.map(({ name }) => name),
+          }).run();
+          clearLine();
+
+          service.send({ type: 'CHOICE_ITEM', itemIndex: getElementIndexByName(deletedColumns, columnName) });
+        }
+
+        if (state.changed && state.matches('action.actionChoice')) {
+          const actionName = await new Select({
+            name: 'tableName',
+            message: `Column "${deletedColumns[missingItemIndex].name}" was:`,
+            choices: actions,
+          }).run();
+          clearLine();
+
+          service.send({ type: actionName.toUpperCase() });
+        }
+
+        if (state.changed && state.matches('confirmationDelete')) {
+          const confirmation = await new Confirm({
+            name: 'confirm',
+            message: 'Are you sure?',
+            initial: true,
+          }).run();
+          clearLine();
+
+          if (confirmation) console.log(`${bold}Deleted column "${deletedColumns[missingItemIndex].name}" from "${tableName}" table, ${red}all data will be lost!`)
+
+          service.send({ type: confirmation ? 'CONFIRM' : 'CANCEL' });
+        }
+
+        if (state.changed && state.matches('confirmationRename')) {
+          const confirmation = await new Confirm({
+            name: 'confirm',
+            message: 'Are you sure?',
+            initial: true,
+          }).run();
+          clearLine();
+
+          if (confirmation) console.log(`${bold}Renamed "${deletedColumns[missingItemIndex].name} -> ${addedColumns[newItemIndex].name}" in "${tableName}" table`)
+
+          service.send({ type: confirmation ? 'CONFIRM' : 'CANCEL' });
+        }
+
+        if (state.changed && state.matches('action.rename')) {
+          const columnName = await new Select({
+            name: 'tableName',
+            message: `Column "${deletedColumns![missingItemIndex]?.name}" was renamed to:`,
+            choices: addedColumns.map(({ name }) => name),
+          }).run();
+          clearLine();
+
+          service.send({ type: 'CHOICE_NEW_ITEM', itemIndex: getElementIndexByName(addedColumns, columnName) });
+        }
+
+        if (state.changed && state.matches('done')) {
+          if (created.length || deleted.length || renamed.length) {
+            const table = new Table({
+              head: [`${blue}Created`, `${blue}Renamed`, `${blue}Deleted`],
+              rows: formatDataForTable(created, renamed, deleted)
+            });
+
+            console.log(`${reset}${bold}Table "${tableName}" columns:`);
+            console.log(table.toString());
+          }
+
+          resolve({
+            created,
+            deleted,
+            renamed,
+          });
+
+          service.stop();
+        }
+      } catch (e) {
+        console.error(e);
+      }
+    });
+  });

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/index.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import { Command, program } from 'commander';
+import { prepareAndMigrate } from './commands/migrate';
+// import 'source-map-support/register';
+import 'pretty-error/start';
+import './commands/migrate';
+
+const migrationCommand = new Command('migrate')
+    .alias('mg')
+    .description('Migration')
+    .action(prepareAndMigrate);
+
+program.addCommand(migrationCommand)
+program.parse();

package/src/cli/machines/resolveColumnsMachine.ts

@@ -0,0 +1,173 @@
+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 };
+
+export interface CreateColumnsMachineProps<T> {
+  name: string;
+  added: T[],
+  deleted: T[],
+}
+
+interface Context<T> {
+  tableName: string,
+  addedColumns: T[],
+  deletedColumns: T[],
+  missingItemIndex: number,
+  newItemIndex: number,
+  created: T[];
+  renamed: RenamedObject<T>[];
+  deleted: T[];
+}
+
+const createResolveColumnsMachine = <T extends Named>(props: CreateColumnsMachineProps<T>) => (
+  createMachine<Context<T>, Event>({
+    id: 'resolveColumns',
+    initial: 'idle',
+    context: {
+      tableName: props.name,
+      addedColumns: props.added,
+      deletedColumns: props.deleted,
+      missingItemIndex: 0,
+      newItemIndex: 0,
+      created: [],
+      renamed: [],
+      deleted: [],
+    },
+    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: '#resolveColumns.confirmationDelete', RENAMED: 'rename' },
+          },
+          rename: {
+            on: {
+              CHOICE_NEW_ITEM: { target: '#resolveColumns.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: ({ deletedColumns, addedColumns }) => !deletedColumns.length || !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,
+          { from: deletedColumns[missingItemIndex], to: 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],
+        deleted: ({
+          deletedColumns,
+          deleted,
+        }) => [...deleted, ...deletedColumns],
+        deletedColumns: (context) => [],
+        addedColumns: (context) => [],
+      }),
+    },
+  }));
+
+export default createResolveColumnsMachine;