drizzle-orm 0.10.21 → 0.10.24

package/dist/src/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: number): number | undefined;
+}

package/dist/src/columns/types/pgInteger.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const columnType_1 = __importDefault(require("./columnType"));
+class PgInteger extends columnType_1.default {
+    constructor() {
+        super();
+        this.getDbName = () => this.dbName;
+        this.insertStrategy = (value) => `${value}`;
+        this.dbName = 'INT';
+    }
+    selectStrategy(value) {
+        if (typeof value === 'string') {
+            return value ? parseInt(value, 10) : undefined;
+        }
+        return value;
+    }
+}
+exports.default = PgInteger;

package/dist/src/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/dist/src/columns/types/pgJsonb.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable max-len */
+const columnType_1 = __importDefault(require("./columnType"));
+class PgJsonb extends columnType_1.default {
+    constructor() {
+        super();
+        this.getDbName = () => this.dbName;
+        // public insertStrategy = (value: TCodeType): string => `'${JSON.stringify(value).replace(/'/g, "''")}'::jsonb`;
+        this.insertStrategy = (value) => `${JSON.stringify(value).replace(/'/g, "''")}`;
+        this.dbName = 'JSONB';
+    }
+    selectStrategy(value) {
+        return value;
+    }
+}
+exports.default = PgJsonb;

package/dist/src/columns/types/pgSerial.d.ts

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

package/dist/src/columns/types/pgSerial.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 columnType_1 = __importDefault(require("./columnType"));
+class PgSerial extends columnType_1.default {
+    constructor() {
+        super();
+        this.getDbName = () => this.dbName;
+        this.insertStrategy = (value) => `${value}`;
+        this.dbName = 'SERIAL';
+    }
+    selectStrategy(value) {
+        return value;
+    }
+}
+exports.default = PgSerial;

package/dist/src/columns/types/pgSmallInt.d.ts

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

package/dist/src/columns/types/pgSmallInt.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 columnType_1 = __importDefault(require("./columnType"));
+class PgSmallInt extends columnType_1.default {
+    constructor() {
+        super();
+        this.getDbName = () => this.dbName;
+        this.insertStrategy = (value) => `${value}`;
+        this.dbName = 'SMALLINT';
+    }
+    selectStrategy(value) {
+        return value;
+    }
+}
+exports.default = PgSmallInt;

package/dist/src/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/dist/src/columns/types/pgText.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 columnType_1 = __importDefault(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/dist/src/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/dist/src/columns/types/pgTime.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 columnType_1 = __importDefault(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/dist/src/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/dist/src/columns/types/pgTimestamp.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 columnType_1 = __importDefault(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/dist/src/columns/types/pgTimestamptz.d.ts

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

package/dist/src/columns/types/pgTimestamptz.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 columnType_1 = __importDefault(require("./columnType"));
+class PgTimestamptz extends columnType_1.default {
+    constructor() {
+        super();
+        this.getDbName = () => this.dbName;
+        this.insertStrategy = (value) => `${value.toISOString()}`;
+        this.dbName = 'timestamp with time zone';
+    }
+    selectStrategy(value) {
+        return value;
+    }
+}
+exports.default = PgTimestamptz;

package/dist/src/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/dist/src/columns/types/pgVarChar.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const columnType_1 = __importDefault(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/dist/src/db/db.d.ts

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

package/dist/src/db/db.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DB {
+    constructor(session) {
+        this._cache = new Map();
+        this.useLogger = (logger) => {
+            this._logger = logger;
+        };
+        this.cache = () => this._cache;
+        this.logger = () => this._logger;
+        this.session = () => this._session;
+        this._session = session;
+    }
+    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/dist/src/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/dist/src/db/dbConnector.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pg_1 = require("pg");
+const db_1 = __importDefault(require("./db"));
+const dbStringConnector_1 = __importDefault(require("./dbStringConnector"));
+const session_1 = __importDefault(require("./session"));
+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(new session_1.default(pool));
+            }
+            catch (e) {
+                // console.log(`Connection error: ${e.message}`);
+                throw new Error(`Connection error: ${e.message}`);
+            }
+        };
+    }
+}
+exports.default = DbConnector;

package/dist/src/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/dist/src/db/dbStringConnector.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pg_1 = require("pg");
+const db_1 = __importDefault(require("./db"));
+const session_1 = __importDefault(require("./session"));
+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(new session_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/dist/src/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/dist/src/db/index.d.ts

@@ -0,0 +1,4 @@
+export { default as DB } from './db';
+export { default as DbConnector } from './dbConnector';
+export { default as DBStringConnector } from './dbStringConnector';
+export { ISession } from './session';

package/dist/src/db/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISession = exports.DBStringConnector = exports.DbConnector = exports.DB = void 0;
+var db_1 = require("./db");
+Object.defineProperty(exports, "DB", { enumerable: true, get: function () { return __importDefault(db_1).default; } });
+var dbConnector_1 = require("./dbConnector");
+Object.defineProperty(exports, "DbConnector", { enumerable: true, get: function () { return __importDefault(dbConnector_1).default; } });
+var dbStringConnector_1 = require("./dbStringConnector");
+Object.defineProperty(exports, "DBStringConnector", { enumerable: true, get: function () { return __importDefault(dbStringConnector_1).default; } });
+var session_1 = require("./session");
+Object.defineProperty(exports, "ISession", { enumerable: true, get: function () { return session_1.ISession; } });

package/dist/src/db/session.d.ts

@@ -0,0 +1,9 @@
+import { Pool, QueryResult } from 'pg';
+export declare abstract class ISession {
+    abstract execute(query: string, values?: Array<any>): Promise<QueryResult<any>>;
+}
+export default class Session extends ISession {
+    private pool;
+    constructor(pool: Pool);
+    execute(query: string, values?: Array<any>): Promise<QueryResult<any>>;
+}

package/dist/src/db/session.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISession = void 0;
+class ISession {
+}
+exports.ISession = ISession;
+class Session extends ISession {
+    constructor(pool) {
+        super();
+        this.pool = pool;
+    }
+    async execute(query, values) {
+        return this.pool.query(query, values || []);
+    }
+}
+exports.default = Session;

package/dist/src/docs/cases/simple_delete.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const __1 = require("../..");
+const builders_1 = require("../../builders");
+const consoleLogger_1 = __importDefault(require("../../logger/consoleLogger"));
+const citiesTable_1 = __importDefault(require("../tables/citiesTable"));
+const userGroupsTable_1 = __importDefault(require("../tables/userGroupsTable"));
+const usersTable_1 = __importDefault(require("../tables/usersTable"));
+(async () => {
+    try {
+        const db = await new __1.DbConnector()
+            .connectionString('postgresql://postgres@127.0.0.1/migrator')
+            .connect();
+        db.useLogger(new consoleLogger_1.default());
+        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, 6))
+            .execute();
+        const deletedCities = await citiesTable.delete()
+            .where(builders_1.eq(citiesTable.id, 7))
+            .all();
+        const deletedUserGroup = await userGroupsTable.delete()
+            .where(builders_1.eq(userGroupsTable.id, 3))
+            .findOne();
+    }
+    catch (e) {
+        console.log(e);
+    }
+})();

package/dist/src/docs/cases/simple_insert.d.ts

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

package/dist/src/docs/cases/simple_insert.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dbConnector_1 = __importDefault(require("../../db/dbConnector"));
+const consoleLogger_1 = __importDefault(require("../../logger/consoleLogger"));
+const citiesTable_1 = __importDefault(require("../tables/citiesTable"));
+const userGroupsTable_1 = __importDefault(require("../tables/userGroupsTable"));
+const usersTable_1 = __importDefault(require("../tables/usersTable"));
+(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);
+        const userGroupsTable = new userGroupsTable_1.default(db);
+        // await db.session().execute(Create.table(usersTable).build());
+        // await db.session().execute(Create.table(citiesTable).build());
+        // await db.session().execute(Create.table(userGroupsTable).build());
+        db.useLogger(new consoleLogger_1.default());
+        await usersTable.insert({
+            decimalField: 12.4,
+            createdAt: new Date(),
+            role: 'foo',
+        }).execute();
+        const insertedCities = await citiesTable.insert({
+            foundationDate: new Date(),
+        }).all();
+        const insertedUserGroup = await userGroupsTable.insert({
+            name: 'firstGroup',
+        }).findOne();
+        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: 'foo',
+            }, {
+                decimalField: 32.4,
+                createdAt: new Date(),
+                role: 'foo',
+                phone: '+1808',
+            }])
+            .onConflict((table) => table.phoneIndex, { isArchived: true }).all();
+    }
+    catch (e) {
+        console.log(e);
+    }
+})();

package/dist/src/docs/cases/simple_join.d.ts

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