drizzle-orm 0.10.25 → 0.10.28

package/dist/errors/baseError.d.ts

@@ -0,0 +1,22 @@
+export interface Failure {
+    type: PgSessionError;
+    reason: Error;
+}
+export declare enum PgSessionError {
+    PgQueryExecutionError = 0
+}
+export declare type Either<L, A> = Left<L, A> | Right<L, A>;
+export declare class Left<L, A> {
+    readonly value: L;
+    constructor(value: L);
+    isLeft(): this is Left<L, A>;
+    isRight(): this is Right<L, A>;
+}
+export declare class Right<L, A> {
+    readonly value: A;
+    constructor(value: A);
+    isLeft(): this is Left<L, A>;
+    isRight(): this is Right<L, A>;
+}
+export declare const left: <L, A>(l: L) => Either<L, A>;
+export declare const right: <L, A>(a: A) => Either<L, A>;

package/dist/errors/baseError.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.right = exports.left = exports.Right = exports.Left = exports.PgSessionError = void 0;
+var PgSessionError;
+(function (PgSessionError) {
+    PgSessionError[PgSessionError["PgQueryExecutionError"] = 0] = "PgQueryExecutionError";
+})(PgSessionError = exports.PgSessionError || (exports.PgSessionError = {}));
+class Left {
+    constructor(value) {
+        this.value = value;
+    }
+    isLeft() {
+        return true;
+    }
+    isRight() {
+        return false;
+    }
+}
+exports.Left = Left;
+class Right {
+    constructor(value) {
+        this.value = value;
+    }
+    isLeft() {
+        return false;
+    }
+    isRight() {
+        return true;
+    }
+}
+exports.Right = Right;
+const left = (l) => new Left(l);
+exports.left = left;
+const right = (a) => new Right(a);
+exports.right = right;

package/dist/errors/builderError.d.ts

@@ -0,0 +1,14 @@
+import Expr from '../builders/requestBuilders/where/where';
+import { AbstractColumn } from '../columns/column';
+import ColumnType from '../columns/types/columnType';
+export declare enum BuilderType {
+    SELECT = 0,
+    JOINED_SELECT = 1,
+    TWO_JOINED_SELECT = 2,
+    DELETE = 3,
+    INSERT = 4,
+    UPDATE = 5
+}
+export default class BuilderError extends Error {
+    constructor(builderType: BuilderType, tableName: string, columns: AbstractColumn<ColumnType>[], reason: Error, filter?: Expr);
+}

package/dist/errors/builderError.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuilderType = void 0;
+var BuilderType;
+(function (BuilderType) {
+    BuilderType[BuilderType["SELECT"] = 0] = "SELECT";
+    BuilderType[BuilderType["JOINED_SELECT"] = 1] = "JOINED_SELECT";
+    BuilderType[BuilderType["TWO_JOINED_SELECT"] = 2] = "TWO_JOINED_SELECT";
+    BuilderType[BuilderType["DELETE"] = 3] = "DELETE";
+    BuilderType[BuilderType["INSERT"] = 4] = "INSERT";
+    BuilderType[BuilderType["UPDATE"] = 5] = "UPDATE";
+})(BuilderType = exports.BuilderType || (exports.BuilderType = {}));
+class BuilderError extends Error {
+    constructor(builderType, tableName, columns, reason, filter) {
+        super('');
+        this.message = ` Error while building select query from ${tableName}\n-----\nIf you see current error, please create [github issue](https://github.com/lambda-direct/drizzle-orm/issues) and provide following information\n
+Reason: ${reason.message}
+Query builder: ${BuilderType[builderType]}
+Table name: ${tableName}
+Filter query: ${filter ? filter.toQuery().query : 'undefined'}
+Values: ${filter ? filter.toQuery().values : 'undefined'}
+Column names: ${columns.map((column) => column.getColumnName()).join(', ')}\n-----\n`;
+    }
+}
+exports.default = BuilderError;

package/dist/errors/dbErrors.d.ts

@@ -0,0 +1,12 @@
+export declare class DatabaseSelectError extends Error {
+    constructor(tableName: string, reason: Error, query: string);
+}
+export declare class DatabaseDeleteError extends Error {
+    constructor(tableName: string, reason: Error, query: string);
+}
+export declare class DatabaseInsertError extends Error {
+    constructor(tableName: string, reason: Error, query: string);
+}
+export declare class DatabaseUpdateError extends Error {
+    constructor(tableName: string, reason: Error, query: string);
+}

package/dist/errors/dbErrors.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseUpdateError = exports.DatabaseInsertError = exports.DatabaseDeleteError = exports.DatabaseSelectError = void 0;
+/* eslint-disable max-classes-per-file */
+class DatabaseSelectError extends Error {
+    constructor(tableName, reason, query) {
+        super(` Got an error, while selecting from ${tableName}. Reason: ${reason.message}. Query to database looks like:\n${query}\n`);
+    }
+}
+exports.DatabaseSelectError = DatabaseSelectError;
+class DatabaseDeleteError extends Error {
+    constructor(tableName, reason, query) {
+        super(` Got an error, while deleting from ${tableName}. Reason: ${reason.message}. Query to database looks like:\n${query}\n`);
+    }
+}
+exports.DatabaseDeleteError = DatabaseDeleteError;
+class DatabaseInsertError extends Error {
+    constructor(tableName, reason, query) {
+        super(` Got an error, while inserting to ${tableName}. Reason: ${reason.message}. Query to database looks like:\n${query}\n`);
+    }
+}
+exports.DatabaseInsertError = DatabaseInsertError;
+class DatabaseUpdateError extends Error {
+    constructor(tableName, reason, query) {
+        super(` Got an error, while updating ${tableName}. Reason: ${reason.message}. Query to database looks like:\n${query}\n`);
+    }
+}
+exports.DatabaseUpdateError = DatabaseUpdateError;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { ClientConfig } from 'pg';
+import { DB } from './db';
+import Migrator from './migrator/migrator';
+export * from './db';
+export * from './builders';
+export * from './columns';
+export * from './tables';
+export declare const drizzle: {
+    connect(config: ClientConfig): Promise<DB>;
+    migrator(db: DB): Migrator;
+};

package/dist/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.drizzle = void 0;
+const db_1 = require("./db");
+const migrator_1 = __importDefault(require("./migrator/migrator"));
+__exportStar(require("./db"), exports);
+__exportStar(require("./builders"), exports);
+__exportStar(require("./columns"), exports);
+__exportStar(require("./tables"), exports);
+exports.drizzle = {
+    async connect(config) {
+        const dbConnector = new db_1.DbConnector().params(config);
+        return dbConnector.connect();
+    },
+    migrator(db) {
+        return new migrator_1.default(db);
+    },
+};

package/dist/indexes/tableIndex.d.ts

@@ -0,0 +1,11 @@
+import { Column } from '../columns/column';
+import ColumnType from '../columns/types/columnType';
+export default class TableIndex {
+    private _columns;
+    private _tableName;
+    private _isUnique;
+    constructor(tableName: string, columns: Column<ColumnType<any>, boolean, boolean>[], isUnique?: boolean);
+    getColumns: () => Column<ColumnType<any>, boolean, boolean>[];
+    indexName: () => string;
+    isUnique: () => boolean;
+}

package/dist/indexes/tableIndex.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class TableIndex {
+    constructor(tableName, columns, isUnique = false) {
+        this._columns = [];
+        this.getColumns = () => this._columns;
+        this.indexName = () => {
+            const columnNames = this._columns.map((column) => column.getColumnName());
+            return `${this._tableName}_${columnNames.join('_')}_index`;
+        };
+        this.isUnique = () => this._isUnique;
+        this._columns = columns;
+        this._tableName = tableName;
+        this._isUnique = isUnique;
+    }
+}
+exports.default = TableIndex;

package/dist/logger/abstractLogger.d.ts

@@ -0,0 +1,4 @@
+export default abstract class BaseLogger {
+    abstract info(msg: string): void;
+    abstract error(msg: string): void;
+}

package/dist/logger/abstractLogger.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class BaseLogger {
+}
+exports.default = BaseLogger;

package/dist/logger/consoleLogger.d.ts

@@ -0,0 +1,5 @@
+import BaseLogger from './abstractLogger';
+export default class ConsoleLogger extends BaseLogger {
+    info(msg: string): void;
+    error(msg: string): void;
+}

package/dist/logger/consoleLogger.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const abstractLogger_1 = __importDefault(require("./abstractLogger"));
+class ConsoleLogger extends abstractLogger_1.default {
+    info(msg) {
+        console.log(`INFO: ${msg}`);
+    }
+    error(msg) {
+        console.log(`ERROR: ${msg}`);
+    }
+}
+exports.default = ConsoleLogger;

package/dist/mappers/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/mappers/responseMapper.d.ts

@@ -0,0 +1,10 @@
+import { QueryResult } from 'pg';
+import { AbstractColumn } from '../columns/column';
+import ColumnType from '../columns/types/columnType';
+import { ExtractModel } from '../tables/inferTypes';
+export default class QueryResponseMapper {
+    static map: <ITable>(mappedServiceToDb: { [name in keyof ExtractModel<ITable>]: AbstractColumn<ColumnType<{}>, true, false, any>; }, queryResult: QueryResult<any>, joinId?: number | undefined) => ExtractModel<ITable>[];
+    static partialMap: <T>(partial: {
+        [name: string]: AbstractColumn<ColumnType<{}>, true, false, any>;
+    }, queryResult: QueryResult<any>, joinId?: number | undefined) => ExtractModel<T>[];
+}

package/dist/mappers/responseMapper.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line max-len
+// const checkProperties = (obj: any) => Object.values(obj).every((x) => x === null || Number.isNaN(x));
+class QueryResponseMapper {
+}
+exports.default = QueryResponseMapper;
+QueryResponseMapper.map = (mappedServiceToDb, queryResult, joinId) => {
+    const response = [];
+    queryResult.rows.forEach((row) => {
+        const mappedRow = {};
+        Object.keys(mappedServiceToDb).forEach((key) => {
+            const column = mappedServiceToDb[key];
+            const alias = `${column.getAlias()}${joinId ? `_${joinId}` : ''}`;
+            const value = column.getColumnType().selectStrategy(row[alias]);
+            mappedRow[key] = value === null ? undefined : value;
+        });
+        response.push(mappedRow);
+    });
+    return response;
+};
+QueryResponseMapper.partialMap = (partial, queryResult, joinId) => {
+    const response = [];
+    queryResult.rows.forEach((row) => {
+        const mappedRow = {};
+        Object.keys(partial).forEach((key) => {
+            const column = partial[key];
+            const alias = `${column.getAlias()}${joinId ? `_${joinId}` : ''}`;
+            const value = column.getColumnType().selectStrategy(row[alias]);
+            mappedRow[key] = value === null ? undefined : value;
+        });
+        response.push(mappedRow);
+    });
+    return response;
+};

package/dist/migrator/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/migrator/migrator.d.ts

@@ -0,0 +1,11 @@
+import Db from '../db/db';
+export declare type InCodeConfig = {
+    migrationFolder: string;
+};
+export default class Migrator {
+    private db;
+    constructor(db: Db);
+    migrate(configPath: string): Promise<void>;
+    migrate(config: InCodeConfig): Promise<void>;
+    private generateHash;
+}

package/dist/migrator/migrator.js

@@ -0,0 +1,105 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable import/export */
+/* eslint-disable max-classes-per-file */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const builders_1 = require("../builders");
+const transaction_1 = __importDefault(require("../builders/transaction/transaction"));
+const tables_1 = require("../tables");
+class Migrator {
+    constructor(db) {
+        this.db = db;
+    }
+    async migrate(configPath) {
+        let migrationFolderTo;
+        if (typeof configPath === 'string') {
+            const configAsString = fs.readFileSync(path.resolve('.', configPath), 'utf8');
+            const splitted = configAsString.trim().split('\n');
+            // eslint-disable-next-line no-restricted-syntax
+            for (const split of splitted) {
+                const entry = split.trim().split(':');
+                const key = entry[0];
+                const value = entry[1].trim().replace(/['"]+/g, '');
+                if (key === 'migrationRootFolder') {
+                    // proceed value
+                    migrationFolderTo = value;
+                }
+            }
+        }
+        else {
+            migrationFolderTo = configPath.migrationFolder;
+        }
+        if (!migrationFolderTo) {
+            throw Error('no migration folder defined');
+        }
+        const migrationTable = new tables_1.MigrationsTable(this.db);
+        await this.db.session().execute(builders_1.Create.table(migrationTable).build());
+        const dbMigrations = await migrationTable.select().all();
+        const lastDbMigration = dbMigrations.length > 0
+            ? dbMigrations[dbMigrations.length - 1]
+            : undefined;
+        const files = fs.readdirSync(migrationFolderTo);
+        const transaction = new transaction_1.default(this.db.session());
+        await transaction.begin();
+        try {
+            for await (const migrationFolder of files) {
+                const migrationFiles = fs.readdirSync(`${migrationFolderTo}/${migrationFolder}`);
+                const migrationFile = migrationFiles.filter((file) => file === 'migration.sql')[0];
+                const query = fs.readFileSync(`${migrationFolderTo}/${migrationFolder}/${migrationFile}`).toString();
+                const year = Number(migrationFolder.slice(0, 4));
+                // second param for Date() is month index, that started from 0, so we need
+                // to decrement a value for month
+                const month = Number(migrationFolder.slice(4, 6)) - 1;
+                const day = Number(migrationFolder.slice(6, 8));
+                const hour = Number(migrationFolder.slice(8, 10));
+                const min = Number(migrationFolder.slice(10, 12));
+                const sec = Number(migrationFolder.slice(12, 14));
+                const folderAsMillis = new Date(year, month, day, hour, min, sec).getTime();
+                if (!lastDbMigration || lastDbMigration.createdAt < folderAsMillis) {
+                    await this.db.session().execute(query);
+                    await migrationTable.insert({
+                        hash: this.generateHash(query),
+                        createdAt: folderAsMillis,
+                    }).execute();
+                }
+            }
+            await transaction.commit();
+        }
+        catch (e) {
+            // if (this.db.logger()) {
+            //   this.db.logger()!.error(e);
+            // }
+            transaction.rollback();
+            throw e;
+        }
+    }
+    generateHash(value) {
+        return crypto.createHash('sha256').update(value).digest('hex');
+    }
+}
+exports.default = Migrator;

package/dist/serializer/serializer.d.ts

@@ -0,0 +1,47 @@
+import { DB } from '../db';
+import { AbstractTable } from '../tables';
+import Enum from '../types/type';
+interface EnumsAsObject {
+    [name: string]: {
+        name: string;
+        values: string[];
+    };
+}
+interface ColumnAsObject {
+    [name: string]: {
+        name?: string;
+        type?: string;
+        primaryKey?: boolean;
+        unique?: boolean;
+        default?: any;
+        notNull?: boolean;
+        references?: 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>;
+        };
+    };
+    fromDatabase: (db: DB) => Promise<{
+        version: string;
+        tables: TableAsObject;
+        enums: EnumsAsObject;
+    }>;
+}
+export {};