drizzle-kit 0.9.41 → 0.9.44

package/src/serializer/factory.ts

@@ -1,415 +0,0 @@
-import ts from "typescript";
-import fs from "fs";
-const printer: ts.Printer = ts.createPrinter();
-
-const prepareFabricFile = (folder: string, fileName?: string) => {
-  const staticImports = [
-    ts.createImportDeclaration(
-      undefined,
-      undefined,
-      ts.createImportClause(
-        undefined,
-        ts.createNamespaceImport(ts.createIdentifier('drizzle'))
-      ),
-      ts.createStringLiteral('drizzle-orm')
-    ),
-    ts.createImportDeclaration(
-      undefined,
-      undefined,
-      ts.createImportClause(
-        ts.createIdentifier('Session'),
-        undefined
-      ),
-      ts.createStringLiteral('drizzle-orm/db/session')
-    ),
-    ts.createImportDeclaration(
-      undefined,
-      undefined,
-      ts.createImportClause(
-        ts.createIdentifier('MigrationSerializer'),
-        undefined
-      ),
-      ts.createStringLiteral('drizzle-orm/serializer/serializer')
-    ),
-    ts.createImportDeclaration(
-      undefined,
-      undefined,
-      ts.createImportClause(ts.createIdentifier("Enum"), undefined),
-      ts.createStringLiteral("drizzle-orm/types/type"),
-    ),
-    ts.createImportDeclaration(
-      undefined,
-      undefined,
-      ts.createImportClause(
-        undefined,
-        ts.createNamespaceImport(ts.createIdentifier('pg'))
-      ),
-      ts.createStringLiteral('pg')
-    ),
-  ];
-
-  const dynamicImports = [];
-  const filenames = fileName ? [fileName!!] : fs.readdirSync(folder);
-  for (let i = 0; i < filenames.length; i++) {
-    const filename = filenames[i];
-
-    const importPath = `${folder}/${filename.split(".")[0]}`;
-    dynamicImports.push(ts.createImportDeclaration(
-      undefined,
-      undefined,
-      ts.createImportClause(
-        undefined,
-        ts.createNamespaceImport(ts.createIdentifier(`i${i}`)),
-      ),
-      ts.createStringLiteral(importPath),
-    ));
-  }
-
-  const variablesStatements = [
-    ts.createVariableStatement(
-      undefined,
-      ts.createVariableDeclarationList(
-        [
-          ts.createVariableDeclaration(
-            ts.createIdentifier("db"),
-            undefined,
-            ts.createNew(ts.createIdentifier("drizzle.DB"), undefined, [
-              ts.createNew(ts.createIdentifier("Session"), undefined, [ts.createNew(ts.createPropertyAccess(
-                ts.createIdentifier('pg'),
-                ts.createIdentifier('Pool')
-              ), undefined, [])]),
-            ]),
-          ),
-        ],
-        ts.NodeFlags.Const,
-      ),
-    ),
-    ts.createVariableStatement(
-      undefined,
-      ts.createVariableDeclarationList(
-        [
-          ts.createVariableDeclaration(
-            ts.createIdentifier("serializer"),
-            undefined,
-            ts.createNew(ts.createIdentifier("MigrationSerializer"), undefined, []),
-          ),
-        ],
-        ts.NodeFlags.Const,
-      ),
-    ),
-  ];
-
-  const blockStatements = [];
-
-  // const tables: AbstractTable<any> = []
-  blockStatements.push(ts.createVariableStatement(
-    undefined,
-    ts.createVariableDeclarationList(
-      [
-        ts.createVariableDeclaration(
-          ts.createIdentifier('tables'),
-          ts.createArrayTypeNode(
-            ts.createTypeReferenceNode(
-              ts.createQualifiedName(
-                ts.createIdentifier('drizzle'),
-                ts.createIdentifier('AbstractTable')
-              ),
-              [ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)]
-            )
-          ),
-          ts.createArrayLiteral([], false)
-        ),
-      ],
-      ts.NodeFlags.Const,
-    ),
-  ));
-
-  // const enums: Enum<any>[] = []
-  blockStatements.push(ts.createVariableStatement(
-    undefined,
-    ts.createVariableDeclarationList(
-      [
-        ts.createVariableDeclaration(
-          ts.createIdentifier('enums'),
-          ts.createArrayTypeNode(
-            ts.createTypeReferenceNode(
-              ts.createIdentifier('Enum'),
-              [ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)]
-            )
-          ),
-          ts.createArrayLiteral([], false)
-        )
-      ],
-      ts.NodeFlags.Const
-    ),
-  ));
-
-  for (let i = 0; i < filenames.length; i++) {
-    // const t1 = (new i1.default(db) as unknown as AbstractTable<any>);
-    // tables.push(t1)
-
-    // const i1values = Object.values(i1)
-    const valuesDeclaration = ts.createVariableStatement(
-      undefined,
-      ts.createVariableDeclarationList(
-        [
-          ts.createVariableDeclaration(
-            ts.createIdentifier(`i${i}values`),
-            undefined,
-            ts.createCall(
-              ts.createPropertyAccess(
-                ts.createIdentifier('Object'),
-                ts.createIdentifier('values')
-              ),
-              undefined,
-              [ts.createIdentifier('i' + i)]
-            )
-          )
-        ],
-        ts.NodeFlags.Const
-      )
-    )
-    blockStatements.push(valuesDeclaration)
-
-    //  i1values.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>)
-    //     }
-    //   }
-    // });
-    const iterationWithTypeChecks = ts.createExpressionStatement(
-      ts.createCall(
-        ts.createPropertyAccess(
-          ts.createIdentifier(`i${i}values`),
-          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.createIf(
-                  ts.createBinary(
-                    ts.createIdentifier('t'),
-                    ts.SyntaxKind.InstanceOfKeyword,
-                    ts.createIdentifier('Enum')
-                  ),
-                  ts.createBlock(
-                    [
-                      ts.createExpressionStatement(
-                        ts.createCall(
-                          ts.createPropertyAccess(
-                            ts.createIdentifier('enums'),
-                            ts.createIdentifier('push')
-                          ),
-                          undefined,
-                          [ts.createIdentifier('t')]
-                        )
-                      ),
-                      ts.createReturn(undefined)
-                    ],
-                    true
-                  ),
-                  undefined
-                ),
-                ts.createIf(
-                  ts.createBinary(
-                    ts.createBinary(
-                      ts.createBinary(
-                        ts.createTypeOf(ts.createIdentifier('t')),
-                        ts.createToken(
-                          ts.SyntaxKind.EqualsEqualsEqualsToken
-                        ),
-                        ts.createStringLiteral('function')
-                      ),
-                      ts.createToken(
-                        ts.SyntaxKind.AmpersandAmpersandToken
-                      ),
-                      ts.createPropertyAccess(
-                        ts.createIdentifier('t'),
-                        ts.createIdentifier('prototype')
-                      )
-                    ),
-                    ts.createToken(
-                      ts.SyntaxKind.AmpersandAmpersandToken
-                    ),
-                    ts.createPropertyAccess(
-                      ts.createPropertyAccess(
-                        ts.createIdentifier('t'),
-                        ts.createIdentifier('prototype')
-                      ),
-                      ts.createIdentifier('constructor')
-                    )
-                  ),
-                  ts.createBlock(
-                    [
-                      ts.createVariableStatement(
-                        undefined,
-                        ts.createVariableDeclarationList(
-                          [
-                            ts.createVariableDeclaration(
-                              ts.createIdentifier('instance'),
-                              undefined,
-                              ts.createNew(
-                                ts.createIdentifier('t'),
-                                undefined,
-                                [ts.createIdentifier('db')]
-                              )
-                            )
-                          ],
-                          ts.NodeFlags.Const
-                        )
-                      ),
-                      ts.createIf(
-                        ts.createBinary(
-                          ts.createIdentifier('instance'),
-                          ts.SyntaxKind.InstanceOfKeyword,
-                          ts.createIdentifier('drizzle.AbstractTable')
-                        ),
-                        ts.createBlock(
-                          [
-                            ts.createExpressionStatement(
-                              ts.createCall(
-                                ts.createPropertyAccess(
-                                  ts.createIdentifier('tables'),
-                                  ts.createIdentifier('push')
-                                ),
-                                undefined,
-                                [
-                                  ts.createAsExpression(
-                                    ts.createAsExpression(
-                                      ts.createIdentifier(
-                                        'instance'
-                                      ),
-                                      ts.createKeywordTypeNode(
-                                        ts.SyntaxKind.UnknownKeyword
-                                      )
-                                    ),
-                                    ts.createTypeReferenceNode(
-                                      ts.createQualifiedName(
-                                        ts.createIdentifier('drizzle'),
-                                        ts.createIdentifier('AbstractTable')
-                                      ),
-                                      [
-                                        ts.createKeywordTypeNode(
-                                          ts.SyntaxKind.AnyKeyword
-                                        )
-                                      ]
-                                    )
-                                  )
-                                ]
-                              )
-                            )
-                          ],
-                          true
-                        ),
-                        undefined
-                      )
-                    ],
-                    true
-                  ),
-                  undefined
-                )
-              ],
-              true
-            )
-          )
-        ]
-      )
-    )
-    blockStatements.push(iterationWithTypeChecks)
-  }
-
-  // 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/serializer/index.ts

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

package/src/simulator.ts

@@ -1,155 +0,0 @@
-declare global {
-    interface Array<T> {
-        exactlyOne(): T;
-    }
-}
-
-Array.prototype.exactlyOne = function () {
-    if (this.length !== 1) {
-        return undefined
-    }
-    return this[0]
-}
-
-interface TablesHandler<T extends Named> {
-    can(added: T[], removed: T[]): boolean
-    handle(added: T[], removed: T[]): { created: T[], deleted: T[], renamed: { from: T, to: T }[] }
-}
-
-interface ColumnsHandler<T extends Named> {
-    can(tableName: string, added: T[], removed: T[]): boolean
-    handle(tableName: string, added: T[], removed: T[]): { tableName: string, created: T[], deleted: T[], renamed: { from: T, to: T }[] }
-}
-
-class DryRun<T extends Named> implements TablesHandler<T> {
-    can(added: T[], removed: T[]): boolean {
-        return added.length === 0 && removed.length === 0
-    }
-    handle(added: T[], _: T[]): { created: T[]; deleted: T[]; renamed: { from: T; to: T; }[]; } {
-        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<T extends Named> implements TablesHandler<T> {
-    can(_: T[], removed: T[]): boolean {
-        return removed.length === 1 && removed[0].name === 'citiess'
-    }
-
-    handle(added: T[], removed: T[]): { created: T[]; deleted: T[]; renamed: { from: T; to: T; }[]; } {
-        return { created: added, deleted: removed, renamed: [] }
-    }
-}
-class Case2<T extends Named> implements TablesHandler<T> {
-    // authOtp, deleted, users -> authOtp renamed, cities added, deleted deleted
-    can(_: T[], removed: T[]): boolean {
-        return removed.length === 3 && removed[0].name === 'auth_otp'
-    }
-
-    handle(added: T[], removed: T[]): { created: T[]; deleted: T[]; renamed: { from: T; to: T; }[]; } {
-        return { created: added.slice(1), deleted: removed.slice(1), renamed: [{ from: removed[0], to: added[0] }] }
-    }
-}
-
-type Named = { name: string }
-
-const handlers: TablesHandler<any>[] = []
-handlers.push(new Case1())
-handlers.push(new Case2())
-handlers.push(new DryRun())
-
-export const resolveTables = <T extends Named>(added: T[], removed: T[]) => {
-    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)
-}
-class LehaColumnsHandler<T extends Named> implements ColumnsHandler<T> {
-    can(tableName: string, _: T[], __: T[]): boolean {
-        return tableName === 'users'
-    }
-
-    handle(
-        tableName: string,
-        added: T[],
-        removed: T[]
-    ): { tableName: string; created: T[]; deleted: T[]; renamed: { from: T; to: T }[] } {
-        return { tableName, created: [], deleted: [], renamed: [{from: removed[0], to: added[0]}] }
-    }
-}
-
-class DryRunColumnsHandler<T extends Named> implements ColumnsHandler<T> {
-    can(tableName: string, _: T[], __: T[]): boolean {
-        return true
-    }
-
-    handle(
-        tableName: string,
-        added: T[],
-        removed: T[]
-    ): { tableName: string; created: T[]; deleted: T[]; renamed: { from: T; to: T }[] } {
-        return { tableName, created: added, deleted: removed, renamed: [] }
-    }
-}
-
-
-class V1V2AuthOtpColumnsHandler<T extends Named> implements ColumnsHandler<T> {
-    can(tableName: string, _: T[], __: T[]): boolean {
-        return tableName === 'auth_otp'
-    }
-
-    handle(
-        tableName: string,
-        added: T[],
-        removed: T[]
-    ): { tableName: string; created: T[]; deleted: T[]; renamed: { from: T; to: T }[] } {
-        const phonePrev = removed.filter((it) => it.name === 'phone')[0];
-        const phoneNew = added.filter((it) => it.name === 'phone1')[0];
-
-        const newAdded = added.filter((it => it.name !== 'phone1'))
-        const newRemoved = removed.filter((it => it.name !== 'phone'))
-
-        return { tableName, created: newAdded, deleted: newRemoved, renamed: [{ from: phonePrev, to: phoneNew }] }
-    }
-
-    // handle(tableName:string, added: T[], _: T[]): { created: T[]; deleted: T[]; renamed: { from: T; to: T; }[]; } {
-    //     return { created: added, deleted: [], renamed: [] }
-    // }
-}
-
-const columnsHandlers: ColumnsHandler<any>[] = []
-columnsHandlers.push(new V1V2AuthOtpColumnsHandler())
-columnsHandlers.push(new LehaColumnsHandler())
-columnsHandlers.push(new DryRunColumnsHandler())
-
-export const resolveColumns = <T extends Named>(tableName: string, added: T[], removed: T[]) => {
-    const handler = columnsHandlers.filter(it => {
-        return it.can(tableName, added, removed)
-    })[0]
-
-    if (!handler) {
-        console.log('added', added.map(it => it.name).join())
-        console.log('removed', removed.map(it => it.name).join())
-        throw new Error("No columns handler for table: " + tableName);
-    }
-
-    console.log(`${tableName} columns simluated by ${handler.constructor.name}`)
-    return handler.handle(tableName, added, removed)
-}
-