drizzle-kit 0.9.2 → 0.9.6

package/src/jsonStatements.js

@@ -1,176 +0,0 @@
-export class Types {
-    static createTable = 'create_table'
-    static dropTable = 'drop_table'
-    static renameTable = 'rename_table'
-    static alterTableDropColumn = 'alter_table_drop_column'
-    static alterTableAddColumn = 'alter_table_add_column'
-    static alterTableAlterColumnSetType = 'alter_table_alter_column_set_type'
-    static alterTableAlterColumnSetDefault = 'alter_table_alter_column_set_default'
-    static alterTableAlterColumnDropDefault = 'alter_table_alter_column_drop_default'
-    static alterTableAlterColumnSetNotNull = 'alter_table_alter_column_set_notnull'
-    static alterTableAlterColumnDropNotNull = 'alter_table_alter_column_drop_notnull'
-    static createIndex = 'create_index'
-    static dropIndex = 'drop_index'
-    static createTypeEnum = 'create_type_enum'
-    static alterTypeAddValue = 'alter_type_add_value'
-}
-
-export const prepareCreateTableJson = (table) => {
-    const { name, columns } = table
-    const mappedColumns = Object.keys(columns)
-        .map(it => {
-            return { ...columns[it] }
-        })
-
-    return {
-        type: Types.createTable,
-        tableName: name,
-        columns: mappedColumns
-    };
-}
-
-export const prepareDropTableJson = (table) => {
-    return {
-        type: Types.dropTable,
-        tableName: table.name
-    }
-}
-
-export const prepareRenameTableJson = (tableFrom, tableTo) => {
-    return {
-        type: Types.renameTable,
-        from: tableFrom.name,
-        to: tableTo.name
-    }
-}
-
-export const prepareCreateEnumJson = (name, values) => {
-    return {
-        type: Types.createTypeEnum,
-        enumName: name,
-        values
-    }
-}
-
-// https://blog.yo1.dog/updating-enum-values-in-postgresql-the-safe-and-easy-way/
-export const prepareAddValuesToEnumJson = (name, values) => {
-    return values.map(it => {
-        return {
-            type: Types.alterTypeAddValue,
-            enumName: name,
-            enumValue: it
-        }
-    })
-}
-
-export const prepareAlterTableColumnsJson = (table) => {
-    const tableName = table['name'];
-    const statements = []
-
-    const dropColumns = _prepareDropColumns(tableName, table.deleted)
-    const addColumns = _prepareAddColumns(tableName, table.added)
-    const alterColumns = _prepareAlterColumns(tableName, table.altered)
-
-
-    statements.push(...dropColumns)
-    statements.push(...addColumns)
-    statements.push(...alterColumns)
-
-    return statements;
-}
-
-const _prepareDropColumns = (taleName, columns) => {
-    return columns.map(it => {
-        return {
-            type: Types.alterTableDropColumn,
-            tableName: taleName,
-            columnName: it.name
-        }
-    })
-}
-
-const _prepareAddColumns = (tableName, columns) => {
-    
-    return columns.map(it => {
-        return {
-            type: Types.alterTableAddColumn,
-            tableName,
-            column: it
-        }
-    })
-}
-
-const _prepareAlterColumns = (tableName, columns) => {
-    let statements = []
-
-    for (const column of columns) {
-        const columnName = column.name;
-
-        if (column['type']) {
-            const { __new } = column.type
-
-            statements.push({
-                type: Types.alterTableAlterColumnSetType,
-                tableName,
-                columnName,
-                newDataType: __new
-            })
-        }
-
-        if (column['defaultValue'] || column['defaultValue__added']) {
-            const newDefaultValue = column.defaultValue.__new | column.defaultValue__added
-            statements.push({
-                type: Types.alterTableAlterColumnSetDefault,
-                tableName,
-                columnName,
-                newDefault: newDefaultValue
-            })
-        }
-
-        if (column['defaultValue__deleted']) {
-            statements.push({
-                type: Types.alterTableAlterColumnDropDefault,
-                tableName,
-                columnName,
-            })
-        }
-
-        if (column['notNull__added'] || (column['notNull'] && column['notNull']['__new'])) {
-            statements.push({
-                type: Types.alterTableAlterColumnSetNotNull,
-                tableName,
-                columnName
-            })
-        }
-
-        if (column['notNull__deleted'] || (column['notNull'] && !column['notNull']['__new'])) {
-            statements.push({
-                type: Types.alterTableAlterColumnDropNotNull,
-                tableName,
-                columnName
-            })
-        }
-    }
-
-    return statements
-}
-
-export const prepareCreateIndexesJson = (tableName, indexes) => {
-    return indexes.map(index => {
-        return {
-            type: Types.createIndex,
-            tableName,
-            indexName: index.name,
-            indexValue: index.columns.join(', ')
-        }
-    })
-}
-export const prepareDropIndexesJson = (tableName, indexes) => {
-    return indexes.map(index => {
-        return {
-            type: Types.dropIndex,
-            tableName,
-            indexName: index.name,
-        }
-    })
-}

package/src/migrationPreparator.ts

@@ -1,47 +0,0 @@
-import fs from 'fs'
-import serialize from 'serilizer'
-
-// TODO: export as a function w
-
-const dry = {
-    version: "1",
-    tables: {},
-    enums: {}
-}
-
-const prepareMigration = (
-    migrationRootFolderName: string = 'drizzle',
-    dataFolderPath: string
-): { prev: any, cur: any } => {
-    const root = migrationRootFolderName
-    const files = fs.readdirSync('./')
-    const drizzleFolder = files.find((it) => {
-        return it === root
-    })
-
-    if (!drizzleFolder) {
-        fs.mkdirSync(root)
-    }
-
-    const migrationFolders = fs.readdirSync(`./${root}`)
-
-    let prevSnapshot;
-
-    if (migrationFolders.length === 0) {
-        prevSnapshot = dry
-    } else {
-        migrationFolders.sort()
-        const lastSnapshotFolder = migrationFolders[migrationFolders.length - 1]
-        console.log(lastSnapshotFolder)
-        prevSnapshot = JSON.parse(fs.readFileSync(`./${root}/${lastSnapshotFolder}/snapshot.json`).toString())
-    }
-
-    const tbls = `${dataFolderPath}/tables/`
-    const tps = `${dataFolderPath}/types/`
-
-    const result = serialize(tbls, tps)
-
-    return { prev: prevSnapshot, cur: result }
-}
-
-export default prepareMigration;

package/src/serilizer/factory.ts

@@ -1,340 +0,0 @@
-import ts from "typescript";
-import fs from "fs";
-const printer: ts.Printer = ts.createPrinter();
-
-const prepareFabricFile = (tablesFolder: string, typesFolder: string) => {
-  const staticImports = [
-    ts.createImportDeclaration(
-      undefined,
-      undefined,
-      ts.createImportClause(
-        undefined,
-        ts.createNamedImports([
-          ts.createImportSpecifier(
-            undefined,
-            ts.createIdentifier("AbstractTable"),
-          ),
-          ts.createImportSpecifier(undefined, ts.createIdentifier("DB")),
-        ]),
-      ),
-      ts.createStringLiteral("drizzle-orm"),
-    ),
-    ts.createImportDeclaration(
-      undefined,
-      undefined,
-      ts.createImportClause(ts.createIdentifier("Enum"), undefined),
-      ts.createStringLiteral("drizzle-orm/types/type"),
-    ),
-    ts.createImportDeclaration(
-      undefined,
-      undefined,
-      ts.createImportClause(
-        undefined,
-        ts.createNamedImports([
-          ts.createImportSpecifier(undefined, ts.createIdentifier("Pool")),
-        ]),
-      ),
-      ts.createStringLiteral("pg"),
-    ),
-    ts.createImportDeclaration(
-      undefined,
-      undefined,
-      ts.createImportClause(ts.createIdentifier("Serializer"), undefined),
-      ts.createStringLiteral("./serializer"),
-    ),
-  ];
-
-  const dynamicImports = [];
-  const tablesFilenames = fs.readdirSync(tablesFolder);
-  for (let i = 0; i < tablesFilenames.length; i++) {
-    const filename = tablesFilenames[i];
-    const importPath = `${tablesFolder}${filename.split(".")[0]}`;
-    dynamicImports.push(ts.createImportDeclaration(
-      undefined,
-      undefined,
-      ts.createImportClause(
-        undefined,
-        ts.createNamespaceImport(ts.createIdentifier(`i${i}`)),
-      ),
-      ts.createStringLiteral(importPath),
-    ));
-  }
-  const typesFilenames = fs.readdirSync(typesFolder);
-  for (let i = 0; i < typesFilenames.length; i++) {
-    const filename = typesFilenames[i];
-    const importPath = `${typesFolder}${filename.split(".")[0]}`;
-    dynamicImports.push(ts.createImportDeclaration(
-      undefined,
-      undefined,
-      ts.createImportClause(
-        undefined,
-        ts.createNamespaceImport(ts.createIdentifier(`t${i}`)),
-      ),
-      ts.createStringLiteral(importPath),
-    ));
-  }
-
-  const variablesStatements = [
-    ts.createVariableStatement(
-      undefined,
-      ts.createVariableDeclarationList(
-        [
-          ts.createVariableDeclaration(
-            ts.createIdentifier("db"),
-            undefined,
-            ts.createNew(ts.createIdentifier("DB"), undefined, [
-              ts.createNew(ts.createIdentifier("Pool"), undefined, []),
-            ]),
-          ),
-        ],
-        ts.NodeFlags.Const,
-      ),
-    ),
-    ts.createVariableStatement(
-      undefined,
-      ts.createVariableDeclarationList(
-        [
-          ts.createVariableDeclaration(
-            ts.createIdentifier("serializer"),
-            undefined,
-            ts.createNew(ts.createIdentifier("Serializer"), undefined, []),
-          ),
-        ],
-        ts.NodeFlags.Const,
-      ),
-    ),
-  ];
-
-  const blockStatements = [];
-
-  // const tables = []
-  blockStatements.push(ts.createVariableStatement(
-    undefined,
-    ts.createVariableDeclarationList(
-      [
-        ts.createVariableDeclaration(
-          ts.createIdentifier("tables"),
-          undefined,
-          ts.createArrayLiteral([], false),
-        ),
-      ],
-      ts.NodeFlags.Const,
-    ),
-  ));
-
-  for (let i = 0; i < tablesFilenames.length; i++) {
-    // const t1 = (new i1.default(db) as unknown as AbstractTable<any>);
-    // tables.push(t1)
-    const blockStatement = [
-      ts.createVariableStatement(
-        undefined,
-        ts.createVariableDeclarationList(
-          [
-            ts.createVariableDeclaration(
-              ts.createIdentifier("table" + i),
-              undefined,
-              ts.createParen(
-                ts.createAsExpression(
-                  ts.createAsExpression(
-                    ts.createNew(
-                      ts.createPropertyAccess(
-                        ts.createIdentifier("i" + i),
-                        ts.createIdentifier("default"),
-                      ),
-                      undefined,
-                      [ts.createIdentifier("db")],
-                    ),
-                    ts.createKeywordTypeNode(
-                      ts.SyntaxKind.UnknownKeyword,
-                    ),
-                  ),
-                  ts.createTypeReferenceNode(
-                    ts.createIdentifier("AbstractTable"),
-                    [
-                      ts.createKeywordTypeNode(
-                        ts.SyntaxKind.AnyKeyword,
-                      ),
-                    ],
-                  ),
-                ),
-              ),
-            ),
-          ],
-          ts.NodeFlags.Const,
-        ),
-      ),
-      ts.createExpressionStatement(
-        ts.createCall(
-          ts.createPropertyAccess(
-            ts.createIdentifier("tables"),
-            ts.createIdentifier("push"),
-          ),
-          undefined,
-          [ts.createIdentifier("table" + i)],
-        ),
-      ),
-    ];
-
-    blockStatements.push(...blockStatement);
-  }
-
-  // const enums = []
-  blockStatements.push(ts.createVariableStatement(
-    undefined,
-    ts.createVariableDeclarationList(
-      [
-        ts.createVariableDeclaration(
-          ts.createIdentifier("enums"),
-          undefined,
-          ts.createArrayLiteral([], false),
-        ),
-      ],
-      ts.NodeFlags.Const,
-    ),
-  ));
-
-  // Object.values(t0).forEach((t) => {
-  //  enums.push(t as Enum<any>);
-  // });
-  if (typesFilenames.length > 0) {
-    blockStatements.push(
-      ts.createExpressionStatement(
-        ts.createCall(
-          ts.createPropertyAccess(
-            ts.createCall(
-              ts.createPropertyAccess(
-                ts.createIdentifier("Object"),
-                ts.createIdentifier("values"),
-              ),
-              undefined,
-              [ts.createIdentifier("t0")],
-            ),
-            ts.createIdentifier("forEach"),
-          ),
-          undefined,
-          [
-            ts.createArrowFunction(
-              undefined,
-              undefined,
-              [
-                ts.createParameter(
-                  undefined,
-                  undefined,
-                  undefined,
-                  ts.createIdentifier("t"),
-                  undefined,
-                  undefined,
-                  undefined,
-                ),
-              ],
-              undefined,
-              ts.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
-              ts.createBlock(
-                [
-                  ts.createExpressionStatement(
-                    ts.createCall(
-                      ts.createPropertyAccess(
-                        ts.createIdentifier("enums"),
-                        ts.createIdentifier("push"),
-                      ),
-                      undefined,
-                      [
-                        ts.createAsExpression(
-                          ts.createAsExpression(
-                            ts.createIdentifier("t"),
-                            ts.createKeywordTypeNode(
-                              ts.SyntaxKind.UnknownKeyword,
-                            ),
-                          ),
-                          ts.createTypeReferenceNode(
-                            ts.createIdentifier("Enum"),
-                            [
-                              ts.createKeywordTypeNode(
-                                ts.SyntaxKind.AnyKeyword,
-                              ),
-                            ],
-                          ),
-                        ),
-                      ],
-                    ),
-                  ),
-                ],
-                true,
-              ),
-            ),
-          ],
-        ),
-      ),
-    );
-  }
-
-  // return serializer.generate(tables, enums)
-  blockStatements.push(
-    ts.createReturn(
-      ts.createCall(
-        ts.createPropertyAccess(
-          ts.createIdentifier("serializer"),
-          ts.createIdentifier("generate"),
-        ),
-        undefined,
-        [
-          ts.createIdentifier("tables"),
-          ts.createIdentifier("enums"),
-        ],
-      ),
-    ),
-  );
-
-  const funcStatement = [
-    ts.createVariableStatement(
-      undefined,
-      ts.createVariableDeclarationList(
-        [
-          ts.createVariableDeclaration(
-            ts.createIdentifier("testFun"),
-            undefined,
-            ts.createArrowFunction(
-              undefined,
-              undefined,
-              [],
-              undefined,
-              ts.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
-              // function body
-              ts.createBlock(
-                blockStatements,
-                true,
-              ),
-            ),
-          ),
-        ],
-        ts.NodeFlags.Const,
-      ),
-    ),
-  ];
-  const invocationStatement = [
-    ts.createExpressionStatement(
-      ts.createCall(ts.createIdentifier("testFun"), undefined, []),
-    ),
-  ];
-
-  const outFile: ts.SourceFile = ts.createSourceFile(
-    "outfile.ts",
-    "",
-    ts.ScriptTarget.ES2015,
-    true,
-    ts.ScriptKind.TS,
-  );
-
-  const source = [];
-  source.push(...staticImports);
-  source.push(...dynamicImports);
-  source.push(...variablesStatements);
-  source.push(...funcStatement);
-  source.push(...invocationStatement);
-
-  const newFile = ts.factory.updateSourceFile(outFile, source);
-
-  return printer.printFile(newFile);
-};
-
-export default prepareFabricFile;

package/src/serilizer/index.ts

@@ -1,25 +0,0 @@
-import fs from "fs";
-import { StringDecoder } from "string_decoder";
-import prepareFabricFile from "./factory";
-const esbuild = require("esbuild");
-
-const serialize = (pathToTables: string, pathToTypes: string): string => {
-  const decoder = new StringDecoder();
-  // const preparedFarbic = prepareFabricFile("./examples/tables/", './examples/types/')
-  const preparedFarbic = prepareFabricFile(pathToTables, pathToTypes)
-  const ts = preparedFarbic;
-
-  fs.writeFileSync("__out.ts", ts, "utf-8");
-  const result = esbuild.buildSync({
-    entryPoints: ["__out.ts"],
-    bundle: true,
-    platform: "node",
-    write: false,
-    external: ["pg-native"],
-  });
-
-  fs.rmSync("__out.ts");
-  return eval(decoder.write(result.outputFiles[0].contents));
-};
-
-export default serialize;

package/src/simulator.ts

@@ -1,85 +0,0 @@
-declare global {
-    interface Array<T> {
-        exactlyOne(): T;
-    }
-}
-
-Array.prototype.exactlyOne = function () {
-    if (this.length !== 1) {
-        return undefined
-    }
-    return this[0]
-}
-
-interface Table {
-    name: string,
-    indexes?: any
-}
-
-interface Handler {
-    can(added: Table[], removed: Table[]): boolean
-    handle(added: Table[], removed: Table[]): { created: Table[], deleted: Table[], renamed: { from: Table, to: Table }[] }
-}
-
-class DryRun implements Handler {
-    can(_: Table[], removed: Table[]): boolean {
-        return removed.length === 0
-    }
-    handle(added: Table[], _: Table[]): { created: Table[]; deleted: Table[]; renamed: { from: Table; to: Table; }[]; } {
-        return { created: added, deleted: [], renamed: [] }
-    }
-
-}
-
-// class Fallback implements Handler {
-//     can(_: Table[], __: Table[]): boolean {
-//         return true
-//     }
-//     handle(added: Table[], _: Table[]): { created: Table[]; deleted: Table[]; renamed: { from: Table; to: Table; }[]; } {
-//         return { created: added, deleted: , renamed: [] }
-//     }
-// }
-
-class Case1 implements Handler {
-    can(_: Table[], removed: Table[]): boolean {
-        return removed.length === 1 && removed[0].name === 'citiess'
-    }
-
-    handle(added: Table[], removed: Table[]): { created: Table[]; deleted: Table[]; renamed: { from: Table; to: Table; }[]; } {
-        return { created: added, deleted: [], renamed: [{ from: removed[0], to: added[0] }] }
-    }
-}
-
-class Case2 implements Handler {
-    // authOtp, deleted, users -> authOtp renamed, cities added, deleted deleted
-    can(_: Table[], removed: Table[]): boolean {
-        return removed.length === 2 && removed[0].name === 'auth_otp'
-    }
-
-    handle(added: Table[], removed: Table[]): { created: Table[]; deleted: Table[]; renamed: { from: Table; to: Table; }[]; } {
-        return { created: added.slice(1), deleted: removed.slice(1), renamed: [{ from: removed[0], to: added[0] }] }
-    }
-}
-
-const handlers: Handler[] = []
-handlers.push(new Case1())
-handlers.push(new Case2())
-handlers.push(new DryRun())
-
-
-const resolveTables = (added: Table[], removed: Table[]) => {
-    const handler = handlers.filter(it => {
-        return it.can(added, removed)
-    }).exactlyOne()
-
-    if (!handler) {
-        console.log('added', added.map(it => it.name).join())
-        console.log('removed', removed.map(it => it.name).join())
-        throw new Error("No handler");
-    }
-
-    console.log(`Simluated by ${handler.constructor.name}`)
-    return handler.handle(added, removed)
-}
-
-export default resolveTables;