drizzle-kit 0.9.0 → 0.9.1

package/.eslintrc

@@ -14,6 +14,8 @@
     "react/require-default-props": ["off"],
     "react/jsx-props-no-spreading": ["off"],
     "no-underscore-dangle": ["off"],
-    "react/no-array-index-key": ["off"]
+    "react/no-array-index-key": ["off"],
+    "no-param-reassign": ["off"],
+    "no-nested-ternary": ["off"]
   }
 }

package/config.yml

@@ -0,0 +1,4 @@
+driver: postgres
+paths:
+  tables: ./examples/tables/
+  enums: ./examples/types/

package/data/_prev/multi.ts

@@ -0,0 +1,43 @@
+import { AbstractTable } from 'drizzle-orm';
+import { createEnum } from 'drizzle-orm/types/type';
+
+export class CitiesTable2 extends AbstractTable<CitiesTable2> {
+    public name = this.timestamp('name', { notNull: true }).defaultValue(new Date());
+    public page = this.varchar('page', { size: 256 });
+    public roleEnum = this.type(rolesEnumMulti, 'role')
+
+    public userId1 = this.int('user_id').foreignKey(UsersTable2, (table) => table.id);
+
+    public data = this.jsonb<string[]>('data');
+
+    public tableName(): string {
+        return 'citiess';
+    }
+}
+
+export class UsersTable2 extends AbstractTable<UsersTable2> {
+    public id = this.int('id').autoIncrement().primaryKey();
+    public phone = this.varchar('phone', { size: 256 }).unique();
+    public fullName = this.varchar('full_name', { size: 512 });
+    public test = this.decimal('test', { notNull: true, precision: 100, scale: 2 });
+    public test1 = this.bigint('test1', { notNull: true });
+    public createdAt = this.timestamp('created_at', { notNull: true });
+    public updatedAt = this.timestamp('updated_at', { notNull: true });
+
+    public phoneFullNameIndex = this.index([this.phone, this.fullName]);
+    public phoneIndex = this.index(this.phone);
+
+    public tableName(): string {
+        return 'users';
+    }
+}
+
+export const rolesEnumMulti = createEnum({
+    alias: "roles_enum",
+    values: ["role1", "role2", "role3"],
+});
+
+export const rolesEnumMulti2 = createEnum({
+    alias: "roles2_enum",
+    values: ["role1.1", "role2.2", "role3.3"],
+});

package/{examples → data/_prev}/tables/authOtpTable.ts

@@ -1,6 +1,6 @@
-import { AbstractTable } from '@lambda-team/ltdl';
-import TestEnum from '@lambda-team/ltdl/examples/testEnum';
+import { AbstractTable } from 'drizzle-orm';
 import UsersTable from './usersTable';
+import { rolesEnum } from '../types/types';
 
 export default class AuthOtpTable extends AbstractTable<AuthOtpTable> {
   public id = this.int('id').autoIncrement().primaryKey();
@@ -10,7 +10,7 @@ export default class AuthOtpTable extends AbstractTable<AuthOtpTable> {
   public createdAt = this.timestamp('created_at', { notNull: true });
   public updatedAt = this.timestamp('updated_at', { notNull: true });
 
-  public enum1 = this.enum<TestEnum>(TestEnum, 'enum1', 'TestEnum')
+  public roleEnum = this.type(rolesEnum, 'role')
 
   public userId = this.int('user_id').foreignKey(UsersTable, (table) => table.id);
 

package/{examples → data/_prev}/tables/cityTable.ts

@@ -1,11 +1,11 @@
-import { AbstractTable } from '@lambda-team/ltdl';
-import TestEnum from '@lambda-team/ltdl/examples/testEnum';
+import { AbstractTable } from 'drizzle-orm';
 import UsersTable from './usersTable';
+import { rolesEnum } from '../types/types';
 
 export default class CitiesTable extends AbstractTable<CitiesTable> {
   public name = this.timestamp('name', { notNull: true }).defaultValue(new Date());
   public page = this.varchar('page', { size: 256 });
-  public enum1 = this.enum<TestEnum>(TestEnum, 'enum1', 'TestEnum')
+  public roleEnum = this.type(rolesEnum, 'role')
 
   public userId1 = this.int('user_id').foreignKey(UsersTable, (table) => table.id);
 

package/{examples → data/_prev}/tables/usersTable.ts

@@ -1,4 +1,4 @@
-import { AbstractTable } from "@lambda-team/ltdl";
+import { AbstractTable } from "drizzle-orm";
 
 export default class UsersTable extends AbstractTable<UsersTable> {
   public id = this.int('id').autoIncrement().primaryKey();

package/data/_prev/types/types.ts

@@ -0,0 +1,11 @@
+import { createEnum } from "drizzle-orm/types/type";
+
+export const rolesEnum = createEnum({
+  alias: "roles_enum",
+  values: ["role1", "role2", "role3"],
+});
+
+export const roles2Enum = createEnum({
+  alias: "roles2_enum",
+  values: ["role1.1", "role2.2", "role3.3"],
+});

package/data/v1/tables/authOtpTable.ts

@@ -0,0 +1,18 @@
+import { AbstractTable } from 'drizzle-orm';
+
+export default class AuthOtpTable extends AbstractTable<AuthOtpTable> {
+  public id = this.int('id').autoIncrement().primaryKey();
+  public phone = this.varchar('phone', { size: 256 });
+
+  public column1 = this.varchar('to_add_default', { size: 256 });
+  public column2 = this.varchar('to_add_notnull', { size: 256 });
+
+  public column3 = this.varchar('to_change_default', { size: 256 }).defaultValue('defaultToChange');
+
+  public column4 = this.varchar('to_drop_default', { size: 256 }).defaultValue('defaul_to_be_dropped');
+  public column5 = this.varchar('to_drop_notnull', { size: 256, notNull: true });
+
+  public tableName(): string {
+    return 'auth_otp';
+  }
+}

package/data/v1/tables/deletedTable.ts

@@ -0,0 +1,9 @@
+import { AbstractTable } from 'drizzle-orm';
+
+export default class DeletedTable extends AbstractTable<DeletedTable> {
+  public id = this.int('id');
+
+  public tableName(): string {
+    return 'deleted';
+  }
+}

package/data/v1/tables/usersTable.ts

@@ -0,0 +1,15 @@
+import { AbstractTable } from "drizzle-orm";
+
+export default class UsersTable extends AbstractTable<UsersTable> {
+  public id = this.int('id').autoIncrement().primaryKey();
+  public fullName = this.varchar('full_name_to_alter', { size: 256 });
+
+  public test = this.decimal('column_to_delete1', { notNull: true, precision: 100, scale: 2 });
+  public test1 = this.bigint('column_to_todelet2', { notNull: true });
+
+  public fullNameIndex = this.index(this.fullName);
+
+  public tableName(): string {
+    return 'users';
+  }
+}

package/data/v1/types/types.ts

@@ -0,0 +1,6 @@
+import { createEnum } from "drizzle-orm/types/type";
+
+export const rolesEnum = createEnum({
+  alias: "roles_enum",
+  values: ["role1"],
+});

package/data/v2/tables/authOtpTable.ts

@@ -0,0 +1,22 @@
+import { AbstractTable } from 'drizzle-orm';
+import { rolesEnum, roles2Enum} from '../types/types'
+import UsersTable from './usersTable';
+
+export default class AuthOtpTable extends AbstractTable<AuthOtpTable> {
+  public id = this.int('id').autoIncrement().primaryKey();
+  public phone = this.varchar('phone', { size: 256 });
+
+  public column1 = this.varchar('to_add_default', { size: 256 }).defaultValue('added_default');
+  public column2 = this.varchar('to_add_notnull', { size: 256, notNull: true});
+  public column3 = this.varchar('to_change_default', { size: 256 }).defaultValue('defaultToChange');
+  public column4 = this.varchar('to_drop_default', { size: 256 });
+  public column5 = this.varchar('to_drop_notnull', { size: 256 });
+
+  public roleEnum1 = this.type(rolesEnum, 'role')
+  public roleEnum2 = this.type(roles2Enum, 'role2')
+  public userId = this.int('user_id').foreignKey(UsersTable, (table) => table.id);
+
+  public tableName(): string {
+    return 'auth_otp_renamed';
+  }
+}

package/data/v2/tables/cityTable.ts

@@ -0,0 +1,10 @@
+import { AbstractTable } from 'drizzle-orm';
+
+export default class CitiesTable extends AbstractTable<CitiesTable> {
+  public name = this.timestamp('name', { notNull: true }).defaultValue(new Date());
+  public data = this.jsonb<string[]>('data');
+
+  public tableName(): string {
+    return 'cities';
+  }
+}

package/data/v2/tables/usersTable.ts

@@ -0,0 +1,19 @@
+import { AbstractTable } from "drizzle-orm";
+
+export default class UsersTable extends AbstractTable<UsersTable> {
+  public id = this.int('id').autoIncrement().primaryKey();
+  public phone = this.varchar('phone', { size: 256 }).unique();
+  public fullName = this.varchar('full_name_to_alter', { size: 512 });
+
+  public createdAt = this.timestamp('created_at', { notNull: true });
+  public updatedAt = this.timestamp('updated_at', { notNull: true });
+
+  public phoneFullNameIndex = this.index([this.phone, this.fullName]);
+  
+  // deleted
+  // public fullNameIndex = this.index(this.fullName);
+
+  public tableName(): string {
+    return 'users2';
+  }
+}

package/data/v2/types/types.ts

@@ -0,0 +1,11 @@
+import { createEnum } from "drizzle-orm/types/type";
+
+export const rolesEnum = createEnum({
+  alias: "roles_enum",
+  values: ["role1", "role2", "role3"],
+});
+
+export const roles2Enum = createEnum({
+  alias: "roles2_enum",
+  values: ["role1.1", "role2.2", "role3.3"],
+});

package/data/v3/tables/authOtpTable.ts

@@ -0,0 +1,21 @@
+import { AbstractTable } from 'drizzle-orm';
+import UsersTable from './usersTable';
+import { rolesEnum } from '../types/types';
+
+export default class AuthOtpTable extends AbstractTable<AuthOtpTable> {
+  public id = this.int('id').autoIncrement().primaryKey();
+  public phone = this.varchar('phone', { size: 256 });
+  public otp = this.varchar('otp', { size: 256 });
+  public issuedAt = this.timestamp('issued_at', { notNull: true });
+  public createdAt = this.timestamp('created_at', { notNull: true });
+  public updatedAt = this.timestamp('updated_at', { notNull: true });
+
+  public roleEnum = this.type(rolesEnum, 'role')
+  public userId = this.int('user_id').foreignKey(UsersTable, (table) => table.id);
+
+  public test = this.jsonb<string[]>('test');
+
+  public tableName(): string {
+    return 'auth_otp';
+  }
+}

package/data/v3/tables/cityTable.ts

@@ -0,0 +1,17 @@
+import { AbstractTable } from 'drizzle-orm';
+import UsersTable from './usersTable';
+import { rolesEnum } from '../types/types';
+
+export default class CitiesTable extends AbstractTable<CitiesTable> {
+  public name = this.timestamp('name', { notNull: true }).defaultValue(new Date());
+  public page = this.varchar('page', { size: 256 });
+  public roleEnum = this.type(rolesEnum, 'role')
+
+  public userId1 = this.int('user_id').foreignKey(UsersTable, (table) => table.id);
+
+  public data = this.jsonb<string[]>('data');
+
+  public tableName(): string {
+    return 'citiess';
+  }
+}

package/data/v3/tables/usersTable.ts

@@ -0,0 +1,18 @@
+import { AbstractTable } from "drizzle-orm";
+
+export default class UsersTable extends AbstractTable<UsersTable> {
+  public id = this.int('id').autoIncrement().primaryKey();
+  public phone = this.varchar('phone', { size: 256 }).unique();
+  public fullName = this.varchar('full_name', { size: 512 });
+  public test = this.decimal('test', { notNull: true, precision: 100, scale: 2 });
+  public test1 = this.bigint('test1', { notNull: true });
+  public createdAt = this.timestamp('created_at', { notNull: true });
+  public updatedAt = this.timestamp('updated_at', { notNull: true });
+
+  public phoneFullNameIndex = this.index([this.phone, this.fullName]);
+  public phoneIndex = this.index(this.phone);
+
+  public tableName(): string {
+    return 'users';
+  }
+}

package/data/v3/types/types.ts

@@ -0,0 +1,11 @@
+import { createEnum } from "drizzle-orm/types/type";
+
+export const rolesEnum = createEnum({
+  alias: "roles_enum",
+  values: ["role1", "role2", "role3"],
+});
+
+export const roles2Enum = createEnum({
+  alias: "roles2_enum",
+  values: ["role1.1", "role2.2", "role3.3"],
+});

package/factory.ts

@@ -0,0 +1,224 @@
+import ts from "typescript";
+import fs from "fs";
+const printer: ts.Printer = ts.createPrinter();
+
+const prepareFabricFile = (folder: 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("@lambda-team/ltdl"),
+    ),
+    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 filenames = 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("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 < filenames.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("t" + 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("t" + i)],
+        ),
+      ),
+    ];
+
+    blockStatements.push(...blockStatement);
+  }
+
+  // return serializer.generate(tables)
+  blockStatements.push(ts.createReturn(
+    ts.createCall(
+      ts.createPropertyAccess(
+        ts.createIdentifier("serializer"),
+        ts.createIdentifier("generate"),
+      ),
+      undefined,
+      [ts.createIdentifier("tables")],
+    ),
+  ));
+
+  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/fstest.ts

@@ -0,0 +1,50 @@
+import fs from 'fs'
+import serialize from './src/serilizer'
+
+// TODO: export as a function w
+
+const dry = {
+    version: "1",
+    tables: {},
+    enums: {}
+}
+
+const prepareMigration = (path: string = 'drizzle'): {} => {
+    const root = path
+    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]
+        prevSnapshot = fs.readFileSync(`./${root}/${lastSnapshotFolder}/snapshot.json`).toJSON()
+    }
+
+    const timestamp = Date.now()
+    const migrationFolder = `./${root}/${timestamp}`
+    fs.mkdirSync(migrationFolder)
+
+    const version = 'v3'
+    const dir = `./data/${version}`
+    const tbls = `${dir}/tables/`
+    const tps = `${dir}/types/`
+
+    const result = serialize(tbls, tps)
+    fs.writeFileSync(`${migrationFolder}/snapshot.json`, JSON.stringify(result, null, 2))
+
+    return { prev: prevSnapshot, cur: result }
+}
+
+export default prepareMigration;

package/index.ts

@@ -0,0 +1,16 @@
+import serialize from './src/serilizer'
+import yaml from 'js-yaml'
+import fs from 'fs'
+
+const version = 'v2'
+const dir = `./data/${version}`
+const tbls = `${dir}/tables/`
+const tps = `${dir}/types/`
+
+// const config: Config = yaml.load(fs.readFileSync('config.yml', {encoding: 'utf-8'})) as Config;
+// console.log(config)
+
+const result = serialize(tbls, tps)
+const outName = `${version}_${new Date().getTime()}.json`
+fs.writeFileSync(`./out/${outName}`, JSON.stringify(result, null, 2))
+console.log(`-----> .../${outName}`)