drizzle-orm 0.9.0 → 0.9.4

package/migrator/migrator.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationSession = void 0;
+/* eslint-disable import/export */
+/* eslint-disable max-classes-per-file */
+const create_1 = require("../builders/lowLvlBuilders/create");
+const transaction_1 = require("../builders/transaction/transaction");
+const migrationsTable_1 = require("../tables/migrationsTable");
+class MigrationSession {
+    constructor() {
+        this.finalQuery = '';
+        this.execute = (query) => {
+            this.finalQuery += query;
+            this.finalQuery += '\n';
+        };
+        this.getQuery = () => this.finalQuery;
+    }
+}
+exports.MigrationSession = MigrationSession;
+class Migrator {
+    constructor(db) {
+        this.migrationsPerVersion = new Map();
+        this.chain = (tag, migration) => {
+            const migrationSession = new MigrationSession();
+            migration(migrationSession);
+            this.migrationsPerVersion.set(+tag, migrationSession.getQuery());
+            return this;
+        };
+        this.getResultScript = () => {
+            const values = [];
+            // eslint-disable-next-line no-restricted-syntax
+            for (const value of this.migrationsPerVersion.values()) {
+                values.push(value);
+            }
+            return values;
+        };
+        this.execute = async () => {
+            const migrationsTable = new migrationsTable_1.default(this._db);
+            await this.session.execute(create_1.default.table(migrationsTable).build());
+            const migrations = await migrationsTable.select().all();
+            const transaction = new transaction_1.default(this.session);
+            await transaction.begin();
+            // eslint-disable-next-line no-restricted-syntax
+            for await (const [key, value] of this.migrationsPerVersion) {
+                const dbMigrationByTag = migrations.find((it) => it.version === key);
+                if (dbMigrationByTag) {
+                    // const isHashSameAsInDb =
+                    // Buffer.from(dbMigrationByTag.hash, 'base64').toString('ascii') === value;
+                    // if (!isHashSameAsInDb) {
+                    //   throw Error(`Migration script was changed for version ${key}`);
+                    // }
+                }
+                else {
+                    try {
+                        const logger = this._db.logger();
+                        if (logger) {
+                            logger.info(`Executing migration with tag ${key} with query:\n${value}`);
+                        }
+                        const result = await this._db.session().execute(value);
+                        if (result.isLeft()) {
+                            const { reason } = result.value;
+                            throw new Error(`Error while executing migration tag ${key}. Error: ${reason}`);
+                        }
+                        else {
+                            await migrationsTable
+                                .insert({
+                                version: key,
+                                createdAt: new Date(),
+                                hash: Buffer.from(value).toString('base64'),
+                            }).execute();
+                        }
+                    }
+                    catch (e) {
+                        await transaction.rollback();
+                        throw new Error(`Migration chain ${key} was not migrated sucessfully.\nMessage: ${e.message}`);
+                    }
+                }
+            }
+            await transaction.commit();
+            return true;
+        };
+        this._db = db;
+        this.session = db.session();
+    }
+    generateHash(value) {
+        let hash = 0;
+        let i;
+        let chr;
+        if (value.length === 0)
+            return hash;
+        for (i = 0; i < value.length; i += 1) {
+            chr = value.charCodeAt(i);
+            // eslint-disable-next-line no-bitwise
+            hash = ((hash << 5) - hash) + chr;
+            // eslint-disable-next-line no-bitwise
+            hash |= 0;
+        }
+        return hash;
+    }
+}
+exports.default = Migrator;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drizzle-orm",
-  "version": "0.9.0",
+  "version": "0.9.4",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -32,7 +32,7 @@
     "typescript": "^4.2.4"
   },
   "dependencies": {
-    "@types/pg": "^7.14.11",
+    "@types/pg": "^8.6.1",
     "pg": "^8.6.0"
   }
 }

package/serializer/serializer.d.ts

@@ -0,0 +1,40 @@
+import { AbstractTable } from '../tables';
+import Enum from '../types/type';
+interface ColumnAsObject {
+    [name: string]: {
+        name?: string;
+        type?: string;
+        primaryKey?: boolean;
+        unique?: boolean;
+        onDelete?: string;
+        onUpdate?: string;
+        default?: any;
+        notNull?: boolean;
+        references?: {
+            table: string;
+            column: string;
+        };
+    };
+}
+interface TableAsObject {
+    [name: string]: {
+        name: string;
+        columns: ColumnAsObject;
+        indexes: {
+            [name: string]: {
+                name?: string;
+                type?: string;
+            };
+        };
+    };
+}
+export default class MigrationSerializer {
+    generate: (tables: AbstractTable<any>[], enums: Enum<any>[]) => {
+        version: string;
+        tables: TableAsObject;
+        enums: {
+            [key: string]: Enum<any>;
+        };
+    };
+}
+export {};

package/serializer/serializer.js

@@ -0,0 +1,74 @@
+"use strict";
+/* 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 */
+Object.defineProperty(exports, "__esModule", { value: true });
+const columns_1 = require("../columns");
+const tableIndex_1 = require("../indexes/tableIndex");
+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 key = properties[0];
+                    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,
+                        };
+                    }
+                    if (value instanceof columns_1.Column) {
+                        columnToReturn[key] = {
+                            name: value.getColumnName(),
+                            type: value.isAutoIncrement() ? 'serial' : value.getColumnType().getDbName(),
+                            primaryKey: !!value.primaryKeyName,
+                            onDelete: value.getOnDelete(),
+                            onUpdate: value.getOnUpdate(),
+                            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.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: '1', tables: result, enums: enumsToReturn };
+        };
+    }
+}
+exports.default = MigrationSerializer;

package/tables/abstractTable.d.ts

@@ -0,0 +1,118 @@
+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 PgBigInt 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';
+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({ limit, offset }?: {
+        limit?: number;
+        offset?: number;
+    }): SelectTRB<TTable>;
+    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;
+        notNull: false;
+    }): Column<PgVarChar, true>;
+    protected varchar(name: string, params: {
+        size?: number;
+        notNull: true;
+    }): Column<PgVarChar, false>;
+    protected varchar(name: string, params?: {
+        size?: number;
+        notNull?: false;
+    }): Column<PgVarChar, true>;
+    protected varchar(name: string, params: {
+        size?: number;
+        notNull?: true;
+    }): Column<PgVarChar, false>;
+    protected int(name: string, params?: {
+        notNull: false;
+    }): Column<PgInteger, true>;
+    protected int(name: string, params: {
+        notNull: true;
+    }): Column<PgInteger, false>;
+    protected timestamp(name: string, params?: {
+        notNull: false;
+    }): Column<PgTimestamp, true>;
+    protected timestamp(name: string, params: {
+        notNull: true;
+    }): Column<PgTimestamp, false>;
+    protected bigint(name: string, params?: {
+        notNull: false;
+    }): Column<PgBigInt, true>;
+    protected bigint(name: string, params: {
+        notNull: true;
+    }): Column<PgBigInt, false>;
+    protected type<ETtype extends string>(typeEnum: Enum<ETtype>, name: string, params?: {
+        notNull: false;
+    }): Column<PgEnum<ExtractEnumValues<Enum<ETtype>>>, true>;
+    protected type<ETtype extends string>(typeEnum: Enum<ETtype>, name: string, params: {
+        notNull: true;
+    }): Column<PgEnum<ExtractEnumValues<Enum<ETtype>>>, false>;
+    protected decimal(name: string, params?: {
+        notNull: false;
+        precision: number;
+        scale: number;
+    }): Column<PgBigDecimal, true>;
+    protected decimal(name: string, params: {
+        notNull: true;
+        precision: number;
+        scale: number;
+    }): Column<PgBigDecimal, false>;
+    protected time(name: string, params?: {
+        notNull: false;
+    }): Column<PgTime, true>;
+    protected time(name: string, params: {
+        notNull: true;
+    }): Column<PgTime, false>;
+    protected bool(name: string, params?: {
+        notNull: false;
+    }): Column<PgBoolean, true>;
+    protected bool(name: string, params: {
+        notNull: true;
+    }): Column<PgBoolean, false>;
+    protected text(name: string, params?: {
+        notNull: false;
+    }): Column<PgText, true>;
+    protected text(name: string, params: {
+        notNull: true;
+    }): Column<PgText, false>;
+    protected jsonb<TSubType>(name: string, params?: {
+        notNull: false;
+    }): Column<PgJsonb<TSubType>, true>;
+    protected jsonb<TSubType>(name: string, params: {
+        notNull: true;
+    }): Column<PgJsonb<TSubType>, false>;
+}

package/tables/abstractTable.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pgVarChar_1 = require("../columns/types/pgVarChar");
+const pgTimestamp_1 = require("../columns/types/pgTimestamp");
+const pgInteger_1 = require("../columns/types/pgInteger");
+const pgBigDecimal_1 = require("../columns/types/pgBigDecimal");
+const pgTime_1 = require("../columns/types/pgTime");
+const pgBoolean_1 = require("../columns/types/pgBoolean");
+const pgText_1 = require("../columns/types/pgText");
+const pgJsonb_1 = require("../columns/types/pgJsonb");
+const insertRequestBuilder_1 = require("../builders/highLvlBuilders/insertRequestBuilder");
+const deleteRequestBuilder_1 = require("../builders/highLvlBuilders/deleteRequestBuilder");
+const updateRequestBuilder_1 = require("../builders/highLvlBuilders/updateRequestBuilder");
+const selectRequestBuilder_1 = require("../builders/highLvlBuilders/selectRequestBuilder");
+const pgBigInt_1 = require("../columns/types/pgBigInt");
+const pgEnum_1 = require("../columns/types/pgEnum");
+const column_1 = require("../columns/column");
+const tableIndex_1 = require("../indexes/tableIndex");
+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;
+    }
+    select({ limit, offset } = {}) {
+        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(), { limit, offset }, this, this._logger);
+    }
+    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]);
+    }
+    varchar(name, params = {}) {
+        var _a;
+        return new column_1.Column(this, name, new pgVarChar_1.default(params.size), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    }
+    int(name, params = {}) {
+        var _a;
+        return new column_1.Column(this, name, new pgInteger_1.default(), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    }
+    timestamp(name, params = {}) {
+        var _a;
+        return new column_1.Column(this, name, new pgTimestamp_1.default(), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    }
+    bigint(name, params = {}) {
+        var _a;
+        return new column_1.Column(this, name, new pgBigInt_1.default(), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    }
+    type(typeEnum, name, params = {}) {
+        var _a;
+        const pgEnum = new pgEnum_1.default(typeEnum.name);
+        return new column_1.Column(this, name, pgEnum, (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    }
+    decimal(name, params = {}) {
+        var _a;
+        return new column_1.Column(this, name, new pgBigDecimal_1.default(params.precision, params.scale), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    }
+    time(name, params = {}) {
+        var _a;
+        return new column_1.Column(this, name, new pgTime_1.default(), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    }
+    bool(name, params = {}) {
+        var _a;
+        return new column_1.Column(this, name, new pgBoolean_1.default(), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    }
+    text(name, params = {}) {
+        var _a;
+        return new column_1.Column(this, name, new pgText_1.default(), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    }
+    jsonb(name, params = {}) {
+        var _a;
+        return new column_1.Column(this, name, new pgJsonb_1.default(), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    }
+}
+exports.default = AbstractTable;

package/tables/index.js

@@ -0,0 +1,8 @@
+"use strict";
+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 migrationsTable_1.default; } });
+var abstractTable_1 = require("./abstractTable");
+Object.defineProperty(exports, "AbstractTable", { enumerable: true, get: function () { return abstractTable_1.default; } });

package/tables/inferTypes.d.ts

@@ -0,0 +1,19 @@
+import { AbstractColumn, Column, IndexedColumn } from '../columns/column';
+import ColumnType from '../columns/types/columnType';
+import TableIndex from '../indexes/tableIndex';
+import Type from '../types/type';
+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 ExtractModel<TTable> = {
+    [Key in ExtractFieldNames<TTable>]: ExtractCodeType<TTable[Key]>;
+} & {
+    [Key in ExtractOptionalFieldNames<TTable>]?: ExtractCodeType<TTable[Key]>;
+};
+export declare type ExtractCodeType<T extends AbstractColumn<ColumnType<any>, boolean, boolean>> = T extends AbstractColumn<ColumnType<infer TCodeType>, infer TNullable, infer TAutoIncrement> ? 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>;

package/tables/inferTypes.js

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

package/tables/migrationsTable.d.ts

@@ -0,0 +1,8 @@
+import AbstractTable from './abstractTable';
+export default class MigrationsTable extends AbstractTable<MigrationsTable> {
+    id: import("../columns/column").IndexedColumn<import("..").PgInteger, true, true>;
+    version: import("..").Column<import("..").PgInteger, false, false>;
+    hash: import("..").Column<import("..").PgText, true, false>;
+    createdAt: import("..").Column<import("..").PgTimestamp, true, false>;
+    tableName(): string;
+}

package/tables/migrationsTable.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const abstractTable_1 = require("./abstractTable");
+class MigrationsTable extends abstractTable_1.default {
+    constructor() {
+        super(...arguments);
+        this.id = this.int('id').autoIncrement().primaryKey();
+        this.version = this.int('version', { notNull: true }).unique();
+        this.hash = this.text('hash');
+        this.createdAt = this.timestamp('created_at');
+    }
+    tableName() {
+        return 'migrations';
+    }
+}
+exports.default = MigrationsTable;

package/test.d.ts

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

package/test.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = require(".");
+const usersTable_1 = require("./docs/tables/usersTable");
+const serializer_1 = require("./serializer/serializer");
+// import { Pool } from 'pg';
+// import { DB } from '.';
+// import { DB, DbConnector } from '.';
+// import Enum from './types/type';
+const fromTypeFile = (filepath) => {
+    // const db = new DB(new Pool());
+    const importedEnum = require(filepath);
+    const res = [];
+    // eslint-disable-next-line no-restricted-syntax
+    for (const type of Object.keys(importedEnum)) {
+        res.push(importedEnum[type]);
+    }
+    return res;
+};
+(async () => {
+    try {
+        const db = await new _1.DbConnector()
+            .connectionString('postgresql://postgres@127.0.0.1/drizzle')
+            .connect();
+        const ser = new serializer_1.default();
+        const d = db.create(usersTable_1.default);
+        const f = ser.generate([d], []);
+        console.log(JSON.stringify(f, null, 2));
+        // const typesFileNames = fs.readdirSync('/Users/andrewsherman/IdeaProjects/datalayer-orm/src/examples/types');
+        // typesFileNames.forEach((filename) => {
+        //   const types = fromTypeFile(`./examples/types/${filename.split('.')[0]}`);
+        //   const typeValues = types[0].values;
+        //   console.log(typeValues);
+        //   // console.log(Object.values(typeValues));
+        // });
+        // // const usersTest = new UsersTest();
+        // // await usersTest.execute();
+        // const db = await new DbConnector()
+        //   .connectionString('postgresql://postgres@127.0.0.1/drizzle')
+        //   .connect();
+        // const res = await db.session().execute(
+        //   Create.table(db.create(UsersTable)).build(),
+        // );
+        // if (res.isLeft()) {
+        //   console.log(res.value.reason);
+        // } else {
+        //   console.log(res.value);
+        // }
+        // const userTable = new UsersTable(db);
+        // const citiesTable = new CitiesTable(db);
+        // const uni = new UniJoin(userTable).innerJoin(
+        //   UsersTable,
+        //   (table) => table.id,
+        //   (t) => t.id,
+        // );
+        // Inner.join1(
+        //   { table: CitiesTable, column: ((table) => table.id), on: ((table) => table.userId1) },
+        // );
+        // const res = await userTable.select().leftJoin(
+        //   UsersTable,
+        //   (table) => table.id,
+        //   (t) => t.id,
+        // ).execute();
+        // const d = await userTable
+        //   .insert({ phone: 'phone1', createdAt: new Date(), role: 'foo' }).all();
+        // const all = await userTable.select().all();
+        // console.log(all[1]?.role);
+        // console.log(typeof d[0]?.role);
+        // const users = await userTable.update()
+        //   .where(eq(userTable.id, 1))
+        //   .set({
+        //     phone: 'dsdf',
+        //     createdAt: new Date(),
+        //   })
+        //   .all();
+        // console.log(users);
+    }
+    catch (e) {
+        console.log(e);
+    }
+})();

package/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>;

package/types/type.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEnum = void 0;
+class Enum {
+    constructor(name, values) {
+        this.name = name;
+        this.values = values;
+    }
+}
+exports.default = Enum;
+function createEnum({ alias, values }) {
+    return new Enum(alias, values);
+}
+exports.createEnum = createEnum;

package/utils/ecranate.d.ts

@@ -0,0 +1,2 @@
+export declare const ecranate: (data: string) => string;
+export declare const shouldEcranate: (value: any) => boolean;

package/utils/ecranate.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldEcranate = exports.ecranate = void 0;
+const ecranate = (data) => `"${data}"`;
+exports.ecranate = ecranate;
+const shouldEcranate = (value) => typeof value === 'string'
+    || value instanceof Date || value === Object(value);
+exports.shouldEcranate = shouldEcranate;