drizzle-kit 0.9.41 → 0.9.44

package/readme.rst

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

package/src/cli/commands/migrate.ts

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

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

@@ -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.ts

@@ -1,14 +0,0 @@
-#!/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

@@ -1,173 +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 };
-
-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;