drizzle-kit 0.9.38 → 0.9.41

package/src/serializer/factory.ts

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

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

@@ -0,0 +1,155 @@
+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)
+}
+