drizzle-kit 0.9.0 → 0.9.4

package/src/common/components/SelectTable.tsx

@@ -1,134 +0,0 @@
-import React, { useEffect, useState } from 'react';
-import { Box, Text, useInput } from 'ink';
-
-interface Props {
-  text: React.ReactFragment;
-  selectFrom: {missing: string, newName: string, deleted: boolean, renamed: string}[];
-  onDone: (value: number) => void;
-}
-
-const SelectTable: React.FC<Props> = ({
-  text,
-  selectFrom,
-  onDone,
-}: React.PropsWithChildren<Props>) => {
-  const [selectedIndex, setSelectedIndex] = useState(0);
-  const [isDone, setDone] = useState(false);
-
-  useInput((input, key) => {
-    if (key.upArrow) {
-      const updatedIndex = selectedIndex === 0 ? selectFrom.length - 1 : selectedIndex - 1;
-      setSelectedIndex(updatedIndex);
-    }
-    if (key.downArrow) {
-      const updatedIndex = selectedIndex === (selectFrom.length - 1) ? 0 : selectedIndex + 1;
-      setSelectedIndex(updatedIndex);
-    }
-
-    if (key.return) {
-      setDone(true);
-    }
-  });
-
-  useEffect(() => {
-    if (isDone) {
-      onDone(selectedIndex);
-    }
-  }, [isDone]);
-
-  const prefix = (
-    <Box flexDirection="row">
-      <Box marginRight={1}>
-        {isDone ? (
-          <Text>
-            [
-            <Text color="green">✓</Text>
-            ]
-          </Text>
-        ) : (
-          <Text>
-            [
-            <Text color="gray">?</Text>
-            ]
-          </Text>
-        )}
-      </Box>
-      <Text>
-        {text}
-        {' '}
-      </Text>
-    </Box>
-  );
-
-  return (
-    <>
-      <Box flexDirection={isDone ? 'row' : 'column'}>
-        {prefix}
-        {isDone ? (
-          <Text>{selectedIndex}</Text>
-        ) : (
-          <>
-            <Box borderStyle="single" padding={-1} width="50%">
-              <Box width="25%">
-                <Text>Missing</Text>
-              </Box>
-              <Box width="25%">
-                <Text>| New</Text>
-              </Box>
-              <Box width="25%">
-                <Text>| Deleted</Text>
-              </Box>
-              <Box width="25%">
-                <Text> | Renamed</Text>
-              </Box>
-            </Box>
-            {selectFrom.map(({
-              missing, newName, deleted, renamed,
-            }, index) => (
-              <Box key={index} padding={0} width="50%">
-                <Box paddingLeft={1} width="25%">
-                  <Text
-                    color={index === selectedIndex ? 'green' : 'white'}
-                  >
-                    {index === selectedIndex ? '>' : '|'}
-                    {' '}
-                    {missing}
-                  </Text>
-                </Box>
-                <Box width="25%">
-                  <Text
-                    color={index === selectedIndex ? 'green' : 'white'}
-                  >
-                    |
-                    {' '}
-                    {newName}
-                  </Text>
-                </Box>
-                <Box width="25%">
-                  <Text
-                    color={index === selectedIndex ? 'green' : 'white'}
-                  >
-                    |
-                    {' '}
-                    {deleted && '✓'}
-                  </Text>
-                </Box>
-                <Box width="25%">
-                  <Text
-                    color={index === selectedIndex ? 'green' : 'white'}
-                  >
-                    |
-                    {' '}
-                    {renamed || ''}
-                  </Text>
-                </Box>
-              </Box>
-            ))}
-          </>
-        )}
-      </Box>
-    </>
-  );
-};
-
-export default SelectTable;

package/src/index.ts

@@ -1,10 +0,0 @@
-import * as fs from 'fs';
-import Serializer from './serializer';
-
-const serializer = new Serializer();
-
-const main = () => {
-  const resutl = serializer.generate();
-  fs.writeFileSync('result.json', JSON.stringify(resutl, null, 2));
-};
-main();

package/src/serializer.ts

@@ -1,135 +0,0 @@
-/* eslint-disable no-restricted-syntax */
-/* eslint-disable new-cap */
-/* eslint-disable global-require */
-/* eslint-disable import/no-dynamic-require */
-import { AbstractTable, Column, DB } from '@lambda-team/ltdl';
-import ColumnType from '@lambda-team/ltdl/columns/types/columnType';
-import PgEnum from '@lambda-team/ltdl/columns/types/pgEnum';
-import TableIndex from '@lambda-team/ltdl/indexes/tableIndex';
-import * as fs from 'fs';
-import { Pool } from 'pg';
-
-interface ColumnAsObject{
-  [name: string]:{
-    name?: string
-    type?: string
-    primaryKey?: boolean
-    autoincrement?: boolean
-    unique?: boolean
-    references?: {
-      table: string,
-      column: string
-    }
-  }
-}
-
-interface IndexColumnAsObject{
-  [name: string]: {
-    name?: string
-  }
-}
-
-interface IndexAsObject{
-  [name: string]:{
-    name?: string
-    columns?: ColumnAsObject
-  }
-}
-
-interface TableAsObject {
-  [name: string]: {
-    name: string,
-    columns: ColumnAsObject,
-    indexes: {
-      [name: string]:{
-        name?: string
-        type?: string
-      }
-    }
-  }
-}
-
-interface EnumAsObject {
-  [name: string]: {
-    name: string,
-    values: string[]
-  }
-}
-
-export default class MigrationSerializer {
-  public generate = () => {
-    const result: TableAsObject = {};
-    const filenames = fs.readdirSync('./examples/tables/');
-
-    const enumToReturn: EnumAsObject = {};
-
-    filenames.forEach((filename) => {
-      const table = this.fromFile(`../examples/tables/${filename.split('.')[0]}`);
-      const tableValues = Object.entries(table);
-
-      const columnToReturn: ColumnAsObject = {};
-      const indexToReturn: IndexAsObject = {};
-
-      for (const properties of tableValues) {
-        const key = properties[0];
-        const value = properties[1];
-        if (value instanceof TableIndex) {
-          const columns = value.getColumns();
-          const name = value.indexName();
-
-          const indexColumnToReturn: IndexColumnAsObject = {};
-
-          for (const column of columns) {
-            const columnName = column.getColumnName();
-            indexColumnToReturn[columnName] = {
-              name: columnName,
-            };
-          }
-
-          indexToReturn[name] = {
-            name,
-            columns: indexColumnToReturn,
-          };
-        }
-        if (value instanceof Column) {
-          const columnType = value.getColumnType();
-          if (columnType instanceof PgEnum) {
-            const enumValues = Object.values(columnType.codeType) as string[];
-            enumToReturn[columnType.getDbName()] = {
-              name: columnType.getDbName(),
-              values: enumValues,
-            };
-          }
-          columnToReturn[key] = {
-            name: value.getColumnName(),
-            type: (value.getColumnType() as ColumnType).getDbName(),
-            primaryKey: !!value.primaryKeyName,
-            autoincrement: value.isAutoIncrement(),
-            unique: !!value.uniqueKeyName,
-          };
-          const referenced = value.getReferenced();
-          if (referenced){
-            columnToReturn[key].references = {
-              table: referenced.getParentName(),
-              column: referenced.getColumnName()
-            }
-          }
-        }
-      }
-
-      result[table.tableName()] = {
-        name: table.tableName(),
-        columns: columnToReturn,
-        indexes: indexToReturn,
-      };
-    });
-
-    return { version: '1', tables: result, enums: enumToReturn };
-  };
-
-  private fromFile(filepath: string): AbstractTable<any> {
-    const db = new DB(new Pool());
-    const importedTable = require(filepath);
-    return (new importedTable.default(db) as AbstractTable<any>);
-  }
-}

package/tsconfig.json

@@ -1,28 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es2020",
-    "lib": ["es2020"],
-    "allowJs": false,
-    "skipLibCheck": false,
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "strict": true,
-    "noImplicitOverride": true,
-    "forceConsistentCasingInFileNames": true,
-    "module": "commonjs",
-    "moduleResolution": "node",
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "jsx": "react",
-    "sourceMap": true,
-    "baseUrl": "./src",
-    "paths": {
-      "@common/*": [
-        "./common/*"
-      ],
-      "@utils/*": [
-        "./utils/*"
-      ]
-    }
-  }
-}

package/webpack.config.js

@@ -1,56 +0,0 @@
-const path = require('path');
-const webpack = require('webpack');
-const { TsconfigPathsPlugin } = require('tsconfig-paths-webpack-plugin');
-const nodeExternals = require('webpack-node-externals');
-const ShebangPlugin = require('webpack-shebang-plugin');
-
-const isProd = process.env.NODE_ENV === 'production';
-
-module.exports = {
-    entry: {
-        sj: './src/cli/index.tsx',
-    },
-    output: {
-        path: path.resolve(__dirname, 'dist'),
-        filename: '[name].js',
-        clean: true,
-    },
-    mode: isProd ? 'production' : 'development',
-    externalsPresets: {
-        node: true,
-    },
-    externals: [nodeExternals()],
-    devtool: isProd ? 'source-map' : 'inline-source-map',
-    module: {
-        rules: [
-            {
-                test: /\.js$/,
-                loader: 'source-map-loader',
-                enforce: 'pre',
-            },
-            {
-                test: /\.tsx?$/,
-                use: {
-                    loader: 'ts-loader',
-                    // options: {
-                    //     onlyCompileBundledFiles: true,
-                    // },
-                },
-                exclude: /node_modules/,
-            },
-        ],
-    },
-    plugins: [
-        new webpack.WatchIgnorePlugin({
-            paths: [/\.js$/, /\.d\.ts$/],
-        }),
-        new ShebangPlugin(),
-    ],
-    resolve: {
-        extensions: ['.js', '.ts', '.tsx'],
-        plugins: [new TsconfigPathsPlugin()],
-    },
-    watchOptions: {
-        ignored: /node_modules/,
-    },
-};