drizzle-orm 0.9.13 → 0.9.17

package/serializer/serializer.js

@@ -1,4 +1,5 @@
 "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 */
@@ -34,7 +35,7 @@ class MigrationSerializer {
                     if (value instanceof columns_1.Column) {
                         columnToReturn[value.getColumnName()] = {
                             name: value.getColumnName(),
-                            type: value.isAutoIncrement() ? 'serial' : value.getColumnType().getDbName(),
+                            type: value.getColumnType().getDbName(),
                             primaryKey: !!value.primaryKeyName,
                             unique: !!value.uniqueKeyName,
                             default: value.getDefaultValue() === null ? undefined : value.getDefaultValue(),
@@ -69,6 +70,172 @@ class MigrationSerializer {
             }, {});
             return { version: '1', 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;
+                        mappedRefernces[columnFrom] = {
+                            foreignKeyName,
+                            table: tableTo,
+                            column: columnTo,
+                            onDelete: onUpdate ? `ON UPDATE ${onUpdate}` : undefined,
+                            onUpdate: onDelete ? `ON DELETE ${onDelete}` : undefined,
+                        };
+                    }
+                    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: '1', tables: result, enums: enumsToReturn };
+        };
     }
 }
 exports.default = MigrationSerializer;

package/tables/abstractTable.d.ts

@@ -11,7 +11,7 @@ import InsertTRB from '../builders/highLvlBuilders/insertRequestBuilder';
 import DeleteTRB from '../builders/highLvlBuilders/deleteRequestBuilder';
 import UpdateTRB from '../builders/highLvlBuilders/updateRequestBuilder';
 import SelectTRB from '../builders/highLvlBuilders/selectRequestBuilder';
-import PgBigInt from '../columns/types/pgBigInt';
+import PgBigInt53, { PgBigInt64 } from '../columns/types/pgBigInt';
 import BaseLogger from '../logger/abstractLogger';
 import PgEnum from '../columns/types/pgEnum';
 import DB from '../db/db';
@@ -19,6 +19,9 @@ import { AbstractColumn, Column } from '../columns/column';
 import TableIndex from '../indexes/tableIndex';
 import { ExtractModel } from './inferTypes';
 import Enum, { ExtractEnumValues } from '../types/type';
+import PgSerial from '../columns/types/pgSerial';
+import PgTimestamptz from '../columns/types/pgTimestamptz';
+import PgBigSerial53, { PgBigSerial64 } from '../columns/types/pgBigSerial';
 export default abstract class AbstractTable<TTable extends AbstractTable<TTable>> {
     db: DB;
     private _session;
@@ -43,102 +46,23 @@ export default abstract class AbstractTable<TTable extends AbstractTable<TTable>
     protected uniqueIndex(columns: Column<ColumnType, boolean, boolean>): TableIndex;
     protected varchar(name: string, params?: {
         size?: number;
-        notNull: false;
     }): Column<PgVarChar, true>;
-    protected varchar(name: string, params: {
-        size?: number;
-        notNull: true;
-    }): Column<PgVarChar, false>;
-    protected varchar(name: string, params?: {
-        size?: number;
-        notNull?: false;
-    }): Column<PgVarChar, true>;
-    protected varchar(name: string, params: {
-        size?: number;
-        notNull?: true;
-    }): Column<PgVarChar, false>;
-    protected int(name: string, params?: {
-        notNull: false;
-    }): Column<PgInteger, true>;
-    protected int(name: string, params: {
-        notNull: true;
-    }): Column<PgInteger, false>;
-    protected smallInt(name: string, params?: {
-        notNull: false;
-    }): Column<PgInteger, true>;
-    protected smallInt(name: string, params: {
-        notNull: true;
-    }): Column<PgInteger, false>;
-    protected timestamp(name: string, params?: {
-        notNull: false;
-    }): Column<PgTimestamp, true>;
-    protected timestamp(name: string, params: {
-        notNull: true;
-    }): Column<PgTimestamp, false>;
-    protected bigint(name: string, params?: {
-        notNull: false;
-    }): Column<PgBigInt, true>;
-    protected bigint(name: string, params: {
-        notNull: true;
-    }): Column<PgBigInt, false>;
-    protected type<ETtype extends string>(typeEnum: Enum<ETtype>, name: string, params?: {
-        notNull: false;
-    }): Column<PgEnum<ExtractEnumValues<Enum<ETtype>>>, true>;
-    protected type<ETtype extends string>(typeEnum: Enum<ETtype>, name: string, params: {
-        notNull: true;
-    }): Column<PgEnum<ExtractEnumValues<Enum<ETtype>>>, false>;
+    protected int(name: string): Column<PgInteger, true>;
+    protected smallInt(name: string): Column<PgInteger, true>;
+    protected serial(name: string): Column<PgSerial, true, true>;
+    protected bigSerial(name: string, maxBytes: 'max_bytes_53'): Column<PgBigSerial53, true, true>;
+    protected bigSerial(name: string, maxBytes: 'max_bytes_64'): Column<PgBigSerial64, true, true>;
+    protected timestamp(name: string): Column<PgTimestamp, true>;
+    protected timestamptz(name: string): Column<PgTimestamptz, true>;
+    protected bigint(name: string, maxBytes: 'max_bytes_53'): Column<PgBigInt53, true, true>;
+    protected bigint(name: string, maxBytes: 'max_bytes_64'): Column<PgBigInt64, true, true>;
+    protected type<ETtype extends string>(typeEnum: Enum<ETtype>, name: string): Column<PgEnum<ExtractEnumValues<Enum<ETtype>>>, true>;
     protected decimal(name: string, params?: {
         precision?: number;
-        scale: number;
-        notNull?: false;
-    }): Column<PgBigDecimal, true>;
-    protected decimal(name: string, params: {
-        precision?: number;
-        scale: number;
-        notNull?: true;
-    }): Column<PgBigDecimal, false>;
-    protected decimal(name: string, params?: {
-        precision: number;
         scale?: number;
-        notNull?: false;
     }): Column<PgBigDecimal, true>;
-    protected decimal(name: string, params: {
-        precision: number;
-        scale?: number;
-        notNull?: true;
-    }): Column<PgBigDecimal, false>;
-    protected decimal(name: string, params?: {
-        precision?: number;
-        scale?: number;
-        notNull?: false;
-    }): Column<PgBigDecimal, true>;
-    protected decimal(name: string, params: {
-        precision?: number;
-        scale?: number;
-        notNull?: true;
-    }): Column<PgBigDecimal, false>;
-    protected time(name: string, params?: {
-        notNull: false;
-    }): Column<PgTime, true>;
-    protected time(name: string, params: {
-        notNull: true;
-    }): Column<PgTime, false>;
-    protected bool(name: string, params?: {
-        notNull: false;
-    }): Column<PgBoolean, true>;
-    protected bool(name: string, params: {
-        notNull: true;
-    }): Column<PgBoolean, false>;
-    protected text(name: string, params?: {
-        notNull: false;
-    }): Column<PgText, true>;
-    protected text(name: string, params: {
-        notNull: true;
-    }): Column<PgText, false>;
-    protected jsonb<TSubType>(name: string, params?: {
-        notNull: false;
-    }): Column<PgJsonb<TSubType>, true>;
-    protected jsonb<TSubType>(name: string, params: {
-        notNull: true;
-    }): Column<PgJsonb<TSubType>, false>;
+    protected time(name: string): Column<PgTime, true>;
+    protected bool(name: string): Column<PgBoolean, true>;
+    protected text(name: string): Column<PgText, true>;
+    protected jsonb<TSubType>(name: string): Column<PgJsonb<TSubType>, true>;
 }

package/tables/abstractTable.js

@@ -17,6 +17,9 @@ const pgEnum_1 = require("../columns/types/pgEnum");
 const column_1 = require("../columns/column");
 const tableIndex_1 = require("../indexes/tableIndex");
 const pgSmallInt_1 = require("../columns/types/pgSmallInt");
+const pgSerial_1 = require("../columns/types/pgSerial");
+const pgTimestamptz_1 = require("../columns/types/pgTimestamptz");
+const pgBigSerial_1 = require("../columns/types/pgBigSerial");
 class AbstractTable {
     constructor(db) {
         this.withLogger = (logger) => {
@@ -73,49 +76,53 @@ class AbstractTable {
         return new tableIndex_1.default(this.tableName(), columns instanceof Array ? columns : [columns]);
     }
     varchar(name, params = {}) {
-        var _a;
-        return new column_1.Column(this, name, new pgVarChar_1.default(params.size), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+        return new column_1.Column(this, name, new pgVarChar_1.default(params.size));
     }
-    int(name, params = {}) {
-        var _a;
-        return new column_1.Column(this, name, new pgInteger_1.default(), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    int(name) {
+        return new column_1.Column(this, name, new pgInteger_1.default());
     }
-    smallInt(name, params = {}) {
-        var _a;
-        return new column_1.Column(this, name, new pgSmallInt_1.default(), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    smallInt(name) {
+        return new column_1.Column(this, name, new pgSmallInt_1.default());
     }
-    timestamp(name, params = {}) {
-        var _a;
-        return new column_1.Column(this, name, new pgTimestamp_1.default(), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    serial(name) {
+        return new column_1.Column(this, name, new pgSerial_1.default());
     }
-    bigint(name, params = {}) {
-        var _a;
-        return new column_1.Column(this, name, new pgBigInt_1.default(), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    bigSerial(name, maxBytes) {
+        if (maxBytes === 'max_bytes_53') {
+            return new column_1.Column(this, name, new pgBigSerial_1.default());
+        }
+        return new column_1.Column(this, name, new pgBigSerial_1.PgBigSerial64());
+    }
+    timestamp(name) {
+        return new column_1.Column(this, name, new pgTimestamp_1.default());
+    }
+    timestamptz(name) {
+        return new column_1.Column(this, name, new pgTimestamptz_1.default());
+    }
+    bigint(name, maxBytes) {
+        if (maxBytes === 'max_bytes_53') {
+            return new column_1.Column(this, name, new pgBigInt_1.default());
+        }
+        return new column_1.Column(this, name, new pgBigInt_1.PgBigInt64());
     }
-    type(typeEnum, name, params = {}) {
-        var _a;
+    type(typeEnum, name) {
         const pgEnum = new pgEnum_1.default(typeEnum.name);
-        return new column_1.Column(this, name, pgEnum, (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+        return new column_1.Column(this, name, pgEnum);
     }
     decimal(name, params = {}) {
-        var _a;
-        return new column_1.Column(this, name, new pgBigDecimal_1.default(params.precision, params.scale), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+        return new column_1.Column(this, name, new pgBigDecimal_1.default(params.precision, params.scale));
     }
-    time(name, params = {}) {
-        var _a;
-        return new column_1.Column(this, name, new pgTime_1.default(), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    time(name) {
+        return new column_1.Column(this, name, new pgTime_1.default());
     }
-    bool(name, params = {}) {
-        var _a;
-        return new column_1.Column(this, name, new pgBoolean_1.default(), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    bool(name) {
+        return new column_1.Column(this, name, new pgBoolean_1.default());
     }
-    text(name, params = {}) {
-        var _a;
-        return new column_1.Column(this, name, new pgText_1.default(), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    text(name) {
+        return new column_1.Column(this, name, new pgText_1.default());
     }
-    jsonb(name, params = {}) {
-        var _a;
-        return new column_1.Column(this, name, new pgJsonb_1.default(), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    jsonb(name) {
+        return new column_1.Column(this, name, new pgJsonb_1.default());
     }
 }
 exports.default = AbstractTable;

package/tables/migrationsTable.d.ts

@@ -1,8 +1,7 @@
 import AbstractTable from './abstractTable';
 export default class MigrationsTable extends AbstractTable<MigrationsTable> {
-    id: import("../columns/column").IndexedColumn<import("..").PgInteger, true, true>;
-    version: import("..").Column<import("..").PgInteger, false, false>;
-    hash: import("..").Column<import("..").PgText, true, false>;
-    createdAt: import("..").Column<import("..").PgTimestamp, true, false>;
+    id: import("..").Column<import("../columns/types/pgSerial").default, true, true>;
+    hash: import("..").Column<import("..").PgText, false, false>;
+    createdAt: import("..").Column<import("..").PgBigInt, true, true>;
     tableName(): string;
 }

package/tables/migrationsTable.js

@@ -4,13 +4,12 @@ const abstractTable_1 = require("./abstractTable");
 class MigrationsTable extends abstractTable_1.default {
     constructor() {
         super(...arguments);
-        this.id = this.int('id').autoIncrement().primaryKey();
-        this.version = this.int('version', { notNull: true }).unique();
-        this.hash = this.text('hash');
-        this.createdAt = this.timestamp('created_at');
+        this.id = this.serial('id').primaryKey();
+        this.hash = this.text('hash').notNull();
+        this.createdAt = this.bigint('created_at', 'max_bytes_53');
     }
     tableName() {
-        return 'migrations';
+        return 'drizzle_migrations';
     }
 }
 exports.default = MigrationsTable;

package/test.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = require(".");
 // import { Pool } from 'pg';
 // import { DB } from '.';
 // import { DB, DbConnector } from '.';
@@ -16,11 +17,17 @@ const fromTypeFile = (filepath) => {
 };
 (async () => {
     try {
+        const db = await new _1.DbConnector()
+            .connectionString('postgresql://postgres@127.0.0.1/drizzle-docs')
+            .connect();
+        // const serializer = new MigrationSerializer();
+        // const res = await serializer.fromDatabase(db);
+        // fs.writeFileSync('introspected.json', JSON.stringify(res, null, 2), 'utf8');
         // const ser = new MigrationSerializer();
         // const d = db.create(UsersTable) as unknown as AbstractTable<any>;
         // const f = ser.generate([d], []);
         // console.log(JSON.stringify(f, null, 2));
-        // await drizzle.migrator(db).migrate('src/drizzle.config.yaml');
+        await _1.drizzle.migrator(db).migrate({ migrationFolder: 'src/drizzle.config.yaml' });
         // drizzle.migrator(db).migrate({ migrationFolder: '' });
         // const typesFileNames = fs.readdirSync('/Users/andrewsherman/IdeaProjects/datalayer-orm/src/examples/types');
         // typesFileNames.forEach((filename) => {

package/docs/tables/citiesToUsers.d.ts

@@ -1,7 +0,0 @@
-import AbstractTable from '../../tables/abstractTable';
-export default class UsersToUserGroupsTable extends AbstractTable<UsersToUserGroupsTable> {
-    groupId: import("../../columns/column").Column<import("../..").PgInteger, true, false>;
-    userId: import("../../columns/column").Column<import("../..").PgInteger, true, false>;
-    manyToManyIndex: import("../../indexes/tableIndex").default;
-    tableName(): string;
-}

package/docs/tables/citiesToUsers.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const column_1 = require("../../columns/column");
-const abstractTable_1 = require("../../tables/abstractTable");
-const userGroupsTable_1 = require("./userGroupsTable");
-const usersTable_1 = require("./usersTable");
-class UsersToUserGroupsTable extends abstractTable_1.default {
-    constructor() {
-        super(...arguments);
-        this.groupId = this.int('city_id').foreignKey(userGroupsTable_1.default, (table) => table.id, column_1.OnDelete.CASCADE);
-        this.userId = this.int('user_id').foreignKey(usersTable_1.default, (table) => table.id, column_1.OnDelete.CASCADE);
-        this.manyToManyIndex = this.index([this.groupId, this.userId]);
-    }
-    tableName() {
-        return 'users_to_user_groups';
-    }
-}
-exports.default = UsersToUserGroupsTable;