drizzle-kit 0.9.2 → 0.9.6

package/src/sqlgenerator.js

@@ -1,373 +0,0 @@
-import { Types } from "./jsonStatements";
-
-class Convertor {
-    constructor(type) {
-        this.type = type
-    }
-
-    can(type) {
-        return this.type === type;
-    }
-
-    convert(_) {
-        throw Error('override the convert mothod')
-    }
-}
-
-class CreateTableConvertor extends Convertor {
-    constructor() {
-        super(Types.createTable)
-    }
-
-    convert(jsonStatement) {
-        const { tableName, columns } = jsonStatement
-        const mappedColumns = Object.keys(columns)
-            .map(it => {
-                return { ...columns[it] }
-            })
-
-        let statement = ''
-
-        statement += `CREATE TABLE ${tableName} (\n`
-        for (const column of mappedColumns) {
-            // console.log(column);
-            const primaryKeyStatement = column.primaryKey ? "PRIMARY KEY" : ''
-            const notNullStatement = column.notNull ? "NOT NULL" : "";
-            const defaultStatement = column.defaultValue ? `DEFAULT '${column.defaultValue}'` : "";
-            statement += '\t' + `${column.name} ${column.type} ${primaryKeyStatement} ${defaultStatement} ${notNullStatement}`.replace(/  +/g, ' ').trim() + ',\n'
-        }
-        statement += `);`
-        return statement;
-    }
-}
-
-class CreateTypeEnumConvertor extends Convertor {
-    constructor() {
-        super(Types.createTypeEnum)
-    }
-
-    convert(jsonStatement) {
-        const { enumName, values } = jsonStatement
-        let valuesStatement = '('
-        valuesStatement += values.map(it => `'${it}'`).join(', ')
-        valuesStatement += ')'
-
-        return `CREATE TYPE ${enumName} AS ENUM${valuesStatement};`
-    }
-}
-
-class AlterTypeAddValueConvertor extends Convertor {
-    constructor() {
-        super(Types.alterTypeAddValue)
-    }
-
-    convert(jsonStatement) {
-        const { enumName, enumValue } = jsonStatement
-        return `ALTER TYPE ${enumName} ADD VALUE ${enumValue};`
-    }
-}
-
-class DropTableConvertor extends Convertor {
-    constructor() {
-        super(Types.dropTable)
-    }
-
-    convert(jsonStatement) {
-        const { tableName } = jsonStatement
-        return `DROP TABLE ${tableName}`
-    }
-}
-
-class RenameTableConvertor extends Convertor {
-    constructor() {
-        super(Types.renameTable)
-    }
-
-    convert(jsonStatement) {
-        const { from, to } = jsonStatement
-        return `ALTER TABLE ${from} RENAME TO ${to}`
-    }
-}
-
-class AlterTableDropColumnConvertor extends Convertor {
-    constructor() {
-        super(Types.alterTableDropColumn)
-    }
-
-    convert(jsonStatement) {
-        const { tableName, columnName } = jsonStatement
-        return `ALTER TABLE ${tableName} DROP COLUMN IF EXISTS ${columnName};`
-    }
-}
-
-class AlterTableAddColumnConvertor extends Convertor {
-    constructor() {
-        super(Types.alterTableAddColumn)
-    }
-
-    convert(jsonStatement) {
-        const { tableName, column } = jsonStatement
-        const { name, type, defaultValue, notNull } = column;
-
-        const defaultStatement = `${defaultValue ? ` DEFAULT ${defaultValue}` : ''}`
-        const notNullStatement = `${notNull ? ' NOT NULL' : ''}`
-        return `ALTER TABLE ${tableName} ADD COLUMN ${name} ${type}${defaultStatement}${notNullStatement}`.trim() + ';'
-    }
-}
-
-class AlterTableAlterColumnSetTypeConvertor extends Convertor {
-    constructor() {
-        super(Types.alterTableAlterColumnSetType)
-    }
-
-    convert(jsonStatement) {
-        const { tableName, columnName, newDataType } = jsonStatement
-        return `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} SET DATA TYPE ${newDataType};`
-    }
-}
-
-class AlterTableAlterColumnSetNotNullConvertor extends Convertor {
-    constructor() {
-        super(Types.alterTableAlterColumnSetNotNull)
-    }
-
-    convert(jsonStatement) {
-        const { tableName, columnName } = jsonStatement
-        return `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} SET NOT NULL;`
-    }
-}
-
-class AlterTableAlterColumnDropNotNullConvertor extends Convertor {
-    constructor() {
-        super(Types.alterTableAlterColumnDropNotNull)
-    }
-
-    convert(jsonStatement) {
-        const { tableName, columnName } = jsonStatement
-        return `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} DROP NOT NULL;`
-    }
-}
-
-class CreateIndexConvertor extends Convertor {
-    constructor() {
-        super(Types.createIndex)
-    }
-
-    convert(jsonStatement) {
-        const { tableName, indexName, indexValue } = jsonStatement
-        return `CREATE INDEX ${indexName} ON ${tableName} (${indexValue});`
-    }
-}
-
-class DropIndexConvertor extends Convertor {
-    constructor() {
-        super(Types.dropIndex)
-    }
-
-    convert(jsonStatement) {
-        const { indexName } = jsonStatement
-        return `DROP INDEX IF EXISTS ${indexName};`
-    }
-}
-
-const convertors = []
-convertors.push(new CreateTableConvertor())
-convertors.push(new CreateTypeEnumConvertor())
-convertors.push(new DropTableConvertor())
-convertors.push(new RenameTableConvertor())
-convertors.push(new AlterTableDropColumnConvertor())
-convertors.push(new AlterTableAddColumnConvertor())
-convertors.push(new AlterTableAlterColumnSetTypeConvertor())
-convertors.push(new CreateIndexConvertor())
-convertors.push(new DropIndexConvertor())
-convertors.push(new AlterTypeAddValueConvertor())
-convertors.push(new AlterTableAlterColumnSetNotNullConvertor())
-convertors.push(new AlterTableAlterColumnDropNotNullConvertor())
-
-export const fromJson = (statements) => {
-    return statements.map(statement => {
-        const filtered = convertors.filter(it => {
-            return it.can(statement.type)
-        })
-        const convertor = filtered.length === 1 ? filtered[0] : undefined
-
-        if (!convertor) {
-            console.log('no convertor:', statement.type)
-            return 'dry run'
-        }
-
-        return convertor.convert(statement)
-    })
-}
-
-export const prepareDeleteColumns = (tableName, columns) => {
-    let statement = ''
-    for (const column of columns) {
-        statement += `ALTER TABLE ${tableName} DROP COLUMN IF EXISTS ${column.name};`
-        statement += '\n'
-    }
-    return statement.trim()
-}
-
-export const prepareCreateColumns = (tableName, columns) => {
-    let statement = ''
-    for (const column of columns) {
-        const { name, type, defaultValue, notNull } = column;
-
-        const defaultStatement = `${defaultValue ? `DEFAULT ${defaultValue}` : ''}`
-        const notNullStatement = `${notNull ? 'NOT NULL' : ''}`
-        statement += `ALTER TABLE ${tableName} ADD COLUMN ${name} ${type} ${defaultStatement} ${notNullStatement}`.trim() + ';'
-        statement += '\n'
-    }
-    return statement.trim()
-}
-
-export const prepareAlterColumns = (tableName, columns) => {
-    let statement = ''
-    for (const column of columns) {
-        const { name } = column;
-
-        if (column['type']) {
-            const { __new } = column.type
-            statement += `ALTER TABLE ${tableName} ALTER COLUMN ${name} SET DATA TYPE ${__new};`
-            statement += '\n'
-        }
-
-        if (column['defaultValue']) {
-            const { __new } = column.defaultValue
-            statement += `ALTER TABLE ${tableName} ALTER COLUMN ${name} SET DEFAULT ${__new};`
-            statement += '\n'
-        }
-
-        if (column['defaultValue__added']) {
-            statement += `ALTER TABLE ${tableName} ALTER COLUMN ${name} SET DEFAULT ${column.defaultValue__added};`
-            statement += '\n'
-        }
-
-        if (column['defaultValue__deleted']) {
-            // console.log(`default value deleted`)
-            statement += `ALTER TABLE ${tableName} ALTER COLUMN ${name} DROP DEFAULT;`
-            statement += '\n'
-        }
-
-        if (column['notNull']) {
-            const { __new } = column.notNull
-            const dropStatement = __new ? 'SET NOT NULL' : 'DROP NOT NULL'
-            statement += `ALTER TABLE ${tableName} ALTER COLUMN ${name} ${dropStatement};`
-            statement += '\n'
-        }
-
-        if (column['notNull__added']) {
-            statement += `ALTER TABLE ${tableName} ALTER COLUMN ${name} SET NOT NULL;`
-            statement += '\n'
-        }
-
-        if (column['notNull__deleted']) {
-            statement += `ALTER TABLE ${tableName} ALTER COLUMN ${name} DROP NOT NULL;`
-            statement += '\n'
-        }
-    }
-    return statement.trim()
-}
-
-export const prepareCreateTable = (table) => {
-    const { name, columns } = table
-    const mappedColumns = Object.keys(columns)
-        .map(it => {
-            return { ...columns[it] }
-        })
-
-    let statement = ''
-
-    statement += `CREATE TABLE ${name} (\n`
-    for (const column of mappedColumns) {
-        // console.log(column);
-        const primaryKeyStatement = column.primaryKey ? "PRIMARY KEY" : ''
-        const notNullStatement = column.notNull ? "NOT NULL" : "";
-        const defaultStatement = column.defaultValue ? `DEFAULT '${column.defaultValue}'` : "";
-        statement += '\t' + `${column.name} ${column.type} ${primaryKeyStatement} ${defaultStatement} ${notNullStatement}`.replace(/  +/g, ' ').trim() + ',\n'
-    }
-    statement += `);`
-    return statement;
-}
-
-export const prepareCreateIndex = (table, indexes) => {
-    let statement = ''
-    for (const index of indexes) {
-        const { name, columns } = index
-        statement += `CREATE INDEX ${name} ON ${table} (${columns.join(', ')});`
-        statement += '\n'
-    }
-
-    return statement.trim()
-}
-
-export const prepareDropIndex = (table, indexes) => {
-    let statement = ''
-    for (const index of indexes) {
-        const { name } = index
-        statement += `DROP INDEX IF EXISTS ${name};`
-        statement += '\n'
-    }
-    return statement.trim()
-}
-
-export const prepareRenameTable = (tableFrom, tableTo) => {
-    const namefrom = tableFrom.name
-    const nameTo = tableTo.name
-    const statement = `ALTER TABLE ${namefrom} RENAME TO ${nameTo}`
-    return statement
-}
-
-export const prepareDropTable = (table) => {
-    const { name } = table;
-    return `DROP TABLE ${name}`
-}
-
-export const prepareCreateEnum = (name, values) => {
-    // console.log(name, values)
-    let valuesStatement = '('
-    valuesStatement += Object.values(values).map(it => `'${it}'`).join(', ')
-    valuesStatement += ')'
-
-    const statement = `CREATE TYPE ${name} AS ENUM${valuesStatement};`
-    return statement;
-}
-
-// https://blog.yo1.dog/updating-enum-values-in-postgresql-the-safe-and-easy-way/
-export const prepareAddValuesToEnum = (name, values) => {
-    let statement = ''
-    for (const idx in values) {
-        statement += `ALTER TYPE ${name} ADD VALUE ${values[idx]};`
-        statement += '\n'
-    }
-    return statement.trim();
-}
-
-
-
-
-// test case for enum altering
-`
-create table users (
-	id int,
-    name character varying(128)
-);
-
-create type venum as enum('one', 'two', 'three');
-alter table users add column typed venum;
-
-insert into users(id, name, typed) values (1, 'name1', 'one');
-insert into users(id, name, typed) values (2, 'name2', 'two');
-insert into users(id, name, typed) values (3, 'name3', 'three');
-
-alter type venum rename to __venum;
-create type venum as enum ('one', 'two', 'three', 'four', 'five');
-
-ALTER TABLE users ALTER COLUMN typed TYPE venum USING typed::text::venum;
-
-insert into users(id, name, typed) values (4, 'name4', 'four');
-insert into users(id, name, typed) values (5, 'name5', 'five');
-
-drop type __venum;
-`

package/test-build.js

@@ -1,26 +0,0 @@
-const fs = require('fs')
-const decoder = new TextDecoder()
-const functionBody = decoder.decode(fs.readFileSync('./testFactory.js'))
-new Function(functionBody)(1,2,3)
-
-const result = require('esbuild').buildSync({
-    entryPoints: ['testFactory.ts'],
-    bundle: true,
-    platform: 'node',
-    write: false,
-    external: ['pg-native'],
-});
-
-const decoder = new TextDecoder()
-const ts = eval(decoder.decode(result.outputFiles[0].contents),)
-// console.log(ts)
-
-// fs.writeFileSync('__out.ts', ts, 'utf-8')
-// const result2 = require('esbuild').buildSync({
-//     entryPoints: ['__out.ts'],
-//     bundle: true,
-//     platform: 'node',
-//     write: false,
-//     external: ['pg-native'],
-// });
-// console.log(eval(decoder.decode(result2.outputFiles[0].contents)))

package/test.ts

@@ -1,57 +0,0 @@
-import { AbstractTable, DB } from "drizzle-orm";
-import Enum from "drizzle-orm/types/type";
-import { Pool } from "pg";
-import { isAccessor, isClassLike } from "typescript";
-import * as i1 from "./data/_prev/multi";
-// import * as t1 from "./data/_prev/types/types";
-import Serializer from "./serializer";
-
-const db = new DB(new Pool());
-const serializer = new Serializer();
-
-type Constructor<T = any> = new (...args: any[]) => T;
-// function isConstructor<T>(type: Constructor<T>): boolean {
-//   if (typeof type !== 'function') return false;
-//   return !!Reflect.get('__class__', type);
-// }
-
-const testFun = <T extends AbstractTable<any>>() => {
-  const tables: AbstractTable<any>[] = []
-  // const t1 = (new i1.default(db) as unknown as AbstractTable<any>);
-  // tables.push(t1)
-
-  console.log(i1)
-
-
-  const enums: Enum<any>[] = [];
-  Object.values(i1).forEach((t) => {
-    if (t instanceof Enum) {
-      enums.push(t);
-      return
-    }
-
-    if (typeof t === 'function' && t.prototype && t.prototype.constructor) {
-      const instance = new t(db)
-      if (instance instanceof AbstractTable) {
-        tables.push(instance as unknown as AbstractTable<any>)
-        console.log(instance.tableName())
-        console.log(Object.entries(instance))
-      }
-    }
-
-    // console.log(t, t instanceof Enum)
-    // console.log(t, t instanceof AbstractTable)
-    
-    // const instance = new t(db) as unknown as AbstractTable<any>
-    // console.log(instance.tableName)
-    // tables.push(t as unknown as AbstractTable<any>)
-    // }
-  });
-
-  console.log(enums)
-  console.log(tables)
-
-  return serializer.generate(tables, enums);
-};
-
-console.log(testFun());

package/testFactory.js

@@ -1,3 +0,0 @@
-console.log('eval')
-
-console.log(arguments)

package/testFactory.ts

@@ -1,26 +0,0 @@
-import { AbstractTable, DB } from "drizzle-orm";
-import Enum from "drizzle-orm/types/type";
-import { Pool } from "pg";
-import * as i1 from "./data/v1/tables/authOtpTable";
-import * as i2 from "./data/v1/tables/deletedTable";
-import * as i3 from "./data/v1/tables/usersTable";
-import * as t1 from "./data/v1/types/types";
-import Serializer from "./serializer";
-
-const db = new DB(new Pool());
-const serializer = new Serializer();
-
-const testFun = () => {
-  const tables: AbstractTable<any>[] = []
-  const t1 = (new i1.default(db) as unknown as AbstractTable<any>);
-  tables.push(t1)
-
-  const enums: Enum<any>[] = [];
-  Object.values(t1).forEach((t) => {
-    enums.push(t as Enum<any>);
-  });
-
-  return serializer.generate(tables, enums);
-};
-
-testFun();

package/tsconfig.json

@@ -1,28 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es2020",
-    "lib": ["es2020"],
-    "allowJs": true,
-    "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,53 +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: {
-    drizzle: './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',
-        },
-        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/,
-  },
-};