drizzle-orm 0.9.0 → 0.9.4

package/columns/types/pgBoolean.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const columnType_1 = require("./columnType");
+class PgBoolean extends columnType_1.default {
+    constructor() {
+        super();
+        this.getDbName = () => this.dbName;
+        this.insertStrategy = (value) => `${value}`;
+        this.dbName = 'boolean';
+    }
+    selectStrategy(value) {
+        return value;
+    }
+}
+exports.default = PgBoolean;

package/columns/types/pgEnum.d.ts

@@ -0,0 +1,9 @@
+import ColumnType from './columnType';
+export default class PgEnum<TCodeType> extends ColumnType {
+    codeType: TCodeType;
+    dbName: string;
+    constructor(dbName: string);
+    getDbName: () => string;
+    insertStrategy: (value: TCodeType) => string;
+    selectStrategy(value: any): TCodeType;
+}

package/columns/types/pgEnum.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const columnType_1 = require("./columnType");
+class PgEnum extends columnType_1.default {
+    constructor(dbName) {
+        super();
+        this.getDbName = () => this.dbName;
+        this.insertStrategy = (value) => `'${value}'`;
+        this.dbName = dbName;
+    }
+    selectStrategy(value) {
+        return value;
+    }
+}
+exports.default = PgEnum;

package/columns/types/pgInteger.d.ts

@@ -0,0 +1,8 @@
+import ColumnType from './columnType';
+export default class PgInteger extends ColumnType<number> {
+    dbName: string;
+    constructor();
+    getDbName: () => string;
+    insertStrategy: (value: number) => string;
+    selectStrategy(value: string): number;
+}

package/columns/types/pgInteger.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const columnType_1 = require("./columnType");
+class PgInteger extends columnType_1.default {
+    constructor() {
+        super();
+        this.getDbName = () => this.dbName;
+        this.insertStrategy = (value) => `${value}`;
+        this.dbName = 'INT';
+    }
+    selectStrategy(value) {
+        return parseInt(value, 10);
+    }
+}
+exports.default = PgInteger;

package/columns/types/pgJsonb.d.ts

@@ -0,0 +1,9 @@
+import ColumnType from './columnType';
+export default class PgJsonb<TCodeType> extends ColumnType<TCodeType> {
+    codeType: TCodeType;
+    dbName: string;
+    constructor();
+    getDbName: () => string;
+    insertStrategy: (value: TCodeType) => string;
+    selectStrategy(value: any): TCodeType;
+}

package/columns/types/pgJsonb.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const columnType_1 = require("./columnType");
+class PgJsonb extends columnType_1.default {
+    constructor() {
+        super();
+        this.getDbName = () => this.dbName;
+        this.insertStrategy = (value) => `'${JSON.stringify(value).replace(/'/g, "''")}'::jsonb`;
+        this.dbName = 'JSONB';
+    }
+    selectStrategy(value) {
+        return value;
+    }
+}
+exports.default = PgJsonb;

package/columns/types/pgText.d.ts

@@ -0,0 +1,8 @@
+import ColumnType from './columnType';
+export default class PgText extends ColumnType<string> {
+    protected dbName: string;
+    constructor();
+    getDbName: () => string;
+    insertStrategy: (value: string) => string;
+    selectStrategy(value: string): string;
+}

package/columns/types/pgText.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const columnType_1 = require("./columnType");
+class PgText extends columnType_1.default {
+    constructor() {
+        super();
+        this.getDbName = () => this.dbName;
+        this.insertStrategy = (value) => `'${value.replace(/'/g, "''")}'`;
+        this.dbName = 'TEXT';
+    }
+    selectStrategy(value) {
+        return value;
+    }
+}
+exports.default = PgText;

package/columns/types/pgTime.d.ts

@@ -0,0 +1,8 @@
+import ColumnType from './columnType';
+export default class PgTime extends ColumnType<Date> {
+    dbName: string;
+    constructor();
+    getDbName: () => string;
+    insertStrategy: (value: Date) => string;
+    selectStrategy(value: any): Date;
+}

package/columns/types/pgTime.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const columnType_1 = require("./columnType");
+class PgTime extends columnType_1.default {
+    constructor() {
+        super();
+        this.getDbName = () => this.dbName;
+        this.insertStrategy = (value) => value.toISOString();
+        this.dbName = 'time without time zone';
+    }
+    selectStrategy(value) {
+        return value;
+    }
+}
+exports.default = PgTime;

package/columns/types/pgTimestamp.d.ts

@@ -0,0 +1,8 @@
+import ColumnType from './columnType';
+export default class PgTimestamp extends ColumnType<Date> {
+    dbName: string;
+    constructor();
+    getDbName: () => string;
+    insertStrategy: (value: Date) => string;
+    selectStrategy(value: any): Date;
+}

package/columns/types/pgTimestamp.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const columnType_1 = require("./columnType");
+class PgTimestamp extends columnType_1.default {
+    constructor() {
+        super();
+        this.getDbName = () => this.dbName;
+        this.insertStrategy = (value) => `'${value.toISOString()}'`;
+        this.dbName = 'timestamp without time zone';
+    }
+    selectStrategy(value) {
+        return value;
+    }
+}
+exports.default = PgTimestamp;

package/columns/types/pgVarChar.d.ts

@@ -0,0 +1,9 @@
+import ColumnType from './columnType';
+export default class PgVarChar extends ColumnType<string> {
+    size?: number;
+    protected dbName: string;
+    constructor(size?: number);
+    getDbName: () => string;
+    insertStrategy: (value: string) => string;
+    selectStrategy(value: string): string;
+}

package/columns/types/pgVarChar.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const columnType_1 = require("./columnType");
+class PgVarChar extends columnType_1.default {
+    constructor(size) {
+        super();
+        this.getDbName = () => this.dbName;
+        this.insertStrategy = (value) => `'${value.replace(/'/g, "''")}'`;
+        this.size = size;
+        if (size) {
+            this.dbName = `character varying(${size})`;
+        }
+        else {
+            this.dbName = 'character varying';
+        }
+    }
+    selectStrategy(value) {
+        return value;
+    }
+}
+exports.default = PgVarChar;

package/db/db.d.ts

@@ -0,0 +1,19 @@
+import { Pool } from 'pg';
+import BaseLogger from '../logger/abstractLogger';
+import { AbstractTable } from '../tables';
+import Session from './session';
+export declare type TableConstructor = {
+    new (db: DB): AbstractTable<any>;
+};
+export default class DB {
+    private _session;
+    private _logger?;
+    private _cache;
+    constructor(pool: Pool);
+    create<TTable extends AbstractTable<TTable>>(t: new (db: DB) => TTable): TTable;
+    useLogger: (logger: BaseLogger) => void;
+    cache: () => Map<TableConstructor, AbstractTable<any>>;
+    logger: () => BaseLogger | undefined;
+    session: () => Session;
+    protected instanceFor<TTable extends AbstractTable<TTable>>(t: new (db: DB) => TTable): AbstractTable<any> | undefined;
+}

package/db/db.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const session_1 = require("./session");
+class DB {
+    constructor(pool) {
+        this._cache = new Map();
+        this.useLogger = (logger) => {
+            this._logger = logger;
+        };
+        this.cache = () => this._cache;
+        this.logger = () => this._logger;
+        this.session = () => this._session;
+        this._session = new session_1.default(pool);
+    }
+    create(t) {
+        if (!this._cache.has(t)) {
+            // eslint-disable-next-line new-cap
+            this._cache.set(t, new t(this));
+        }
+        return this._cache.get(t);
+    }
+    instanceFor(t) {
+        return this._cache.get(t);
+    }
+}
+exports.default = DB;

package/db/dbConnector.d.ts

@@ -0,0 +1,9 @@
+import { ClientConfig } from 'pg';
+import DB from './db';
+import DBStringConnector from './dbStringConnector';
+export default class DbConnector {
+    private __config;
+    connectionString: (url: string) => DBStringConnector;
+    params: (config: ClientConfig) => DbConnector;
+    connect: () => Promise<DB>;
+}

package/db/dbConnector.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pg_1 = require("pg");
+const db_1 = require("./db");
+const dbStringConnector_1 = require("./dbStringConnector");
+class DbConnector {
+    constructor() {
+        this.connectionString = (url) => new dbStringConnector_1.default(url);
+        this.params = (config) => {
+            this.__config = config;
+            return this;
+        };
+        this.connect = async () => {
+            try {
+                const pool = new pg_1.Pool(this.__config);
+                await pool.connect();
+                // console.log('Db connected!');
+                // check if table structure is the same as in code
+                return new db_1.default(pool);
+            }
+            catch (e) {
+                // console.log(`Connection error: ${e.message}`);
+                throw new Error(`Connection error: ${e.message}`);
+            }
+        };
+    }
+}
+exports.default = DbConnector;

package/db/dbStringConnector.d.ts

@@ -0,0 +1,6 @@
+import Db from './db';
+export default class DBStringConnector {
+    private _url;
+    constructor(url: string);
+    connect: () => Promise<Db>;
+}

package/db/dbStringConnector.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pg_1 = require("pg");
+const db_1 = require("./db");
+class DBStringConnector {
+    constructor(url) {
+        this.connect = async () => {
+            const config = {
+                connectionString: this._url,
+            };
+            try {
+                const pool = new pg_1.Pool(config);
+                await pool.connect();
+                // console.log('Db connected!');
+                return new db_1.default(pool);
+            }
+            catch (e) {
+                // console.log(`Connection error: ${e.message}`);
+                throw new Error(`Connection error: ${e.message}`);
+            }
+        };
+        this._url = url;
+    }
+}
+exports.default = DBStringConnector;

package/db/group_by.js

@@ -0,0 +1,68 @@
+"use strict";
+// const _groupBy = <T, K extends keyof any>(list: T[], getKey: (item: T) => K) => {
+//   list.reduce((previous, currentItem) => {
+//     const group = getKey(currentItem);
+//     // eslint-disable-next-line no-param-reassign
+//     if (!previous[group]) previous[group] = [];
+//     previous[group].push(currentItem);
+//     return previous;
+//   }, {} as Record<K, T[]>);
+// };
+// const groupBy = (xs, key) => xs.reduce((rv, x) => {
+//   (rv[x[key]] = rv[x[key]] || []).push(x);
+//   return rv;
+// }, {});
+// interface Mapp {
+//   [key: string]: any;
+// }
+// const groupBy1 = <K, V>(list: Array<K>, keyGetter: (input: V) => K): Map<K, Array<V>> => {
+//   const map = new Map<K, Array<V>>();
+//   list.forEach((item) => {
+//     const key = keyGetter(item as unknown as V);
+//     const collection = map.get(key);
+//     console.log(collection);
+//     console.log(map.has(key));
+//     if (!collection) {
+//       map.set(key, [item as unknown as V]);
+//     } else {
+//       collection.push(item as unknown as V);
+//     }
+//   });
+//   return map;
+// };
+// interface T1 {
+//   name: string,
+//   key: number
+// }
+// interface T2 {
+//   name: string,
+//   hello: number
+// }
+// interface Person {
+//   t1: T1,
+//   t2: T2
+// }
+// const person: Person[] = [
+//   {
+//     t1: {
+//       name: 'name',
+//       key: 2,
+//     },
+//     t2: {
+//       name: 'name',
+//       hello: 2,
+//     },
+//   },
+//   {
+//     t1: {
+//       name: 'name',
+//       key: 2,
+//     },
+//     t2: {
+//       name: 'name3',
+//       hello: 3,
+//     },
+//   },
+// ];
+// const d = groupBy1(person, (i: Person) => i.t1);
+// console.log(d);

package/db/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DBStringConnector = exports.DbConnector = exports.DB = void 0;
+var db_1 = require("./db");
+Object.defineProperty(exports, "DB", { enumerable: true, get: function () { return db_1.default; } });
+var dbConnector_1 = require("./dbConnector");
+Object.defineProperty(exports, "DbConnector", { enumerable: true, get: function () { return dbConnector_1.default; } });
+var dbStringConnector_1 = require("./dbStringConnector");
+Object.defineProperty(exports, "DBStringConnector", { enumerable: true, get: function () { return dbStringConnector_1.default; } });

package/db/session.d.ts

@@ -0,0 +1,7 @@
+import { Pool, QueryResult } from 'pg';
+import { Either, Failure } from '../errors/baseError';
+export default class Session {
+    private pool;
+    constructor(pool: Pool);
+    execute: (query: string) => Promise<Either<Failure, QueryResult<any>>>;
+}

package/db/session.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const baseError_1 = require("../errors/baseError");
+class Session {
+    constructor(pool) {
+        this.pool = pool;
+        this.execute = async (query) => {
+            try {
+                return baseError_1.right(await this.pool.query(query));
+            }
+            catch (e) {
+                return baseError_1.left({
+                    type: baseError_1.PgSessionError.PgQueryExecutionError,
+                    reason: e,
+                });
+            }
+        };
+    }
+}
+exports.default = Session;

package/docs/cases/simple_delete.d.ts

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

package/docs/cases/simple_delete.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const __1 = require("../..");
+const builders_1 = require("../../builders");
+const citiesTable_1 = require("../tables/citiesTable");
+const userGroupsTable_1 = require("../tables/userGroupsTable");
+const usersTable_1 = require("../tables/usersTable");
+(async () => {
+    try {
+        const db = await new __1.DbConnector()
+            .connectionString('postgresql://postgres@127.0.0.1/drizzle')
+            .connect();
+        const usersTable = new usersTable_1.default(db);
+        const citiesTable = new citiesTable_1.default(db);
+        const userGroupsTable = new userGroupsTable_1.default(db);
+        await usersTable.delete()
+            .where(builders_1.eq(usersTable.id, 1))
+            .execute();
+        const deletedCities = await citiesTable.delete()
+            .where(builders_1.eq(citiesTable.id, 2))
+            .all();
+        const deletedUserGroup = await userGroupsTable.delete()
+            .where(builders_1.eq(userGroupsTable.id, 3))
+            .first();
+    }
+    catch (e) {
+        console.log(e);
+    }
+})();

package/docs/cases/simple_insert.d.ts

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

package/docs/cases/simple_insert.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const __1 = require("../..");
+const citiesTable_1 = require("../tables/citiesTable");
+const userGroupsTable_1 = require("../tables/userGroupsTable");
+const usersTable_1 = require("../tables/usersTable");
+(async () => {
+    try {
+        const db = await new __1.DbConnector()
+            .connectionString('postgresql://postgres@127.0.0.1/drizzle-docs')
+            .connect();
+        const usersTable = new usersTable_1.default(db);
+        const citiesTable = new citiesTable_1.default(db);
+        const userGroupsTable = new userGroupsTable_1.default(db);
+        await db.session().execute(__1.Create.table(usersTable).build());
+        await usersTable.insert({
+            decimalField: 12.4,
+            createdAt: new Date(),
+            role: 'guest',
+        }).execute();
+        const insertedCities = await citiesTable.insert({
+            foundationDate: new Date(),
+        }).all();
+        const insertedUserGroup = await userGroupsTable.insert({
+            name: 'firstGroup',
+        }).first();
+        const manyInsertedCities = await citiesTable.insertMany([{
+                foundationDate: new Date(),
+                location: 'USA',
+            }, {
+                foundationDate: new Date(),
+                location: 'USA',
+                userId: 2,
+            }]).all();
+        const conflictInsertedUsers = await usersTable.insertMany([{
+                decimalField: 12.4,
+                createdAt: new Date(),
+                role: 'guest',
+            }, {
+                decimalField: 32.4,
+                createdAt: new Date(),
+                role: 'admin',
+                phone: '+1808',
+            }])
+            .onConflict((table) => table.phoneIndex, { isArchived: true }).all();
+    }
+    catch (e) {
+        console.log(e);
+    }
+})();

package/docs/cases/simple_join.d.ts

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

package/docs/cases/simple_join.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const __1 = require("../..");
+const builders_1 = require("../../builders");
+const citiesTable_1 = require("../tables/citiesTable");
+const userGroupsTable_1 = require("../tables/userGroupsTable");
+const usersTable_1 = require("../tables/usersTable");
+const usersToUserGroups_1 = require("../tables/usersToUserGroups");
+(async () => {
+    var _a, _b, _c, _d, _e, _f;
+    try {
+        const db = await new __1.DbConnector()
+            .connectionString('postgresql://postgres@127.0.0.1/drizzle-docs')
+            .connect();
+        const usersTable = new usersTable_1.default(db);
+        const citiesTable = new citiesTable_1.default(db);
+        const usersToUserGroupsTable = new usersToUserGroups_1.default(db);
+        const userGroupsTable = new userGroupsTable_1.default(db);
+        await db.session().execute(__1.Create.table(usersTable).build());
+        await db.session().execute(__1.Create.table(citiesTable).build());
+        await db.session().execute(__1.Create.table(userGroupsTable).build());
+        await db.session().execute(__1.Create.table(usersToUserGroupsTable).build());
+        const userRes = await usersTable.insertMany([{
+                decimalField: 4.2,
+                createdAt: new Date(),
+                role: 'guest',
+            }, {
+                decimalField: 5.8,
+                createdAt: new Date(),
+                role: 'user',
+            }]).all();
+        const citiesRes = await citiesTable.insertMany([{
+                foundationDate: new Date(),
+                userId: (_a = userRes[0]) === null || _a === void 0 ? void 0 : _a.id,
+            }, {
+                foundationDate: new Date(),
+                userId: (_b = userRes[1]) === null || _b === void 0 ? void 0 : _b.id,
+            }]).all();
+        const userGroups = await userGroupsTable.insertMany([{
+                name: 'firstGroup',
+            }, {
+                name: 'secondGroup',
+            }]).all();
+        await usersToUserGroupsTable.insertMany([{
+                userId: (_c = userRes[0]) === null || _c === void 0 ? void 0 : _c.id,
+                groupId: (_d = userGroups[0]) === null || _d === void 0 ? void 0 : _d.id,
+            },
+            {
+                userId: (_e = userRes[1]) === null || _e === void 0 ? void 0 : _e.id,
+                groupId: (_f = userGroups[1]) === null || _f === void 0 ? void 0 : _f.id,
+            }]).execute();
+        // map case
+        const userWithCities = await citiesTable.select()
+            .where(builders_1.eq(citiesTable.id, 1))
+            .leftJoin(usersTable_1.default, (city) => city.userId, (users) => users.id)
+            .execute();
+        const citiesWithUserObject = userWithCities.map((city, user) => ({ ...city, user }));
+        // foreach case
+        // const userWithCities1 = await citiesTable.select()
+        //   .where(eq(citiesTable.id, 1))
+        //   .leftJoin(UsersTable,
+        //     (city) => city.userId,
+        //     (users) => users.id)
+        //   .execute();
+        // let user;
+        // const cities = [];
+        // userWithCities.foreach((dbCity, dbUser) => {
+        //   cities.push(dbCity);
+        //   user = dbUser;
+        // });
+        // group case
+        const usersWithUserGroups = await usersToUserGroupsTable.select()
+            .where(builders_1.eq(userGroupsTable.id, 1))
+            .leftJoin(usersTable_1.default, (userToGroup) => userToGroup.userId, (users) => users.id)
+            .leftJoin(userGroupsTable_1.default, (userToGroup) => userToGroup.groupId, (users) => users.id)
+            .execute();
+        const userGroupWithUsers = usersWithUserGroups.group({
+            one: (_, dbUser, dbUserGroup) => dbUser,
+            many: (_, dbUser, dbUserGroup) => dbUserGroup,
+        });
+        const userWithGroups = {
+            ...userGroupWithUsers.one,
+            groups: userGroupWithUsers.many,
+        };
+        // console.log('city', city!);
+        // console.log('cityUsers', cityUsers);
+        // console.log('cityWithUsers', forEachCities);
+        // console.log('cityWithUsers1', forEachUsers);
+        // how to handle many-to-many relations
+    }
+    catch (e) {
+        console.log(e);
+    }
+})();

package/docs/cases/simple_select.d.ts

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