drizzle-orm 0.10.21 → 0.10.24

package/dist/serializer/serializer.js

@@ -0,0 +1,258 @@
+"use strict";
+/* eslint-disable max-classes-per-file */
+/* 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 */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const columns_1 = require("../columns");
+const tableIndex_1 = __importDefault(require("../indexes/tableIndex"));
+const serialiseForeignKey = (fkName, table, column, onDelete, onUpdate) => {
+    return `${fkName};${table};${column};${onDelete !== null && onDelete !== void 0 ? onDelete : ''};${onUpdate !== null && onUpdate !== void 0 ? onUpdate : ''}`;
+};
+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 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,
+                            isUnique: value.isUnique(),
+                        };
+                    }
+                    if (value instanceof columns_1.Column) {
+                        columnToReturn[value.getColumnName()] = {
+                            name: value.getColumnName(),
+                            type: value.getColumnType().getDbName(),
+                            primaryKey: !!value.primaryKeyName,
+                            // unique: !!value.uniqueKeyName,
+                            // default: value.getDefaultValue() === null ? undefined : value.getDefaultValue(),
+                            notNull: !value.isNullableFlag,
+                        };
+                        if (value.getDefaultValue() !== undefined && value.getDefaultValue() !== null) {
+                            columnToReturn[value.getColumnName()].default = value.getDefaultValue();
+                        }
+                        if (value.uniqueKeyName) {
+                            const indexName = `${value.getParent().tableName()}_${value.getColumnName()}_index`;
+                            const indexColumnToReturn = {};
+                            indexColumnToReturn[value.getColumnName()] = {
+                                name: value.getColumnName(),
+                            };
+                            indexToReturn[indexName] = {
+                                name: indexName,
+                                columns: indexColumnToReturn,
+                                isUnique: true,
+                            };
+                        }
+                        const referenced = value.getReferenced();
+                        if (referenced) {
+                            const fkName = `${value.getParent().tableName()}_${value.getColumnName()}_fkey`;
+                            const table = referenced.getParentName();
+                            const column = referenced.getColumnName();
+                            const onDelete = value.getOnDelete();
+                            const onUpdate = value.getOnUpdate();
+                            const referenceString = serialiseForeignKey(fkName, table, column, onDelete, onUpdate);
+                            columnToReturn[value.getColumnName()].references = referenceString;
+                        }
+                    }
+                }
+                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: '2', tables: result, enums: enumsToReturn };
+        };
+        this.fromDatabase = async (db) => {
+            var _a;
+            const result = {};
+            const allTables = await db.session().execute('SELECT table_schema, table_name FROM information_schema.tables WHERE table_schema != \'pg_catalog\' and table_schema != \'information_schema\';');
+            for await (const row of allTables.rows) {
+                try {
+                    // const tableSchema = row.table_schema;
+                    const tableName = row.table_name;
+                    const columnToReturn = {};
+                    const indexToReturn = {};
+                    const tableResponse = await db.session().execute(`SELECT a.attrelid::regclass::text, a.attname
+        , CASE WHEN a.atttypid = ANY ('{int,int8,int2}'::regtype[])
+             AND EXISTS (
+                SELECT FROM pg_attrdef ad
+                WHERE  ad.adrelid = a.attrelid
+                AND    ad.adnum   = a.attnum
+                AND    pg_get_expr(ad.adbin, ad.adrelid)
+                     = 'nextval('''
+                    || (pg_get_serial_sequence (a.attrelid::regclass::text
+                                             , a.attname))::regclass
+                    || '''::regclass)'
+                )
+           THEN CASE a.atttypid
+                   WHEN 'int'::regtype  THEN 'serial'
+                   WHEN 'int8'::regtype THEN 'bigserial'
+                   WHEN 'int2'::regtype THEN 'smallserial'
+                END
+           ELSE format_type(a.atttypid, a.atttypmod)
+           END AS data_type, INFORMATION_SCHEMA.COLUMNS.table_name, INFORMATION_SCHEMA.COLUMNS.column_name, INFORMATION_SCHEMA.COLUMNS.column_default
+   FROM  pg_attribute  a
+   JOIN INFORMATION_SCHEMA.COLUMNS ON INFORMATION_SCHEMA.COLUMNS.column_name = a.attname
+   WHERE  a.attrelid = '${tableName}'::regclass and INFORMATION_SCHEMA.COLUMNS.table_name = '${tableName}'
+   AND    a.attnum > 0
+   AND    NOT a.attisdropped
+   ORDER  BY a.attnum;`);
+                    const tableConstraints = await db.session().execute(`SELECT c.column_name, c.data_type, constraint_type, constraint_name
+      FROM information_schema.table_constraints tc 
+      JOIN information_schema.constraint_column_usage AS ccu USING (constraint_schema, constraint_name) 
+      JOIN information_schema.columns AS c ON c.table_schema = tc.constraint_schema
+        AND tc.table_name = c.table_name AND ccu.column_name = c.column_name
+      WHERE tc.table_name = '${tableName}';`);
+                    const tableForeignKeys = await db.session().execute(`SELECT
+        tc.table_schema, 
+        tc.constraint_name, 
+        tc.table_name, 
+        kcu.column_name,
+        ccu.table_schema AS foreign_table_schema,
+        ccu.table_name AS foreign_table_name,
+        ccu.column_name AS foreign_column_name,
+        rc.delete_rule, rc.update_rule
+    FROM 
+        information_schema.table_constraints AS tc
+        JOIN information_schema.key_column_usage AS kcu
+          ON tc.constraint_name = kcu.constraint_name
+          AND tc.table_schema = kcu.table_schema
+        JOIN information_schema.constraint_column_usage AS ccu
+          ON ccu.constraint_name = tc.constraint_name
+          AND ccu.table_schema = tc.table_schema
+        JOIN information_schema.referential_constraints AS rc
+          ON ccu.constraint_name = rc.constraint_name 
+    WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_name='${tableName}';`);
+                    const mappedRefernces = {};
+                    for (const fk of tableForeignKeys.rows) {
+                        // const tableFrom = fk.table_name;
+                        const columnFrom = fk.column_name;
+                        const tableTo = fk.foreign_table_name;
+                        const columnTo = fk.foreign_column_name;
+                        const foreignKeyName = fk.constraint_name;
+                        const onUpdate = fk.update_rule;
+                        const onDelete = fk.delete_rule;
+                        const references = serialiseForeignKey(foreignKeyName, tableTo, columnTo, onDelete, onUpdate);
+                        mappedRefernces[columnFrom] = references;
+                    }
+                    for (const columnResponse of tableResponse.rows) {
+                        const columnName = columnResponse.attname;
+                        const columnType = columnResponse.data_type;
+                        const primaryKey = tableConstraints.rows.filter((mapRow) => columnName === mapRow.column_name && mapRow.constraint_type === 'PRIMARY KEY');
+                        const uniqueKey = tableConstraints.rows.filter((mapRow) => columnName === mapRow.column_name && mapRow.constraint_type === 'UNIQUE');
+                        const defaultValue = columnResponse.column_default === null
+                            ? undefined : columnResponse.column_default;
+                        const isSerial = columnType === 'serial';
+                        columnToReturn[columnName] = {
+                            name: columnName,
+                            type: columnType,
+                            primaryKey: !!primaryKey[0],
+                            unique: !!uniqueKey[0],
+                            default: isSerial ? undefined : defaultValue,
+                            notNull: !columnResponse.is_nullable,
+                            references: (_a = mappedRefernces[columnName]) !== null && _a !== void 0 ? _a : undefined,
+                        };
+                    }
+                    const dbIndexes = await db.session().execute(`select
+        t.relname as table_name,
+        i.relname as index_name,
+        a.attname as column_name
+    from
+        pg_class t,
+        pg_class i,
+        pg_index ix,
+        pg_attribute a
+    where
+        t.oid = ix.indrelid
+        and i.oid = ix.indexrelid
+        and a.attrelid = t.oid
+        and a.attnum = ANY(ix.indkey)
+        and t.relkind = 'r'
+        and t.relname = '${tableName}'
+    order by
+        t.relname,
+        i.relname;`);
+                    for (const dbIndex of dbIndexes.rows) {
+                        const indexName = dbIndex.index_name;
+                        const indexColumnName = dbIndex.column_name;
+                        if (indexToReturn[indexName] !== undefined && indexToReturn[indexName] !== null) {
+                            indexToReturn[indexName].columns[indexColumnName] = {
+                                name: indexColumnName,
+                            };
+                        }
+                        else {
+                            indexToReturn[indexName] = {
+                                name: indexName,
+                                columns: {
+                                    [indexColumnName]: {
+                                        name: indexColumnName,
+                                    },
+                                },
+                            };
+                        }
+                    }
+                    result[tableName] = {
+                        name: tableName,
+                        columns: columnToReturn,
+                        indexes: indexToReturn,
+                    };
+                }
+                catch (e) {
+                    console.log(e);
+                }
+            }
+            const allEnums = await db.session().execute(`select n.nspname as enum_schema,  
+    t.typname as enum_name,  
+    e.enumlabel as enum_value
+    from pg_type t 
+    join pg_enum e on t.oid = e.enumtypid  
+    join pg_catalog.pg_namespace n ON n.oid = t.typnamespace;`);
+            const enumsToReturn = {};
+            for (const dbEnum of allEnums.rows) {
+                const enumName = dbEnum.enum_name;
+                const enumValue = dbEnum.enum_value;
+                if (enumsToReturn[enumName] !== undefined && enumsToReturn[enumName] !== null) {
+                    enumsToReturn[enumName].values.push(enumValue);
+                }
+                else {
+                    enumsToReturn[enumName] = {
+                        name: enumName,
+                        values: [enumValue],
+                    };
+                }
+            }
+            return { version: '2', tables: result, enums: enumsToReturn };
+        };
+    }
+}
+exports.default = MigrationSerializer;

package/dist/src/builders/aggregators/abstractAggregator.d.ts

@@ -0,0 +1,11 @@
+import { AbstractColumn } from '../../columns/column';
+import ColumnType from '../../columns/types/columnType';
+import { AbstractTable } from '../../tables';
+export default class Aggregator {
+    protected _fields: Array<string>;
+    protected _table: AbstractTable<any>;
+    constructor(table: AbstractTable<any>, partial?: {
+        [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, AbstractTable<any>>;
+    });
+    protected generateSelectArray: (table: string, columns: AbstractColumn<ColumnType>[], id?: number | undefined) => string[];
+}

package/dist/src/builders/aggregators/abstractAggregator.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable max-len */
+const column_1 = require("../../columns/column");
+const ecranate_1 = require("../../utils/ecranate");
+// eslint-disable-next-line max-len
+class Aggregator {
+    constructor(table, partial) {
+        this._fields = [];
+        this.generateSelectArray = (table, columns, id) => {
+            const selectFields = [];
+            columns.forEach((field) => {
+                if (field instanceof column_1.Column) {
+                    selectFields.push(' ');
+                    selectFields.push(table);
+                    selectFields.push('.');
+                    selectFields.push(ecranate_1.ecranate(field.getColumnName()));
+                    selectFields.push(' AS ');
+                    selectFields.push(ecranate_1.ecranate(`${field.getAlias()}${id ? `_${id}` : ''}`));
+                    selectFields.push(',');
+                }
+            });
+            selectFields.pop();
+            return selectFields;
+        };
+        this._table = table;
+        if (!partial) {
+            this._fields = this.generateSelectArray(this._table.tableName(), Object.values(this._table.mapServiceToDb()));
+        }
+        else {
+            this._fields = this.generateSelectArray(this._table.tableName(), Object.values(partial));
+        }
+    }
+}
+exports.default = Aggregator;

package/dist/src/builders/aggregators/deleteAggregator.d.ts

@@ -0,0 +1,16 @@
+import { AbstractTable } from '../../tables';
+import Expr from '../requestBuilders/where/where';
+import Aggregator from './abstractAggregator';
+export default class DeleteAggregator extends Aggregator {
+    private _from;
+    private _filters;
+    private _values;
+    private _delete;
+    constructor(table: AbstractTable<any>);
+    filters: (filters: Expr) => DeleteAggregator;
+    appendFrom: (tableName: string) => DeleteAggregator;
+    buildQuery: () => {
+        query: string;
+        values: Array<any>;
+    };
+}

package/dist/src/builders/aggregators/deleteAggregator.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const abstractAggregator_1 = __importDefault(require("./abstractAggregator"));
+class DeleteAggregator extends abstractAggregator_1.default {
+    constructor(table) {
+        super(table);
+        this._from = [];
+        this._filters = [];
+        this._values = [];
+        this._delete = ['DELETE'];
+        this.filters = (filters) => {
+            if (filters) {
+                const filterQuery = filters.toQuery();
+                this._filters.push('WHERE ');
+                this._filters.push(filterQuery.query);
+                this._values = filterQuery.values;
+            }
+            return this;
+        };
+        this.appendFrom = (tableName) => {
+            this._from.push(' FROM ');
+            this._from.push(tableName);
+            return this;
+        };
+        this.buildQuery = () => {
+            // this._delete.push(this._fields.join(''));
+            this._delete.push('\n');
+            this._delete.push(this._from.join(''));
+            this._delete.push('\n');
+            this._delete.push(this._filters.join(''));
+            this._delete.push('\n');
+            this._delete.push('RETURNING');
+            this._delete.push('\n');
+            this._delete.push(this._fields.join(''));
+            return { query: this._delete.join(''), values: this._values };
+        };
+    }
+}
+exports.default = DeleteAggregator;

package/dist/src/builders/aggregators/insertAggregator.d.ts

@@ -0,0 +1,22 @@
+import { AbstractTable } from '../../tables';
+import { Indexing } from '../../tables/inferTypes';
+import { UpdateExpr } from '../requestBuilders/updates/updates';
+import Aggregator from './abstractAggregator';
+export default class InsertAggregator extends Aggregator {
+    private _onConflict;
+    private _columns;
+    private _query;
+    private _values;
+    private _from;
+    private _insert;
+    constructor(table: AbstractTable<any>);
+    appendColumns: () => void;
+    appendValues: (values: {
+        [name: string]: any;
+    }[]) => void;
+    appendOnConflict: (column: Indexing, updates?: UpdateExpr | undefined) => this;
+    buildQuery: () => {
+        query: string;
+        values: Array<any>;
+    };
+}

package/dist/src/builders/aggregators/insertAggregator.js

@@ -0,0 +1,106 @@
+"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-loop-func */
+const column_1 = require("../../columns/column");
+const abstractAggregator_1 = __importDefault(require("./abstractAggregator"));
+class InsertAggregator extends abstractAggregator_1.default {
+    constructor(table) {
+        super(table);
+        this._onConflict = [];
+        this._columns = [];
+        this._query = [];
+        this._values = [];
+        this._from = [];
+        this._insert = ['INSERT INTO'];
+        this.appendColumns = () => {
+            const mapper = this._table.mapServiceToDb();
+            const columns = Object.values(mapper);
+            for (let i = 0; i < columns.length; i += 1) {
+                const column = columns[i];
+                this._columns.push('"');
+                this._columns.push(column.getColumnName());
+                this._columns.push('"');
+                if (i < columns.length - 1) {
+                    this._columns.push(', ');
+                }
+            }
+        };
+        this.appendValues = (values) => {
+            // @TODO Check if values not empty
+            const mapper = this._table.mapServiceToDb();
+            let position = 0;
+            for (let i = 0; i < values.length; i += 1) {
+                const value = values[i];
+                this._query.push('(');
+                const entries = Object.entries(mapper);
+                entries.forEach(([key], index) => {
+                    const valueToInsert = value[key];
+                    const isKeyExistsInValue = key.toString() in value;
+                    const column = mapper[key];
+                    if (isKeyExistsInValue) {
+                        if (valueToInsert !== undefined && valueToInsert !== null) {
+                            position += 1;
+                            this._query.push(`$${position}`);
+                            this._values.push(column.getColumnType().insertStrategy(valueToInsert));
+                        }
+                        else {
+                            this._query.push('null');
+                        }
+                    }
+                    else {
+                        this._query.push('DEFAULT');
+                    }
+                    if (index < entries.length - 1) {
+                        this._query.push(', ');
+                    }
+                });
+                if (i < values.length - 1) {
+                    this._query.push('),\n');
+                }
+                else {
+                    this._query.push(')\n');
+                }
+            }
+        };
+        this.appendOnConflict = (column, updates) => {
+            if (column) {
+                const indexName = column instanceof column_1.IndexedColumn
+                    ? column.getColumnName() : column.getColumns().map((it) => it.getColumnName()).join(',');
+                this._onConflict.push(`ON CONFLICT (${indexName})\n`);
+                if (updates) {
+                    const currentPointerPosition = this._values.length > 0
+                        ? this._values.length + 1 : undefined;
+                    const updatesQuery = updates.toQuery(currentPointerPosition);
+                    this._onConflict.push('DO UPDATE\n');
+                    this._onConflict.push(`SET ${updatesQuery.query}`);
+                    this._values.push(...updatesQuery.values);
+                }
+                else {
+                    this._onConflict.push('DO NOTHING\n');
+                }
+            }
+            return this;
+        };
+        this.buildQuery = () => {
+            this._insert.push(this._from.join(''));
+            this._insert.push(' (');
+            this._insert.push(this._columns.join(''));
+            this._insert.push(') ');
+            this._insert.push('VALUES\n');
+            this._insert.push(this._query.join(''));
+            this._insert.push('\n');
+            this._insert.push(this._onConflict.join(''));
+            this._insert.push('\n');
+            this._insert.push('RETURNING');
+            this._insert.push('\n');
+            this._insert.push(this._fields.join(''));
+            return { query: this._insert.join(''), values: this._values };
+        };
+        this._from.push(' ');
+        this._from.push(table.tableName());
+    }
+}
+exports.default = InsertAggregator;

package/dist/src/builders/aggregators/selectAggregator.d.ts

@@ -0,0 +1,39 @@
+import { AbstractColumn } from '../../columns/column';
+import ColumnType from '../../columns/types/columnType';
+import { AbstractTable } from '../../tables';
+import Order from '../highLvlBuilders/order';
+import Join from '../joinBuilders/join';
+import Expr from '../requestBuilders/where/where';
+import Aggregator from './abstractAggregator';
+export default class SelectAggregator extends Aggregator {
+    private _from;
+    private _filters;
+    private _select;
+    private _join;
+    private _limit;
+    private _offset;
+    private _distinct;
+    private _orderBy;
+    private _values;
+    private _joinCache;
+    constructor(table: AbstractTable<any>, partial?: {
+        [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, AbstractTable<any>>;
+    });
+    filters: (filters: Expr) => SelectAggregator;
+    limit: (limit?: number | undefined) => SelectAggregator;
+    offset: (offset?: number | undefined) => SelectAggregator;
+    orderBy: (column?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined, order?: Order | undefined) => SelectAggregator;
+    distinct: (column?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined) => SelectAggregator;
+    appendFrom: (tableName: string) => SelectAggregator;
+    join: (joins: {
+        join: Join<any>;
+        partial?: {
+            [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, any>;
+        } | undefined;
+        id?: number | undefined;
+    }[]) => SelectAggregator;
+    buildQuery: () => {
+        query: string;
+        values: Array<any>;
+    };
+}