drizzle-kit 0.9.1 → 0.9.5

package/data/v2/tables/authOtpTable.ts

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

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

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

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

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

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

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

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

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

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

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

package/readme.md

@@ -1,9 +0,0 @@
-todo: configurable migrations folder
-todo: configurable tables and enums folder
-todo: ability to just have single folder with either tables and enums in one file or spreaded in multiple files
-
-stage0 -> fstest.js
-it does check if migration folder exists, if not - creates one. Checks if initial migration exists, if not - creates one and initiate init migration generation with dryrun snapshot1. If init migration exists - initiate migration generation with last chronologically available snapshot folder.
-
-stage1 -> ./index.ts
-It is now harcoded, what it does - it takes directory for tables and enums and generates json snapshot of the whole project schema.

package/serializer.ts

@@ -1,139 +0,0 @@
-/* eslint-disable no-restricted-syntax */
-/* eslint-disable new-cap */
-/* eslint-disable global-require */
-/* eslint-disable import/no-dynamic-require */
-import { AbstractTable, Column, DB } from 'drizzle-orm';
-import ColumnType from 'drizzle-orm/columns/types/columnType';
-import PgEnum from 'drizzle-orm/columns/types/pgEnum';
-import TableIndex from 'drizzle-orm/indexes/tableIndex';
-import Enum from 'drizzle-orm/types/type';
-import { Pool } from 'pg';
-
-interface ColumnAsObject {
-  [name: string]: {
-    name?: string;
-    type?: string;
-    primaryKey?: boolean;
-    autoincrement?: boolean;
-    unique?: boolean;
-    default?: any;
-    notNull?: boolean;
-    references?: {
-      table: string;
-      column: string;
-    };
-  };
-}
-
-interface IndexColumnAsObject {
-  [name: string]: {
-    name?: string;
-  };
-}
-
-interface IndexAsObject {
-  [name: string]: {
-    name?: string;
-    columns?: ColumnAsObject;
-  };
-}
-
-interface TableAsObject {
-  [name: string]: {
-    name: string;
-    columns: ColumnAsObject;
-    indexes: {
-      [name: string]: {
-        name?: string;
-        type?: string;
-      };
-    };
-  };
-}
-
-interface EnumAsObject {
-  [name: string]: {
-    name: string;
-    values: string[];
-  };
-}
-
-export default class MigrationSerializer {
-  db = new DB(new Pool());
-
-  public generate = (tables: AbstractTable<any>[], enums: Enum<any>[]) => {
-    const result: TableAsObject = {};
-
-    for (const table of tables) {
-      const tableEntries = Object.entries(table);
-      const columnToReturn: ColumnAsObject = {};
-      const indexToReturn: IndexAsObject = {};
-
-      for (const properties of tableEntries) {
-        const key = properties[0];
-        const value = properties[1];
-        if (value instanceof TableIndex) {
-          const columns = value.getColumns();
-          const name = value.indexName();
-
-          const indexColumnToReturn: IndexColumnAsObject = {};
-
-          for (const column of columns) {
-            const columnName = column.getColumnName();
-            indexColumnToReturn[columnName] = {
-              name: columnName,
-            };
-          }
-
-          indexToReturn[name] = {
-            name,
-            columns: indexColumnToReturn,
-          };
-        }
-
-        if (value instanceof Column) {
-          columnToReturn[key] = {
-            name: value.getColumnName(),
-            type: (value.getColumnType() as ColumnType).getDbName(),
-            primaryKey: !!value.primaryKeyName,
-            autoincrement: value.isAutoIncrement(),
-            unique: !!value.uniqueKeyName,
-            default: value.getDefaultValue() === null ? undefined : value.getDefaultValue(),
-            notNull: !value.isNullableFlag,
-          };
-
-          const referenced = value.getReferenced();
-          if (referenced) {
-            columnToReturn[key].references = {
-              table: referenced.getParentName(),
-              column: referenced.getColumnName(),
-            };
-          }
-        }
-      }
-
-      result[table.tableName()] = {
-        name: table.tableName(),
-        columns: columnToReturn,
-        indexes: indexToReturn,
-      };
-    }
-
-    // const enumsToReturn = enums.map((it) => {
-    //   return { name: it.name, values: it.values }
-    // });
-
-    const enumsToReturn = enums.reduce<{[key:string]: Enum<any>}>((map, obj) => {
-      const key = obj.name;
-      const newValues = obj.values.reduce((mapped, value) => {
-        mapped[value] = value;
-        return mapped;
-      }, {});
-
-      map[key] = { name: obj.name, values: newValues };
-      return map;
-    }, {});
-
-    return { version: '1', tables: result, enums: enumsToReturn };
-  };
-}

package/src/cli/commands/migration/index.tsx

@@ -1,10 +0,0 @@
-import { program } from 'commander';
-
-import migrate from './migrate';
-
-const cmd = program
-  .command('migrate')
-  .alias('mg')
-  .description('Migration')
-  .action(migrate);
-cmd.command('start').description('Start migration').action(migrate);