drizzle-orm 0.10.25 → 0.10.28

package/src/serializer/serializer.ts

@@ -0,0 +1,336 @@
+/* eslint-disable max-classes-per-file */
+/* eslint-disable import/no-named-as-default-member */
+/* eslint-disable import/no-named-as-default */
+/* eslint-disable no-param-reassign */
+/* eslint-disable no-restricted-syntax */
+
+import { Column } from '../columns';
+import ColumnType from '../columns/types/columnType';
+import { DB } from '../db';
+import TableIndex from '../indexes/tableIndex';
+import { AbstractTable } from '../tables';
+import Enum from '../types/type';
+
+interface EnumsAsObject {
+  [name: string]: {
+    name: string,
+    values: string[]
+  }
+}
+
+interface ColumnAsObject {
+  [name: string]: {
+    name?: string;
+    type?: string;
+    primaryKey?: boolean;
+    unique?: boolean;
+    default?: any;
+    notNull?: boolean;
+    references?: string;
+  };
+}
+
+interface IndexColumnAsObject {
+  [name: string]: {
+    name?: string;
+  };
+}
+
+interface IndexAsObject {
+  [name: string]: {
+    name?: string;
+    columns?: ColumnAsObject;
+    isUnique?: boolean
+  };
+}
+
+interface TableAsObject {
+  [name: string]: {
+    name: string;
+    columns: ColumnAsObject;
+    indexes: {
+      [name: string]: {
+        name?: string;
+        type?: string;
+      };
+    };
+  };
+}
+
+const serialiseForeignKey = (fkName:string, table:string, column:string, onDelete?:string, onUpdate?:string)=>{
+  return`${fkName};${table};${column};${onDelete??''};${onUpdate??''}`
+}
+
+export default class MigrationSerializer {
+  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 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,
+            isUnique: value.isUnique(),
+          };
+        }
+
+        if (value instanceof Column) {
+          columnToReturn[value.getColumnName()] = {
+            name: value.getColumnName(),
+            type: (value.getColumnType() as ColumnType).getDbName(),
+            primaryKey: !!value.primaryKeyName,
+            // unique: !!value.uniqueKeyName,
+            // default: value.getDefaultValue() === null ? undefined : value.getDefaultValue(),
+            notNull: !value.isNullableFlag,
+          };
+
+          if (value.getDefaultValue() !== undefined && value.getDefaultValue() !== null) {
+            columnToReturn[value.getColumnName()].default = value.getDefaultValue();
+          }
+
+          if (value.uniqueKeyName) {
+            const indexName = `${value.getParent().tableName()}_${value.getColumnName()}_index`;
+
+            const indexColumnToReturn: IndexColumnAsObject = {};
+            indexColumnToReturn[value.getColumnName()] = {
+              name: value.getColumnName(),
+            };
+
+            indexToReturn[indexName] = {
+              name: indexName,
+              columns: indexColumnToReturn,
+              isUnique: true,
+            };
+          }
+
+          const referenced = value.getReferenced();
+          if (referenced) {
+            const fkName=`${value.getParent().tableName()}_${value.getColumnName()}_fkey`;
+            const table = referenced.getParentName();
+            const column = referenced.getColumnName();
+            const onDelete= value.getOnDelete();
+            const onUpdate= value.getOnUpdate();
+
+            const referenceString = serialiseForeignKey(fkName,table,column,onDelete,onUpdate)
+            columnToReturn[value.getColumnName()].references = referenceString;
+          }
+        }
+      }
+
+      result[table.tableName()] = {
+        name: table.tableName(),
+        columns: columnToReturn,
+        indexes: indexToReturn,
+      };
+    }
+
+    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: '2', tables: result, enums: enumsToReturn };
+  };
+
+  public fromDatabase = async (db: DB) => {
+    const result: TableAsObject = {};
+
+    const allTables = await db.session().execute('SELECT table_schema, table_name FROM information_schema.tables WHERE table_schema != \'pg_catalog\' and table_schema != \'information_schema\';');
+    for await (const row of allTables.rows) {
+      try {
+        // const tableSchema = row.table_schema;
+        const tableName = row.table_name;
+
+        const columnToReturn: ColumnAsObject = {};
+        const indexToReturn: IndexAsObject = {};
+
+        const tableResponse = await db.session().execute(`SELECT a.attrelid::regclass::text, a.attname
+        , CASE WHEN a.atttypid = ANY ('{int,int8,int2}'::regtype[])
+             AND EXISTS (
+                SELECT FROM pg_attrdef ad
+                WHERE  ad.adrelid = a.attrelid
+                AND    ad.adnum   = a.attnum
+                AND    pg_get_expr(ad.adbin, ad.adrelid)
+                     = 'nextval('''
+                    || (pg_get_serial_sequence (a.attrelid::regclass::text
+                                             , a.attname))::regclass
+                    || '''::regclass)'
+                )
+           THEN CASE a.atttypid
+                   WHEN 'int'::regtype  THEN 'serial'
+                   WHEN 'int8'::regtype THEN 'bigserial'
+                   WHEN 'int2'::regtype THEN 'smallserial'
+                END
+           ELSE format_type(a.atttypid, a.atttypmod)
+           END AS data_type, INFORMATION_SCHEMA.COLUMNS.table_name, INFORMATION_SCHEMA.COLUMNS.column_name, INFORMATION_SCHEMA.COLUMNS.column_default
+   FROM  pg_attribute  a
+   JOIN INFORMATION_SCHEMA.COLUMNS ON INFORMATION_SCHEMA.COLUMNS.column_name = a.attname
+   WHERE  a.attrelid = '${tableName}'::regclass and INFORMATION_SCHEMA.COLUMNS.table_name = '${tableName}'
+   AND    a.attnum > 0
+   AND    NOT a.attisdropped
+   ORDER  BY a.attnum;`);
+        const tableConstraints = await db.session().execute(`SELECT c.column_name, c.data_type, constraint_type, constraint_name
+      FROM information_schema.table_constraints tc 
+      JOIN information_schema.constraint_column_usage AS ccu USING (constraint_schema, constraint_name) 
+      JOIN information_schema.columns AS c ON c.table_schema = tc.constraint_schema
+        AND tc.table_name = c.table_name AND ccu.column_name = c.column_name
+      WHERE tc.table_name = '${tableName}';`);
+
+        const tableForeignKeys = await db.session().execute(`SELECT
+        tc.table_schema, 
+        tc.constraint_name, 
+        tc.table_name, 
+        kcu.column_name,
+        ccu.table_schema AS foreign_table_schema,
+        ccu.table_name AS foreign_table_name,
+        ccu.column_name AS foreign_column_name,
+        rc.delete_rule, rc.update_rule
+    FROM 
+        information_schema.table_constraints AS tc
+        JOIN information_schema.key_column_usage AS kcu
+          ON tc.constraint_name = kcu.constraint_name
+          AND tc.table_schema = kcu.table_schema
+        JOIN information_schema.constraint_column_usage AS ccu
+          ON ccu.constraint_name = tc.constraint_name
+          AND ccu.table_schema = tc.table_schema
+        JOIN information_schema.referential_constraints AS rc
+          ON ccu.constraint_name = rc.constraint_name 
+    WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_name='${tableName}';`);
+
+        const mappedRefernces: { [name: string]: string } = {};
+
+        for (const fk of tableForeignKeys.rows) {
+          // const tableFrom = fk.table_name;
+          const columnFrom = fk.column_name;
+          const tableTo = fk.foreign_table_name;
+          const columnTo = fk.foreign_column_name;
+          const foreignKeyName = fk.constraint_name;
+          const onUpdate = fk.update_rule;
+          const onDelete = fk.delete_rule;
+          const references = serialiseForeignKey(foreignKeyName,tableTo,columnTo,onDelete,onUpdate)
+          mappedRefernces[columnFrom] = references
+        }
+
+        for (const columnResponse of tableResponse.rows) {
+          const columnName = columnResponse.attname;
+          const columnType = columnResponse.data_type;
+
+          const primaryKey = tableConstraints.rows.filter((mapRow) => columnName === mapRow.column_name && mapRow.constraint_type === 'PRIMARY KEY');
+          const uniqueKey = tableConstraints.rows.filter((mapRow) => columnName === mapRow.column_name && mapRow.constraint_type === 'UNIQUE');
+
+          const defaultValue: string = columnResponse.column_default === null
+            ? undefined : columnResponse.column_default;
+
+          const isSerial = columnType === 'serial';
+          
+          columnToReturn[columnName] = {
+            name: columnName,
+            type: columnType,
+            primaryKey: !!primaryKey[0],
+            unique: !!uniqueKey[0],
+            default: isSerial ? undefined : defaultValue,
+            notNull: !columnResponse.is_nullable,
+            references: mappedRefernces[columnName] ?? undefined,
+          };
+        }
+
+        const dbIndexes = await db.session().execute(`select
+        t.relname as table_name,
+        i.relname as index_name,
+        a.attname as column_name
+    from
+        pg_class t,
+        pg_class i,
+        pg_index ix,
+        pg_attribute a
+    where
+        t.oid = ix.indrelid
+        and i.oid = ix.indexrelid
+        and a.attrelid = t.oid
+        and a.attnum = ANY(ix.indkey)
+        and t.relkind = 'r'
+        and t.relname = '${tableName}'
+    order by
+        t.relname,
+        i.relname;`);
+
+        for (const dbIndex of dbIndexes.rows) {
+          const indexName = dbIndex.index_name;
+          const indexColumnName = dbIndex.column_name;
+
+          if (indexToReturn[indexName] !== undefined && indexToReturn[indexName] !== null) {
+            indexToReturn[indexName]!.columns![indexColumnName] = {
+              name: indexColumnName,
+            };
+          } else {
+            indexToReturn[indexName] = {
+              name: indexName,
+              columns: {
+                [indexColumnName]: {
+                  name: indexColumnName,
+                },
+              },
+            };
+          }
+        }
+
+        result[tableName] = {
+          name: tableName,
+          columns: columnToReturn,
+          indexes: indexToReturn,
+        };
+      } catch (e) {
+        console.log(e);
+      }
+    }
+
+    const allEnums = await db.session().execute(`select n.nspname as enum_schema,  
+    t.typname as enum_name,  
+    e.enumlabel as enum_value
+    from pg_type t 
+    join pg_enum e on t.oid = e.enumtypid  
+    join pg_catalog.pg_namespace n ON n.oid = t.typnamespace;`);
+
+    const enumsToReturn: EnumsAsObject = {};
+
+    for (const dbEnum of allEnums.rows) {
+      const enumName = dbEnum.enum_name;
+      const enumValue = dbEnum.enum_value;
+
+      if (enumsToReturn[enumName] !== undefined && enumsToReturn[enumName] !== null) {
+        enumsToReturn[enumName].values.push(enumValue);
+      } else {
+        enumsToReturn[enumName] = {
+          name: enumName,
+          values: [enumValue],
+        };
+      }
+    }
+
+    return { version: '2', tables: result, enums: enumsToReturn };
+  };
+}

package/src/tables/abstractTable.ts

@@ -0,0 +1,188 @@
+import PgVarChar from '../columns/types/pgVarChar';
+import PgTimestamp from '../columns/types/pgTimestamp';
+import PgInteger from '../columns/types/pgInteger';
+import PgBigDecimal from '../columns/types/pgBigDecimal';
+import PgTime from '../columns/types/pgTime';
+import PgBoolean from '../columns/types/pgBoolean';
+import PgText from '../columns/types/pgText';
+import PgJsonb from '../columns/types/pgJsonb';
+import ColumnType from '../columns/types/columnType';
+import InsertTRB from '../builders/highLvlBuilders/insertRequestBuilder';
+import DeleteTRB from '../builders/highLvlBuilders/deleteRequestBuilder';
+import UpdateTRB from '../builders/highLvlBuilders/updateRequestBuilder';
+import SelectTRB from '../builders/highLvlBuilders/selectRequestBuilder';
+import PgBigInt53, { PgBigInt64 } from '../columns/types/pgBigInt';
+import { ISession } from '../db/session';
+import BaseLogger from '../logger/abstractLogger';
+import PgEnum from '../columns/types/pgEnum';
+import DB from '../db/db';
+import { AbstractColumn, Column } from '../columns/column';
+import TableIndex from '../indexes/tableIndex';
+import { ExtractModel } from './inferTypes';
+import Enum, { ExtractEnumValues } from '../types/type';
+import PgSmallInt from '../columns/types/pgSmallInt';
+import PgSerial from '../columns/types/pgSerial';
+import PgTimestamptz from '../columns/types/pgTimestamptz';
+import PgBigSerial53, { PgBigSerial64 } from '../columns/types/pgBigSerial';
+
+export default abstract class AbstractTable<TTable extends AbstractTable<TTable>> {
+  public db: DB;
+
+  private _session: ISession;
+  private _logger: BaseLogger | undefined;
+
+  public constructor(db: DB) {
+    this._session = db.session();
+    this._logger = db.logger();
+    this.db = db;
+  }
+
+  // @TODO document, that you should not use arrow functions for abstract classes
+  public abstract tableName(): string;
+
+  public withLogger = (logger: BaseLogger) => {
+    this._logger = logger;
+  };
+
+  // eslint-disable-next-line max-len
+  public select<TType extends ColumnType<any>, TColumn extends AbstractColumn<TType, boolean, boolean, TTable>, T extends {[name: string]: TColumn} = {}>(partial?: T): SelectTRB<TTable, T> {
+    if (!this._session) {
+      throw new Error(`Db was not provided in constructor, while ${this.constructor.name} class was creating. Please make sure, that you provided Db object to ${this.constructor.name} class. Should be -> new ${this.constructor.name}(db)`);
+    }
+
+    return new SelectTRB(
+      this._session,
+      this.mapServiceToDb(),
+      {},
+      this,
+      this._logger,
+      partial,
+    );
+  }
+
+  public update = (): UpdateTRB<TTable> => {
+    if (!this._session) {
+      throw new Error(`Db was not provided in constructor, while ${this.constructor.name} class was creating. Please make sure, that you provided Db object to ${this.constructor.name} class. Should be -> new ${this.constructor.name}(db)`);
+    }
+    return new UpdateTRB(this, this._session, this.mapServiceToDb(), this._logger);
+  };
+
+  public insert = (value: ExtractModel<TTable>):
+  InsertTRB<TTable> => {
+    if (!this._session) {
+      throw new Error(`Db was not provided in constructor, while ${this.constructor.name} class was creating. Please make sure, that you provided Db object to ${this.constructor.name} class. Should be -> new ${this.constructor.name}(db)`);
+    }
+    return new InsertTRB([value], this._session,
+      this.mapServiceToDb(), this, this._logger);
+  };
+
+  public insertMany = (values: ExtractModel<TTable>[]):
+  InsertTRB<TTable> => {
+    if (!this._session) {
+      throw new Error(`Db was not provided in constructor, while ${this.constructor.name} class was creating. Please make sure, that you provided Db object to ${this.constructor.name} class. Should be -> new ${this.constructor.name}(db)`);
+    }
+    return new InsertTRB(values, this._session,
+      this.mapServiceToDb(), this, this._logger);
+  };
+
+  public delete = (): DeleteTRB<TTable> => {
+    if (!this._session) {
+      throw new Error(`Db was not provided in constructor, while ${this.constructor.name} class was creating. Please make sure, that you provided Db object to ${this.constructor.name} class. Should be -> new ${this.constructor.name}(db)`);
+    }
+    return new DeleteTRB(this, this._session, this.mapServiceToDb(), this._logger);
+  };
+
+  public mapServiceToDb(): {[name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>} {
+    return Object.getOwnPropertyNames(this)
+      .reduce<{[name in keyof ExtractModel<TTable>]
+      : AbstractColumn<ColumnType>}>((res, fieldName) => {
+      const field: unknown = (this as unknown as TTable)[fieldName as keyof TTable];
+      if (field instanceof AbstractColumn) {
+        res[fieldName as keyof ExtractModel<TTable>] = field;
+      }
+      return res;
+    }, {} as {[name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>});
+  }
+
+  protected index(columns: Array<Column<ColumnType, boolean, boolean>>): TableIndex
+  protected index(columns: Column<ColumnType, boolean, boolean>): TableIndex
+  protected index(columns: any) {
+    return new TableIndex(this.tableName(), columns instanceof Array ? columns : [columns]);
+  }
+
+  protected uniqueIndex(columns: Array<Column<ColumnType, boolean, boolean>>): TableIndex
+  protected uniqueIndex(columns: Column<ColumnType, boolean, boolean>): TableIndex
+  protected uniqueIndex(columns: any) {
+    return new TableIndex(this.tableName(), columns instanceof Array ? columns : [columns], true);
+  }
+
+  protected varchar(name: string, params: {size?: number} = {})
+    : Column<PgVarChar, true, false, this> {
+    return new Column(this, name, new PgVarChar(params.size));
+  }
+
+  protected int(name: string): Column<PgInteger, true, false, this> {
+    return new Column(this, name, new PgInteger());
+  }
+
+  protected smallInt(name: string): Column<PgSmallInt, true, false, this> {
+    return new Column(this, name, new PgSmallInt());
+  }
+
+  protected serial(name: string): Column<PgSerial, true, true, this> {
+    return new Column(this, name, new PgSerial());
+  }
+
+  protected bigSerial(name: string, maxBytes: 'max_bytes_53'): Column<PgBigSerial53, true, true, this>
+  protected bigSerial(name: string, maxBytes: 'max_bytes_64'): Column<PgBigSerial64, true, true, this>
+  protected bigSerial(name: string, maxBytes: 'max_bytes_53' | 'max_bytes_64') {
+    if (maxBytes === 'max_bytes_53') {
+      return new Column(this, name, new PgBigSerial53());
+    }
+    return new Column(this, name, new PgBigSerial64());
+  }
+
+  protected timestamp(name: string): Column<PgTimestamp, true, false, this> {
+    return new Column(this, name, new PgTimestamp());
+  }
+
+  protected timestamptz(name: string): Column<PgTimestamptz, true, false, this> {
+    return new Column(this, name, new PgTimestamptz());
+  }
+
+  protected bigint(name: string, maxBytes: 'max_bytes_53'): Column<PgBigInt53, true, false, this>
+  protected bigint(name: string, maxBytes: 'max_bytes_64'): Column<PgBigInt64, true, false, this>
+  protected bigint(name: string, maxBytes: 'max_bytes_53' | 'max_bytes_64') {
+    if (maxBytes === 'max_bytes_53') {
+      return new Column(this, name, new PgBigInt53());
+    }
+    return new Column(this, name, new PgBigInt64());
+  }
+
+  protected type<ETtype extends string>(typeEnum: Enum<ETtype>, name: string)
+    : Column<PgEnum<ExtractEnumValues<Enum<ETtype>>>, true, false, this> {
+    const pgEnum = new PgEnum<ExtractEnumValues<typeof typeEnum>>(typeEnum.name);
+    return new Column(this, name, pgEnum);
+  }
+
+  protected decimal(name: string, params: { precision?: number, scale?: number}
+  = {}): Column<PgBigDecimal, true, false, this> {
+    return new Column(this, name, new PgBigDecimal(params.precision, params.scale));
+  }
+
+  protected time(name: string): Column<PgTime, true, false, this> {
+    return new Column(this, name, new PgTime());
+  }
+
+  protected bool(name: string): Column<PgBoolean, true, false, this> {
+    return new Column(this, name, new PgBoolean());
+  }
+
+  protected text(name: string): Column<PgText, true, false, this> {
+    return new Column(this, name, new PgText());
+  }
+
+  protected jsonb<TSubType>(name: string): Column<PgJsonb<TSubType>, true, false, this> {
+    return new Column(this, name, new PgJsonb<TSubType>());
+  }
+}

package/src/tables/index.ts

@@ -0,0 +1,4 @@
+/* eslint-disable import/no-cycle */
+export { default as MigrationsTable } from './migrationsTable';
+export { default as AbstractTable } from './abstractTable';
+export { ExtractModel } from './inferTypes';

package/src/tables/inferTypes.ts

@@ -0,0 +1,67 @@
+/* eslint-disable max-len */
+import { UpdateCustomExpr } from '../builders/requestBuilders/updates/updates';
+import { AbstractColumn, Column, IndexedColumn } from '../columns/column';
+import ColumnType from '../columns/types/columnType';
+import TableIndex from '../indexes/tableIndex';
+import Type from '../types/type';
+import AbstractTable from './abstractTable';
+
+export type ExtractFieldNames<TTable> = {
+  [Key in keyof TTable]: TTable[Key] extends Function ? never :
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    TTable[Key] extends Column<ColumnType, infer TNullable, infer TAutoIncrement> ?
+      true extends TNullable ? never : Key
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      : TTable[Key] extends IndexedColumn<ColumnType, infer TNullable, infer TAutoIncrement> ?
+        true extends TNullable ? never : Key:never
+}[keyof TTable];
+
+export type ExtractOptionalFieldNames<TTable> = {
+  [Key in keyof TTable]: TTable[Key] extends Function ? never :
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    TTable[Key] extends Column<ColumnType, infer TNullable, infer TAutoIncrement> ?
+      true extends TNullable ? Key : never
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      : TTable[Key] extends IndexedColumn<ColumnType, infer TNullable, infer TAutoIncrement> ?
+        true extends TNullable ? Key : never : never
+}[keyof TTable];
+
+export type ExtractPartialObjectFromColumns<TTable> =
+  {[Key in ExtractFieldNames<TTable>]: TTable[Key]} &
+  {[Key in ExtractOptionalFieldNames<TTable>]?: TTable[Key] };
+
+export type ExtractModel<TTable> =
+  {[Key in ExtractFieldNames<TTable>]: ExtractCodeType<TTable[Key]>} &
+  {[Key in ExtractOptionalFieldNames<TTable>]?: ExtractCodeType<TTable[Key]>};
+
+export type ExtractUpdateModel<TTable> =
+  {[Key in ExtractFieldNames<TTable>]:
+    ExtractCodeType<TTable[Key]> | UpdateCustomExpr<TTable[Key]>} &
+  {[Key in ExtractOptionalFieldNames<TTable>]?:
+    ExtractCodeType<TTable[Key]> | UpdateCustomExpr<TTable[Key]> };
+
+export type ExtractCodeType<T extends AbstractColumn<ColumnType<any>, boolean, boolean>> =
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      T extends AbstractColumn<ColumnType<infer TCodeType>, infer TNullable, infer TAutoIncrement, any> ?
+        TCodeType
+        : never;
+
+export type ExtractTypeEnum<T extends Type<any>> = T extends Type<infer TEnum>
+  ? TEnum
+  : never;
+
+export type Indexing = IndexedColumn<ColumnType, boolean, boolean> | TableIndex;
+
+export type AnyColumn = Column<ColumnType, boolean, boolean>
+| IndexedColumn<ColumnType, boolean, boolean>;
+
+export type PartialFor<TTable extends AbstractTable<TTable>>
+= {[name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, TTable>};
+
+export type FullOrPartial<TTable extends AbstractTable<TTable>, TPartial extends PartialFor<TTable>>
+= [keyof TPartial] extends [never] ? ExtractModel<TTable>: ExtractModel<TPartial>;
+
+export type CheckTwoTypes<TInput, TTable extends AbstractTable<TTable>, TTable1 extends AbstractTable<TTable1>> = TInput extends AbstractTable<TTable> ? TTable : TInput extends AbstractTable<TTable1> ? TTable1 : never;
+export type CheckThreeTypes<TInput, TTable extends AbstractTable<TTable>, TTable1 extends AbstractTable<TTable1>, TTable2 extends AbstractTable<TTable2>> = TInput extends AbstractTable<TTable> ? TTable : TInput extends AbstractTable<TTable1> ? TTable1 : TInput extends AbstractTable<TTable2> ? TTable2 : never;
+export type CheckFourTypes<TInput, TTable extends AbstractTable<TTable>, TTable1 extends AbstractTable<TTable1>, TTable2 extends AbstractTable<TTable2>, TTable3 extends AbstractTable<TTable3>> = TInput extends AbstractTable<TTable> ? TTable : TInput extends AbstractTable<TTable1> ? TTable1 : TInput extends AbstractTable<TTable2> ? TTable2 : TInput extends AbstractTable<TTable3> ? TTable3 : never;
+export type CheckFiveTypes<TInput, TTable extends AbstractTable<TTable>, TTable1 extends AbstractTable<TTable1>, TTable2 extends AbstractTable<TTable2>, TTable3 extends AbstractTable<TTable3>, TTable4 extends AbstractTable<TTable4>> = TInput extends AbstractTable<TTable> ? TTable : TInput extends AbstractTable<TTable1> ? TTable1 : TInput extends AbstractTable<TTable2> ? TTable2 : TInput extends AbstractTable<TTable3> ? TTable3 : TInput extends AbstractTable<TTable4> ? TTable4 : never;

package/src/tables/migrationsTable.ts

@@ -0,0 +1,11 @@
+import AbstractTable from './abstractTable';
+
+export default class MigrationsTable extends AbstractTable<MigrationsTable> {
+  public id = this.serial('id').primaryKey();
+  public hash = this.text('hash').notNull();
+  public createdAt = this.bigint('created_at', 'max_bytes_53');
+
+  public tableName(): string {
+    return 'drizzle_migrations';
+  }
+}

package/src/types/type.ts

@@ -0,0 +1,15 @@
+export default class Enum<T extends string> {
+  public constructor(
+    public name: string,
+    public values: T[],
+  ) {
+  }
+}
+
+export type ExtractEnumValues<T> = T extends Enum<infer TValues> ? TValues : never;
+
+export function createEnum<T extends string>(
+  { alias, values }:{alias: string, values: T[]},
+): Enum<T> {
+  return new Enum(alias, values);
+}

package/src/utils/ecranate.ts

@@ -0,0 +1,4 @@
+export const ecranate = (data: string) => `"${data}"`;
+
+export const shouldEcranate = (value: any): boolean => typeof value === 'string'
+|| value instanceof Date || value === Object(value);

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "declaration": true,
+  },
+  "include": [
+    "src"
+  ],
+  "exclude": [
+    "dist"
+  ]
+}