drizzle-orm 0.10.26 → 0.10.27

package/dist/serializer/serializer.js

@@ -0,0 +1,258 @@
+"use strict";
+/* 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 */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const columns_1 = require("../columns");
+const tableIndex_1 = __importDefault(require("../indexes/tableIndex"));
+const serialiseForeignKey = (fkName, table, column, onDelete, onUpdate) => {
+    return `${fkName};${table};${column};${onDelete !== null && onDelete !== void 0 ? onDelete : ''};${onUpdate !== null && onUpdate !== void 0 ? onUpdate : ''}`;
+};
+class MigrationSerializer {
+    constructor() {
+        this.generate = (tables, enums) => {
+            const result = {};
+            for (const table of tables) {
+                const tableEntries = Object.entries(table);
+                const columnToReturn = {};
+                const indexToReturn = {};
+                for (const properties of tableEntries) {
+                    const value = properties[1];
+                    if (value instanceof tableIndex_1.default) {
+                        const columns = value.getColumns();
+                        const name = value.indexName();
+                        const indexColumnToReturn = {};
+                        for (const column of columns) {
+                            const columnName = column.getColumnName();
+                            indexColumnToReturn[columnName] = {
+                                name: columnName,
+                            };
+                        }
+                        indexToReturn[name] = {
+                            name,
+                            columns: indexColumnToReturn,
+                            isUnique: value.isUnique(),
+                        };
+                    }
+                    if (value instanceof columns_1.Column) {
+                        columnToReturn[value.getColumnName()] = {
+                            name: value.getColumnName(),
+                            type: value.getColumnType().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 = {};
+                            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((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 };
+        };
+        this.fromDatabase = async (db) => {
+            var _a;
+            const result = {};
+            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 = {};
+                    const indexToReturn = {};
+                    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 = {};
+                    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 = 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: (_a = mappedRefernces[columnName]) !== null && _a !== void 0 ? _a : 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 = {};
+            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 };
+        };
+    }
+}
+exports.default = MigrationSerializer;

package/dist/tables/abstractTable.d.ts

@@ -0,0 +1,68 @@
+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 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>> {
+    db: DB;
+    private _session;
+    private _logger;
+    constructor(db: DB);
+    abstract tableName(): string;
+    withLogger: (logger: BaseLogger) => void;
+    select<TType extends ColumnType<any>, TColumn extends AbstractColumn<TType, boolean, boolean, TTable>, T extends {
+        [name: string]: TColumn;
+    } = {}>(partial?: T): SelectTRB<TTable, T>;
+    update: () => UpdateTRB<TTable>;
+    insert: (value: ExtractModel<TTable>) => InsertTRB<TTable>;
+    insertMany: (values: ExtractModel<TTable>[]) => InsertTRB<TTable>;
+    delete: () => DeleteTRB<TTable>;
+    mapServiceToDb(): {
+        [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 uniqueIndex(columns: Array<Column<ColumnType, boolean, boolean>>): TableIndex;
+    protected uniqueIndex(columns: Column<ColumnType, boolean, boolean>): TableIndex;
+    protected varchar(name: string, params?: {
+        size?: number;
+    }): Column<PgVarChar, true, false, this>;
+    protected int(name: string): Column<PgInteger, true, false, this>;
+    protected smallInt(name: string): Column<PgSmallInt, true, false, this>;
+    protected serial(name: string): Column<PgSerial, true, true, this>;
+    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 timestamp(name: string): Column<PgTimestamp, true, false, this>;
+    protected timestamptz(name: string): Column<PgTimestamptz, true, false, this>;
+    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 type<ETtype extends string>(typeEnum: Enum<ETtype>, name: string): Column<PgEnum<ExtractEnumValues<Enum<ETtype>>>, true, false, this>;
+    protected decimal(name: string, params?: {
+        precision?: number;
+        scale?: number;
+    }): Column<PgBigDecimal, true, false, this>;
+    protected time(name: string): Column<PgTime, true, false, this>;
+    protected bool(name: string): Column<PgBoolean, true, false, this>;
+    protected text(name: string): Column<PgText, true, false, this>;
+    protected jsonb<TSubType>(name: string): Column<PgJsonb<TSubType>, true, false, this>;
+}

package/dist/tables/abstractTable.js

@@ -0,0 +1,151 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pgVarChar_1 = __importDefault(require("../columns/types/pgVarChar"));
+const pgTimestamp_1 = __importDefault(require("../columns/types/pgTimestamp"));
+const pgInteger_1 = __importDefault(require("../columns/types/pgInteger"));
+const pgBigDecimal_1 = __importDefault(require("../columns/types/pgBigDecimal"));
+const pgTime_1 = __importDefault(require("../columns/types/pgTime"));
+const pgBoolean_1 = __importDefault(require("../columns/types/pgBoolean"));
+const pgText_1 = __importDefault(require("../columns/types/pgText"));
+const pgJsonb_1 = __importDefault(require("../columns/types/pgJsonb"));
+const insertRequestBuilder_1 = __importDefault(require("../builders/highLvlBuilders/insertRequestBuilder"));
+const deleteRequestBuilder_1 = __importDefault(require("../builders/highLvlBuilders/deleteRequestBuilder"));
+const updateRequestBuilder_1 = __importDefault(require("../builders/highLvlBuilders/updateRequestBuilder"));
+const selectRequestBuilder_1 = __importDefault(require("../builders/highLvlBuilders/selectRequestBuilder"));
+const pgBigInt_1 = __importStar(require("../columns/types/pgBigInt"));
+const pgEnum_1 = __importDefault(require("../columns/types/pgEnum"));
+const column_1 = require("../columns/column");
+const tableIndex_1 = __importDefault(require("../indexes/tableIndex"));
+const pgSmallInt_1 = __importDefault(require("../columns/types/pgSmallInt"));
+const pgSerial_1 = __importDefault(require("../columns/types/pgSerial"));
+const pgTimestamptz_1 = __importDefault(require("../columns/types/pgTimestamptz"));
+const pgBigSerial_1 = __importStar(require("../columns/types/pgBigSerial"));
+class AbstractTable {
+    constructor(db) {
+        this.withLogger = (logger) => {
+            this._logger = logger;
+        };
+        this.update = () => {
+            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 updateRequestBuilder_1.default(this, this._session, this.mapServiceToDb(), this._logger);
+        };
+        this.insert = (value) => {
+            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 insertRequestBuilder_1.default([value], this._session, this.mapServiceToDb(), this, this._logger);
+        };
+        this.insertMany = (values) => {
+            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 insertRequestBuilder_1.default(values, this._session, this.mapServiceToDb(), this, this._logger);
+        };
+        this.delete = () => {
+            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 deleteRequestBuilder_1.default(this, this._session, this.mapServiceToDb(), this._logger);
+        };
+        this._session = db.session();
+        this._logger = db.logger();
+        this.db = db;
+    }
+    // eslint-disable-next-line max-len
+    select(partial) {
+        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 selectRequestBuilder_1.default(this._session, this.mapServiceToDb(), {}, this, this._logger, partial);
+    }
+    mapServiceToDb() {
+        return Object.getOwnPropertyNames(this)
+            .reduce((res, fieldName) => {
+            const field = this[fieldName];
+            if (field instanceof column_1.AbstractColumn) {
+                res[fieldName] = field;
+            }
+            return res;
+        }, {});
+    }
+    index(columns) {
+        return new tableIndex_1.default(this.tableName(), columns instanceof Array ? columns : [columns]);
+    }
+    uniqueIndex(columns) {
+        return new tableIndex_1.default(this.tableName(), columns instanceof Array ? columns : [columns], true);
+    }
+    varchar(name, params = {}) {
+        return new column_1.Column(this, name, new pgVarChar_1.default(params.size));
+    }
+    int(name) {
+        return new column_1.Column(this, name, new pgInteger_1.default());
+    }
+    smallInt(name) {
+        return new column_1.Column(this, name, new pgSmallInt_1.default());
+    }
+    serial(name) {
+        return new column_1.Column(this, name, new pgSerial_1.default());
+    }
+    bigSerial(name, maxBytes) {
+        if (maxBytes === 'max_bytes_53') {
+            return new column_1.Column(this, name, new pgBigSerial_1.default());
+        }
+        return new column_1.Column(this, name, new pgBigSerial_1.PgBigSerial64());
+    }
+    timestamp(name) {
+        return new column_1.Column(this, name, new pgTimestamp_1.default());
+    }
+    timestamptz(name) {
+        return new column_1.Column(this, name, new pgTimestamptz_1.default());
+    }
+    bigint(name, maxBytes) {
+        if (maxBytes === 'max_bytes_53') {
+            return new column_1.Column(this, name, new pgBigInt_1.default());
+        }
+        return new column_1.Column(this, name, new pgBigInt_1.PgBigInt64());
+    }
+    type(typeEnum, name) {
+        const pgEnum = new pgEnum_1.default(typeEnum.name);
+        return new column_1.Column(this, name, pgEnum);
+    }
+    decimal(name, params = {}) {
+        return new column_1.Column(this, name, new pgBigDecimal_1.default(params.precision, params.scale));
+    }
+    time(name) {
+        return new column_1.Column(this, name, new pgTime_1.default());
+    }
+    bool(name) {
+        return new column_1.Column(this, name, new pgBoolean_1.default());
+    }
+    text(name) {
+        return new column_1.Column(this, name, new pgText_1.default());
+    }
+    jsonb(name) {
+        return new column_1.Column(this, name, new pgJsonb_1.default());
+    }
+}
+exports.default = AbstractTable;

package/dist/tables/index.d.ts

@@ -0,0 +1,3 @@
+export { default as MigrationsTable } from './migrationsTable';
+export { default as AbstractTable } from './abstractTable';
+export { ExtractModel } from './inferTypes';

package/dist/tables/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractTable = exports.MigrationsTable = void 0;
+/* eslint-disable import/no-cycle */
+var migrationsTable_1 = require("./migrationsTable");
+Object.defineProperty(exports, "MigrationsTable", { enumerable: true, get: function () { return __importDefault(migrationsTable_1).default; } });
+var abstractTable_1 = require("./abstractTable");
+Object.defineProperty(exports, "AbstractTable", { enumerable: true, get: function () { return __importDefault(abstractTable_1).default; } });

package/dist/tables/inferTypes.d.ts

@@ -0,0 +1,39 @@
+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 declare type ExtractFieldNames<TTable> = {
+    [Key in keyof TTable]: TTable[Key] extends Function ? never : TTable[Key] extends Column<ColumnType, infer TNullable, infer TAutoIncrement> ? true extends TNullable ? never : Key : TTable[Key] extends IndexedColumn<ColumnType, infer TNullable, infer TAutoIncrement> ? true extends TNullable ? never : Key : never;
+}[keyof TTable];
+export declare type ExtractOptionalFieldNames<TTable> = {
+    [Key in keyof TTable]: TTable[Key] extends Function ? never : TTable[Key] extends Column<ColumnType, infer TNullable, infer TAutoIncrement> ? true extends TNullable ? Key : never : TTable[Key] extends IndexedColumn<ColumnType, infer TNullable, infer TAutoIncrement> ? true extends TNullable ? Key : never : never;
+}[keyof TTable];
+export declare type ExtractPartialObjectFromColumns<TTable> = {
+    [Key in ExtractFieldNames<TTable>]: TTable[Key];
+} & {
+    [Key in ExtractOptionalFieldNames<TTable>]?: TTable[Key];
+};
+export declare type ExtractModel<TTable> = {
+    [Key in ExtractFieldNames<TTable>]: ExtractCodeType<TTable[Key]>;
+} & {
+    [Key in ExtractOptionalFieldNames<TTable>]?: ExtractCodeType<TTable[Key]>;
+};
+export declare type ExtractUpdateModel<TTable> = {
+    [Key in ExtractFieldNames<TTable>]: ExtractCodeType<TTable[Key]> | UpdateCustomExpr<TTable[Key]>;
+} & {
+    [Key in ExtractOptionalFieldNames<TTable>]?: ExtractCodeType<TTable[Key]> | UpdateCustomExpr<TTable[Key]>;
+};
+export declare type ExtractCodeType<T extends AbstractColumn<ColumnType<any>, boolean, boolean>> = T extends AbstractColumn<ColumnType<infer TCodeType>, infer TNullable, infer TAutoIncrement, any> ? TCodeType : never;
+export declare type ExtractTypeEnum<T extends Type<any>> = T extends Type<infer TEnum> ? TEnum : never;
+export declare type Indexing = IndexedColumn<ColumnType, boolean, boolean> | TableIndex;
+export declare type AnyColumn = Column<ColumnType, boolean, boolean> | IndexedColumn<ColumnType, boolean, boolean>;
+export declare type PartialFor<TTable extends AbstractTable<TTable>> = {
+    [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, TTable>;
+};
+export declare type FullOrPartial<TTable extends AbstractTable<TTable>, TPartial extends PartialFor<TTable>> = [keyof TPartial] extends [never] ? ExtractModel<TTable> : ExtractModel<TPartial>;
+export declare type CheckTwoTypes<TInput, TTable extends AbstractTable<TTable>, TTable1 extends AbstractTable<TTable1>> = TInput extends AbstractTable<TTable> ? TTable : TInput extends AbstractTable<TTable1> ? TTable1 : never;
+export declare 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 declare 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 declare 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/dist/tables/inferTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/tables/migrationsTable.d.ts

@@ -0,0 +1,7 @@
+import AbstractTable from './abstractTable';
+export default class MigrationsTable extends AbstractTable<MigrationsTable> {
+    id: import("..").Column<import("../columns/types/pgSerial").default, true, true, this>;
+    hash: import("..").Column<import("..").PgText, false, false, this>;
+    createdAt: import("..").Column<import("..").PgBigInt, true, false, this>;
+    tableName(): string;
+}

package/dist/tables/migrationsTable.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const abstractTable_1 = __importDefault(require("./abstractTable"));
+class MigrationsTable extends abstractTable_1.default {
+    constructor() {
+        super(...arguments);
+        this.id = this.serial('id').primaryKey();
+        this.hash = this.text('hash').notNull();
+        this.createdAt = this.bigint('created_at', 'max_bytes_53');
+    }
+    tableName() {
+        return 'drizzle_migrations';
+    }
+}
+exports.default = MigrationsTable;

package/dist/test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const static_1 = require("./builders/requestBuilders/where/static");
+const dbConnector_1 = __importDefault(require("./db/dbConnector"));
+const citiesTable_1 = __importDefault(require("./docs/tables/citiesTable"));
+const usersTable_1 = __importDefault(require("./docs/tables/usersTable"));
+const consoleLogger_1 = __importDefault(require("./logger/consoleLogger"));
+(async () => {
+    try {
+        const db = await new dbConnector_1.default()
+            .connectionString('postgresql://postgres@127.0.0.1/migrator')
+            .connect();
+        const usersTable = new usersTable_1.default(db);
+        const citiesTable = new citiesTable_1.default(db);
+        db.useLogger(new consoleLogger_1.default());
+        const phone = undefined;
+        const res = await usersTable.update()
+            // .groupBy((table, join1, join2, join3) => [table.id, join1.id, join1.phone])
+            .where(static_1.eq(usersTable.id, 16))
+            .set({
+            phone,
+        })
+            // .leftJoin(CitiesTable, UsersTable, (table) => table.userId, (table) => table.id)
+            // .leftJoin(UsersTable, UsersTable, (table) => table.id, (table) => table.id)
+            .execute();
+        // const ser = new MigrationSerializer();
+        // const res = ser.generate([usersTable as AbstractTable<UsersTable>], []);
+        // console.log(JSON.stringify(res, null, 2));
+        // const f = {
+        //   id: count(usersTable.id),
+        // };
+        // type d = ExtractModel<typeof f>;
+        // const res = await usersTable.select({
+        //   piska: count(),
+        //   mongodibil: count(usersTable.phone),
+        // })
+        //   .where({
+        //     piska: eq(),
+        //     mongodibil: eq(usersTable.phone),
+        //   }).leftJoin(UsersTable, (table) => table.id, (table) => table.id)
+        //   .leftJoin(UsersTable, UsersTable, (table) => table.id, (table) => table.id)
+        //   .groupBy((table, join1, join2, join3) => [table.id, join1.id, join1.phone])
+        //   .orderBy((table, join1, join2, join3) => [{table.id}, join1.id, join1.phone])
+        //   .execute();
+        // const res = await usersTable.select()
+        //   // .groupBy((table, join1, join2, join3) => [table.id, join1.id, join1.phone])
+        //   .leftJoin(UsersTable, (table) => table.foundationDate, (table) => table.id)
+        //   .leftJoin(UsersTable, UsersTable, (table) => table.role, (table) => table.id)
+        //   .leftJoin(UsersTable, UsersTable, (table) => table.role, (table) => table.id)
+        //   // .groupBy({
+        //   //   usersTable: usersTable.id,
+        //   //   firstJoin: [usersTable.id],
+        //   //   secondJoin: usersTable.id,
+        //   //   thirdJoin: usersTable.id,
+        //   // })
+        //   .execute();
+        // console.log(res);
+    }
+    catch (e) {
+        console.log(e);
+    }
+})();

package/dist/types/type.d.ts

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