drizzle-kit 0.9.1 → 0.9.5

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;