drizzle-orm 0.10.25 → 0.10.28

package/dist/columns/index.d.ts

@@ -0,0 +1,10 @@
+export { Column, ExtractColumnType, Defaults } from './column';
+export { default as PgBigDecimal } from './types/pgBigDecimal';
+export { default as PgBigInt } from './types/pgBigInt';
+export { default as PgBoolean } from './types/pgBoolean';
+export { default as PgInteger } from './types/pgInteger';
+export { default as PgJsonb } from './types/pgJsonb';
+export { default as PgText } from './types/pgText';
+export { default as PgTime } from './types/pgTime';
+export { default as PgTimestamp } from './types/pgTimestamp';
+export { default as PgVarChar } from './types/pgVarChar';

package/dist/columns/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgVarChar = exports.PgTimestamp = exports.PgTime = exports.PgText = exports.PgJsonb = exports.PgInteger = exports.PgBoolean = exports.PgBigInt = exports.PgBigDecimal = exports.Defaults = exports.Column = void 0;
+var column_1 = require("./column");
+Object.defineProperty(exports, "Column", { enumerable: true, get: function () { return column_1.Column; } });
+Object.defineProperty(exports, "Defaults", { enumerable: true, get: function () { return column_1.Defaults; } });
+var pgBigDecimal_1 = require("./types/pgBigDecimal");
+Object.defineProperty(exports, "PgBigDecimal", { enumerable: true, get: function () { return __importDefault(pgBigDecimal_1).default; } });
+var pgBigInt_1 = require("./types/pgBigInt");
+Object.defineProperty(exports, "PgBigInt", { enumerable: true, get: function () { return __importDefault(pgBigInt_1).default; } });
+var pgBoolean_1 = require("./types/pgBoolean");
+Object.defineProperty(exports, "PgBoolean", { enumerable: true, get: function () { return __importDefault(pgBoolean_1).default; } });
+var pgInteger_1 = require("./types/pgInteger");
+Object.defineProperty(exports, "PgInteger", { enumerable: true, get: function () { return __importDefault(pgInteger_1).default; } });
+var pgJsonb_1 = require("./types/pgJsonb");
+Object.defineProperty(exports, "PgJsonb", { enumerable: true, get: function () { return __importDefault(pgJsonb_1).default; } });
+var pgText_1 = require("./types/pgText");
+Object.defineProperty(exports, "PgText", { enumerable: true, get: function () { return __importDefault(pgText_1).default; } });
+var pgTime_1 = require("./types/pgTime");
+Object.defineProperty(exports, "PgTime", { enumerable: true, get: function () { return __importDefault(pgTime_1).default; } });
+var pgTimestamp_1 = require("./types/pgTimestamp");
+Object.defineProperty(exports, "PgTimestamp", { enumerable: true, get: function () { return __importDefault(pgTimestamp_1).default; } });
+var pgVarChar_1 = require("./types/pgVarChar");
+Object.defineProperty(exports, "PgVarChar", { enumerable: true, get: function () { return __importDefault(pgVarChar_1).default; } });

package/dist/columns/types/columnType.d.ts

@@ -0,0 +1,7 @@
+export default abstract class ColumnType<TCodeType = {}> {
+    codeType: TCodeType;
+    protected abstract dbName: string;
+    abstract getDbName(): string;
+    abstract insertStrategy(value: TCodeType): string;
+    abstract selectStrategy(value: any): TCodeType | undefined;
+}

package/dist/columns/types/columnType.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line max-classes-per-file
+class ColumnType {
+}
+exports.default = ColumnType;

package/dist/columns/types/pgBigDecimal.d.ts

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

package/dist/columns/types/pgBigDecimal.js

@@ -0,0 +1,31 @@
+"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 PgBigDecimal extends columnType_1.default {
+    constructor(precision, scale) {
+        super();
+        this.getDbName = () => this.dbName;
+        this.insertStrategy = (value) => `${value}`;
+        this.precision = precision;
+        this.scale = scale;
+        if (this.scale && !this.precision) {
+            throw new Error('In numeric scale should be set up together with precision');
+        }
+        if (this.precision && !this.scale) {
+            this.dbName = `numeric(${this.precision})`;
+        }
+        else if (this.precision && this.scale) {
+            this.dbName = `numeric(${this.precision},${this.scale})`;
+        }
+        else {
+            this.dbName = 'numeric';
+        }
+    }
+    selectStrategy(value) {
+        return value ? parseFloat(value) : undefined;
+    }
+}
+exports.default = PgBigDecimal;

package/dist/columns/types/pgBigInt.d.ts

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

package/dist/columns/types/pgBigInt.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 });
+exports.PgBigInt64 = void 0;
+// eslint-disable-next-line max-classes-per-file
+const columnType_1 = __importDefault(require("./columnType"));
+class PgBigInt53 extends columnType_1.default {
+    constructor() {
+        super();
+        this.getDbName = () => this.dbName;
+        this.insertStrategy = (value) => `${value}`;
+        this.dbName = 'BIGINT';
+    }
+    selectStrategy(value) {
+        return value ? parseInt(value, 10) : undefined;
+    }
+}
+exports.default = PgBigInt53;
+class PgBigInt64 extends columnType_1.default {
+    constructor() {
+        super();
+        this.getDbName = () => this.dbName;
+        this.insertStrategy = (value) => `${value}`;
+        this.dbName = 'BIGINT';
+    }
+    selectStrategy(value) {
+        return value ? BigInt(value) : undefined;
+    }
+}
+exports.PgBigInt64 = PgBigInt64;

package/dist/columns/types/pgBigSerial.d.ts

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

package/dist/columns/types/pgBigSerial.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 });
+exports.PgBigSerial64 = void 0;
+/* eslint-disable max-classes-per-file */
+const columnType_1 = __importDefault(require("./columnType"));
+class PgBigSerial53 extends columnType_1.default {
+    constructor() {
+        super();
+        this.getDbName = () => this.dbName;
+        this.insertStrategy = (value) => `${value}`;
+        this.dbName = 'BIGSERIAL';
+    }
+    selectStrategy(value) {
+        return value ? parseInt(value, 10) : undefined;
+    }
+}
+exports.default = PgBigSerial53;
+class PgBigSerial64 extends columnType_1.default {
+    constructor() {
+        super();
+        this.getDbName = () => this.dbName;
+        this.insertStrategy = (value) => `${value}`;
+        this.dbName = 'BIGSERIAL';
+    }
+    selectStrategy(value) {
+        return value ? BigInt(value) : undefined;
+    }
+}
+exports.PgBigSerial64 = PgBigSerial64;

package/dist/columns/types/pgBoolean.d.ts

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

package/dist/columns/types/pgBoolean.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 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/dist/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/dist/columns/types/pgEnum.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 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/dist/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/db/dbStringConnector.d.ts

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