drizzle-orm 0.10.24 → 0.10.25

package/dist/serializer/serializer.js

@@ -1,258 +0,0 @@
-"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

@@ -1,11 +0,0 @@
-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

@@ -1,35 +0,0 @@
-"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

@@ -1,16 +0,0 @@
-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

@@ -1,42 +0,0 @@
-"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

@@ -1,22 +0,0 @@
-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

@@ -1,106 +0,0 @@
-"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

@@ -1,39 +0,0 @@
-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>;
-    };
-}