sedentary-pg 0.0.12 → 0.0.16

package/README.md

@@ -29,4 +29,6 @@
 
 # under development
 
+https://www.postgresql.org/support/versioning/
+
 https://bucardo.org/postgres_all_versions.html

package/index.d.ts

@@ -1,6 +1,9 @@
-import { SchemaOptions, Sedentary } from "sedentary";
+import { Entry, Natural, SedentaryOptions, Sedentary, Type } from "sedentary";
 import { PoolConfig } from "pg";
+export { AttributeDefinition, AttributeOptions, AttributesDefinition, Entry, IndexAttributes, IndexDefinition, IndexOptions, IndexesDefinition } from "sedentary";
+export { ModelOptions, Natural, SedentaryOptions, Type, TypeDefinition } from "sedentary";
 export declare class SedentaryPG extends Sedentary {
-    constructor(connection: PoolConfig, options?: SchemaOptions);
+    constructor(connection: PoolConfig, options?: SedentaryOptions);
+    FKEY<N extends Natural, E extends Entry>(attribute: Type<N, E>): Type<N, E>;
 }
 export declare const Package: typeof SedentaryPG;

package/index.js

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Package = exports.SedentaryPG = void 0;
+exports.Package = exports.SedentaryPG = exports.Type = exports.Entry = void 0;
 const sedentary_1 = require("sedentary");
 const pgdb_1 = require("./lib/pgdb");
+var sedentary_2 = require("sedentary");
+Object.defineProperty(exports, "Entry", { enumerable: true, get: function () { return sedentary_2.Entry; } });
+var sedentary_3 = require("sedentary");
+Object.defineProperty(exports, "Type", { enumerable: true, get: function () { return sedentary_3.Type; } });
 class SedentaryPG extends sedentary_1.Sedentary {
     constructor(connection, options) {
         super("", options);
@@ -10,6 +14,12 @@ class SedentaryPG extends sedentary_1.Sedentary {
             throw new Error("SedentaryPG.constructor: 'connection' argument: Wrong type, expected 'Object'");
         this.db = new pgdb_1.PGDB(connection, this.log);
     }
+    FKEY(attribute) {
+        const { attributeName, tableName, unique } = attribute;
+        if (!unique)
+            throw new Error(`Sedentary.FKEY: '${tableName}' table: '${attributeName}' attribute: is not unique: can't be used as FKEY target`);
+        return super.FKEY(attribute);
+    }
 }
 exports.SedentaryPG = SedentaryPG;
 exports.Package = SedentaryPG;

package/lib/pgdb.d.ts

@@ -1,5 +1,5 @@
 import { PoolConfig } from "pg";
-import { DB, Field, Table } from "sedentary/lib/db";
+import { Attribute, DB, Natural, Table } from "sedentary/lib/db";
 export declare class PGDB extends DB {
     private client;
     private indexes;
@@ -7,13 +7,13 @@ export declare class PGDB extends DB {
     private version;
     constructor(connection: PoolConfig, log: (message: string) => void);
     connect(): Promise<void>;
-    dropConstraints(table: Table): Promise<void>;
+    dropConstraints(table: Table): Promise<number[]>;
     dropField(tableName: string, fieldName: string): Promise<void>;
     dropFields(table: Table): Promise<void>;
-    dropIndexes(table: Table): Promise<void>;
+    dropIndexes(table: Table, constraintIndexes: number[]): Promise<void>;
     end(): Promise<void>;
-    fieldType(field: Field<unknown, unknown>): string[];
-    sync(): Promise<void>;
+    fieldType(attribute: Attribute<Natural, unknown>): string[];
+    syncDataBase(): Promise<void>;
     syncConstraints(table: Table): Promise<void>;
     syncFields(table: Table): Promise<void>;
     syncIndexes(table: Table): Promise<void>;

package/lib/pgdb.js

@@ -31,34 +31,19 @@ class PGDB extends db_1.DB {
         this.version = parseInt(res.rows[0].version.split(" ")[1].split(".")[0], 10);
     }
     async dropConstraints(table) {
-        let place = 1;
-        const query = "SELECT conname FROM pg_attribute, pg_constraint WHERE attrelid = $1 AND conrelid = $1 AND attnum = conkey[1]";
-        const values = [table.oid];
-        const wheres = [];
-        for (const i in table.constraints) {
-            wheres.push(` AND (contype <> $${++place} or attname <> $${++place})`);
-            values.push(table.constraints[i].type);
-            values.push(table.constraints[i].field);
-        }
-        const res = await this.client.query(query + wheres.join(""), values);
-        if (!res.rowCount)
-            return;
-        /*
-          return pgo.client.query("SELECT conindid FROM pg_attribute, pg_constraint WHERE attrelid = $1 AND conrelid = $1 AND attnum = conkey[1]", [table.oid], function(err, res) {
-            const arr = [];
-    
-            if(pgo.error(err, 1011, table.name)) return;
-    
-            for(const i in res.rows) arr.push(res.rows[i].conindid);
-    
-            dropIndex(pgo, arr);
-          });
-        */
-        for (const i in res.rows) {
-            const statement = `ALTER TABLE ${table.tableName} DROP CONSTRAINT ${res.rows[i].conname}`;
-            this.log(statement);
-            await this.client.query(statement);
+        const indexes = [];
+        const res = await this.client.query("SELECT * FROM pg_constraint WHERE conrelid = $1 ORDER BY conname", [table.oid]);
+        for (const row of res.rows) {
+            const constraint = table.constraints.filter(_ => _.constraintName === row.conname);
+            if (constraint.length === 0) {
+                const statement = `ALTER TABLE ${table.tableName} DROP CONSTRAINT ${row.conname} CASCADE`;
+                this.log(statement);
+                await this.client.query(statement);
+            }
+            else
+                indexes.push(row.conindid);
         }
+        return indexes;
     }
     async dropField(tableName, fieldName) {
         const statement = `ALTER TABLE ${tableName} DROP COLUMN ${fieldName}`;
@@ -68,26 +53,28 @@ class PGDB extends db_1.DB {
     async dropFields(table) {
         const res = await this.client.query("SELECT attname FROM pg_attribute WHERE attrelid = $1 AND attnum > 0 AND attisdropped = false AND attinhcount = 0", [table.oid]);
         for (const i in res.rows)
-            if (table.fields.filter(f => f.fieldName === res.rows[i].attname).length === 0)
+            if (!table.findField(res.rows[i].attname))
                 await this.dropField(table.tableName, res.rows[i].attname);
     }
-    async dropIndexes(table) {
+    async dropIndexes(table, constraintIndexes) {
         const { indexes, oid } = table;
         const iobject = {};
-        const res = await this.client.query("SELECT amname, attname, indisunique, relname FROM pg_class, pg_index, pg_attribute, pg_am WHERE indrelid = $1 AND indexrelid = pg_class.oid AND attrelid = pg_class.oid AND relam = pg_am.oid ORDER BY attnum", [oid]);
+        const res = await this.client.query("SELECT amname, attname, indexrelid, indisunique, relname FROM pg_class, pg_index, pg_attribute, pg_am WHERE indrelid = $1 AND indexrelid = pg_class.oid AND attrelid = pg_class.oid AND relam = pg_am.oid ORDER BY attnum", [oid]);
         for (const row of res.rows) {
-            const { amname, attname, indisunique, relname } = row;
-            if (iobject[relname])
-                iobject[relname].fields.push(attname);
-            else
-                iobject[relname] = { fields: [attname], name: relname, type: amname, unique: indisunique };
+            const { amname, attname, indexrelid, indisunique, relname } = row;
+            if (!constraintIndexes.includes(indexrelid)) {
+                if (iobject[relname])
+                    iobject[relname].fields.push(attname);
+                else
+                    iobject[relname] = { fields: [attname], indexName: relname, type: amname, unique: indisunique };
+            }
         }
         this.indexes = [];
         for (const index of indexes) {
-            const { name } = index;
-            if (iobject[name] && this.indexesEq(index, iobject[name])) {
-                this.indexes.push(name);
-                delete iobject[name];
+            const { indexName } = index;
+            if (iobject[indexName] && this.indexesEq(index, iobject[indexName])) {
+                this.indexes.push(indexName);
+                delete iobject[indexName];
             }
         }
         for (const index of Object.keys(iobject).sort()) {
@@ -99,8 +86,8 @@ class PGDB extends db_1.DB {
     async end() {
         await this.pool.end();
     }
-    fieldType(field) {
-        const { size, type } = field;
+    fieldType(attribute) {
+        const { size, type } = attribute;
         let ret;
         switch (type) {
             case "DATETIME":
@@ -115,10 +102,10 @@ class PGDB extends db_1.DB {
         }
         throw new Error(`Unknown type: '${type}', '${size}'`);
     }
-    async sync() {
+    async syncDataBase() {
         let err;
         try {
-            await super.sync();
+            await super.syncDataBase();
         }
         catch (e) {
             err = e;
@@ -128,26 +115,36 @@ class PGDB extends db_1.DB {
             throw err;
     }
     async syncConstraints(table) {
-        for (const i in table.constraints) {
-            const constraint = table.constraints[i];
+        for (const constraint of table.constraints) {
+            const { attribute, constraintName, type } = constraint;
             const res = await this.client.query("SELECT attname FROM pg_attribute, pg_constraint WHERE attrelid = $1 AND conrelid = $1 AND attnum = conkey[1] AND attname = $2", [
                 table.oid,
-                constraint.field
+                attribute.fieldName
             ]);
             if (!res.rowCount) {
-                const statement = `ALTER TABLE ${table.tableName} ADD CONSTRAINT ${constraint.name} ${constraint.type === "u" ? `UNIQUE(${constraint.field})` : ``}`;
+                let query;
+                switch (type) {
+                    case "f":
+                        query = `FOREIGN KEY (${attribute.fieldName}) REFERENCES ${attribute.foreignKey.tableName}(${attribute.foreignKey.fieldName})`;
+                        break;
+                    case "u":
+                        query = `UNIQUE(${attribute.fieldName})`;
+                        break;
+                }
+                const statement = `ALTER TABLE ${table.tableName} ADD CONSTRAINT ${constraintName} ${query}`;
                 this.log(statement);
                 await this.client.query(statement);
             }
         }
     }
     async syncFields(table) {
-        const { fields, oid, tableName } = table;
-        for (const field of fields) {
-            const { fieldName, notNull, size } = field;
-            const defaultValue = field.defaultValue === undefined ? undefined : (0, pg_format_1.default)("%L", field.defaultValue);
-            const [base, type] = this.fieldType(field);
-            const res = await this.client.query(`SELECT *${this.version >= 12 ? ", pg_get_expr(pg_attrdef.adbin, pg_attrdef.adrelid) AS adsrc" : ""} FROM pg_type, pg_attribute LEFT JOIN pg_attrdef ON adrelid = attrelid AND adnum = attnum WHERE attrelid = $1 AND attnum > 0 AND atttypid = pg_type.oid AND attislocal = 't' AND attname = $2`, [oid, fieldName]);
+        const { attributes, oid, tableName } = table;
+        for (const attribute of attributes) {
+            const { fieldName, notNull, size } = attribute;
+            const defaultValue = attribute.defaultValue === undefined ? undefined : (0, pg_format_1.default)("%L", attribute.defaultValue);
+            const [base, type] = this.fieldType(attribute);
+            const adsrc = this.version >= 12 ? "pg_get_expr(pg_attrdef.adbin, pg_attrdef.adrelid) AS adsrc" : "adsrc";
+            const res = await this.client.query(`SELECT attnotnull, atttypmod, typname, ${adsrc} FROM pg_type, pg_attribute LEFT JOIN pg_attrdef ON adrelid = attrelid AND adnum = attnum WHERE attrelid = $1 AND attnum > 0 AND atttypid = pg_type.oid AND attislocal = 't' AND attname = $2`, [oid, fieldName]);
             const addField = async () => {
                 const statement = `ALTER TABLE ${tableName} ADD COLUMN ${fieldName} ${type}`;
                 this.log(statement);
@@ -158,13 +155,6 @@ class PGDB extends db_1.DB {
                 this.log(statement);
                 await this.client.query(statement);
             };
-            const setDefault = async () => {
-                if (defaultValue === undefined)
-                    return;
-                const statement = `ALTER TABLE ${tableName} ALTER COLUMN ${fieldName} SET DEFAULT ${defaultValue}`;
-                this.log(statement);
-                await this.client.query(statement);
-            };
             const setNotNull = async (isNull) => {
                 if (isNull === notNull)
                     return;
@@ -172,29 +162,39 @@ class PGDB extends db_1.DB {
                 this.log(statement);
                 await this.client.query(statement);
             };
+            const setDefault = async (isNull) => {
+                if (defaultValue !== undefined) {
+                    let statement = `ALTER TABLE ${tableName} ALTER COLUMN ${fieldName} SET DEFAULT ${defaultValue}`;
+                    this.log(statement);
+                    await this.client.query(statement);
+                    if (isNull) {
+                        statement = `UPDATE ${tableName} SET ${fieldName} = ${defaultValue} WHERE ${fieldName} IS NULL`;
+                        this.log(statement);
+                        this.client.query(statement);
+                    }
+                }
+                await setNotNull(isNull);
+            };
             if (!res.rowCount) {
                 await addField();
-                await setDefault();
-                await setNotNull(false);
+                await setDefault(false);
             }
             else {
                 const { adsrc, attnotnull, atttypmod, typname } = res.rows[0];
                 if (types[typname] !== base || (base === "VARCHAR" && (size ? size + 4 !== atttypmod : atttypmod !== -1))) {
-                    if (needDrop.filter(([type, name]) => field.type === type && typname === name).length) {
+                    if (needDrop.filter(([type, name]) => attribute.type === type && typname === name).length) {
                         await this.dropField(tableName, fieldName);
                         await addField();
-                        await setDefault();
-                        await setNotNull(false);
+                        await setDefault(false);
                     }
                     else {
                         if (adsrc)
                             dropDefault();
-                        const using = needUsing.filter(([type, name]) => field.type === type && typname === name).length ? " USING " + fieldName + "::" + type : "";
+                        const using = needUsing.filter(([type, name]) => attribute.type === type && typname === name).length ? " USING " + fieldName + "::" + type : "";
                         const statement = `ALTER TABLE ${tableName} ALTER COLUMN ${fieldName} TYPE ${type}${using}`;
                         this.log(statement);
                         await this.client.query(statement);
-                        await setDefault();
-                        await setNotNull(attnotnull);
+                        await setDefault(attnotnull);
                     }
                 }
                 else if (defaultValue === undefined) {
@@ -202,19 +202,17 @@ class PGDB extends db_1.DB {
                         dropDefault();
                     await setNotNull(attnotnull);
                 }
-                else if (!adsrc || adsrc.split("::")[0] !== defaultValue) {
-                    await setDefault();
-                    await setNotNull(attnotnull);
-                }
+                else if (!adsrc || adsrc.split("::")[0] !== defaultValue)
+                    await setDefault(attnotnull);
             }
         }
     }
     async syncIndexes(table) {
         const { indexes, tableName } = table;
         for (const index of indexes) {
-            const { fields, name, type, unique } = index;
-            if (this.indexes.indexOf(name) === -1) {
-                const statement = `CREATE${unique ? " UNIQUE" : ""} INDEX ${name} ON ${tableName} USING ${type} (${fields.join(", ")})`;
+            const { fields, indexName, type, unique } = index;
+            if (!this.indexes.includes(indexName)) {
+                const statement = `CREATE${unique ? " UNIQUE" : ""} INDEX ${indexName} ON ${tableName} USING ${type} (${fields.join(", ")})`;
                 this.log(statement);
                 await this.client.query(statement);
             }
@@ -256,7 +254,7 @@ class PGDB extends db_1.DB {
             if (resParent.rowCount) {
                 if (!table.parent)
                     drop = true;
-                else if (this.tables[table.parent.tableName].oid === resParent.rows[0].inhparent)
+                else if (this.findTable(table.parent.tableName).oid === resParent.rows[0].inhparent)
                     return;
                 drop = true;
             }

package/lib/pgdb.ts

@@ -1,6 +1,6 @@
 import { Pool, PoolClient, PoolConfig } from "pg";
 import format from "pg-format";
-import { DB, Field, IndexDef, Table } from "sedentary/lib/db";
+import { Attribute, DB, Index, Natural, Table } from "sedentary/lib/db";
 
 const needDrop = [
   ["DATETIME", "int2"],
@@ -36,39 +36,22 @@ export class PGDB extends DB {
     this.version = parseInt(res.rows[0].version.split(" ")[1].split(".")[0], 10);
   }
 
-  async dropConstraints(table: Table): Promise<void> {
-    let place = 1;
-    const query = "SELECT conname FROM pg_attribute, pg_constraint WHERE attrelid = $1 AND conrelid = $1 AND attnum = conkey[1]";
-    const values: (number | string)[] = [table.oid];
-    const wheres = [];
+  async dropConstraints(table: Table): Promise<number[]> {
+    const indexes: number[] = [];
+    const res = await this.client.query("SELECT * FROM pg_constraint WHERE conrelid = $1 ORDER BY conname", [table.oid]);
 
-    for(const i in table.constraints) {
-      wheres.push(` AND (contype <> $${++place} or attname <> $${++place})`);
-      values.push(table.constraints[i].type);
-      values.push(table.constraints[i].field);
-    }
-
-    const res = await this.client.query(query + wheres.join(""), values);
-
-    if(! res.rowCount) return;
-    /*
-      return pgo.client.query("SELECT conindid FROM pg_attribute, pg_constraint WHERE attrelid = $1 AND conrelid = $1 AND attnum = conkey[1]", [table.oid], function(err, res) {
-        const arr = [];
-
-        if(pgo.error(err, 1011, table.name)) return;
-
-        for(const i in res.rows) arr.push(res.rows[i].conindid);
-
-        dropIndex(pgo, arr);
-      });
-    */
+    for(const row of res.rows) {
+      const constraint = table.constraints.filter(_ => _.constraintName === row.conname);
 
-    for(const i in res.rows) {
-      const statement = `ALTER TABLE ${table.tableName} DROP CONSTRAINT ${res.rows[i].conname}`;
+      if(constraint.length === 0) {
+        const statement = `ALTER TABLE ${table.tableName} DROP CONSTRAINT ${row.conname} CASCADE`;
 
-      this.log(statement);
-      await this.client.query(statement);
+        this.log(statement);
+        await this.client.query(statement);
+      } else indexes.push(row.conindid);
     }
+
+    return indexes;
   }
 
   async dropField(tableName: string, fieldName: string): Promise<void> {
@@ -81,31 +64,33 @@ export class PGDB extends DB {
   async dropFields(table: Table): Promise<void> {
     const res = await this.client.query("SELECT attname FROM pg_attribute WHERE attrelid = $1 AND attnum > 0 AND attisdropped = false AND attinhcount = 0", [table.oid]);
 
-    for(const i in res.rows) if(table.fields.filter(f => f.fieldName === res.rows[i].attname).length === 0) await this.dropField(table.tableName, res.rows[i].attname);
+    for(const i in res.rows) if(! table.findField(res.rows[i].attname)) await this.dropField(table.tableName, res.rows[i].attname);
   }
 
-  async dropIndexes(table: Table): Promise<void> {
+  async dropIndexes(table: Table, constraintIndexes: number[]): Promise<void> {
     const { indexes, oid } = table;
-    const iobject: { [key: string]: IndexDef } = {};
+    const iobject: { [key: string]: Index } = {};
     const res = await this.client.query(
-      "SELECT amname, attname, indisunique, relname FROM pg_class, pg_index, pg_attribute, pg_am WHERE indrelid = $1 AND indexrelid = pg_class.oid AND attrelid = pg_class.oid AND relam = pg_am.oid ORDER BY attnum",
+      "SELECT amname, attname, indexrelid, indisunique, relname FROM pg_class, pg_index, pg_attribute, pg_am WHERE indrelid = $1 AND indexrelid = pg_class.oid AND attrelid = pg_class.oid AND relam = pg_am.oid ORDER BY attnum",
       [oid]
     );
 
     for(const row of res.rows) {
-      const { amname, attname, indisunique, relname } = row;
+      const { amname, attname, indexrelid, indisunique, relname } = row;
 
-      if(iobject[relname]) iobject[relname].fields.push(attname);
-      else iobject[relname] = { fields: [attname], name: relname, type: amname, unique: indisunique };
+      if(! constraintIndexes.includes(indexrelid)) {
+        if(iobject[relname]) iobject[relname].fields.push(attname);
+        else iobject[relname] = { fields: [attname], indexName: relname, type: amname, unique: indisunique };
+      }
     }
 
     this.indexes = [];
     for(const index of indexes) {
-      const { name } = index;
+      const { indexName } = index;
 
-      if(iobject[name] && this.indexesEq(index, iobject[name])) {
-        this.indexes.push(name);
-        delete iobject[name];
+      if(iobject[indexName] && this.indexesEq(index, iobject[indexName])) {
+        this.indexes.push(indexName);
+        delete iobject[indexName];
       }
     }
 
@@ -121,8 +106,8 @@ export class PGDB extends DB {
     await this.pool.end();
   }
 
-  fieldType(field: Field<unknown, unknown>): string[] {
-    const { size, type } = field;
+  fieldType(attribute: Attribute<Natural, unknown>): string[] {
+    const { size, type } = attribute;
     let ret;
 
     switch(type) {
@@ -141,11 +126,11 @@ export class PGDB extends DB {
     throw new Error(`Unknown type: '${type}', '${size}'`);
   }
 
-  async sync(): Promise<void> {
+  async syncDataBase(): Promise<void> {
     let err: Error;
 
     try {
-      await super.sync();
+      await super.syncDataBase();
     } catch(e) {
       err = e;
     }
@@ -156,16 +141,26 @@ export class PGDB extends DB {
   }
 
   async syncConstraints(table: Table): Promise<void> {
-    for(const i in table.constraints) {
-      const constraint = table.constraints[i];
-
+    for(const constraint of table.constraints) {
+      const { attribute, constraintName, type } = constraint;
       const res = await this.client.query("SELECT attname FROM pg_attribute, pg_constraint WHERE attrelid = $1 AND conrelid = $1 AND attnum = conkey[1] AND attname = $2", [
         table.oid,
-        constraint.field
+        attribute.fieldName
       ]);
 
       if(! res.rowCount) {
-        const statement = `ALTER TABLE ${table.tableName} ADD CONSTRAINT ${constraint.name} ${constraint.type === "u" ? `UNIQUE(${constraint.field})` : ``}`;
+        let query: string;
+
+        switch(type) {
+        case "f":
+          query = `FOREIGN KEY (${attribute.fieldName}) REFERENCES ${attribute.foreignKey.tableName}(${attribute.foreignKey.fieldName})`;
+          break;
+        case "u":
+          query = `UNIQUE(${attribute.fieldName})`;
+          break;
+        }
+
+        const statement = `ALTER TABLE ${table.tableName} ADD CONSTRAINT ${constraintName} ${query}`;
 
         this.log(statement);
         await this.client.query(statement);
@@ -174,17 +169,16 @@ export class PGDB extends DB {
   }
 
   async syncFields(table: Table): Promise<void> {
-    const { fields, oid, tableName } = table;
+    const { attributes, oid, tableName } = table;
 
-    for(const field of fields) {
-      const { fieldName, notNull, size } = field;
-      const defaultValue = field.defaultValue === undefined ? undefined : format("%L", field.defaultValue);
-      const [base, type] = this.fieldType(field);
+    for(const attribute of attributes) {
+      const { fieldName, notNull, size } = attribute;
+      const defaultValue = attribute.defaultValue === undefined ? undefined : format("%L", attribute.defaultValue);
+      const [base, type] = this.fieldType(attribute);
+      const adsrc = this.version >= 12 ? "pg_get_expr(pg_attrdef.adbin, pg_attrdef.adrelid) AS adsrc" : "adsrc";
 
       const res = await this.client.query(
-        `SELECT *${
-          this.version >= 12 ? ", pg_get_expr(pg_attrdef.adbin, pg_attrdef.adrelid) AS adsrc" : ""
-        } FROM pg_type, pg_attribute LEFT JOIN pg_attrdef ON adrelid = attrelid AND adnum = attnum WHERE attrelid = $1 AND attnum > 0 AND atttypid = pg_type.oid AND attislocal = 't' AND attname = $2`,
+        `SELECT attnotnull, atttypmod, typname, ${adsrc} FROM pg_type, pg_attribute LEFT JOIN pg_attrdef ON adrelid = attrelid AND adnum = attnum WHERE attrelid = $1 AND attnum > 0 AND atttypid = pg_type.oid AND attislocal = 't' AND attname = $2`,
         [oid, fieldName]
       );
 
@@ -202,55 +196,58 @@ export class PGDB extends DB {
         await this.client.query(statement);
       };
 
-      const setDefault = async () => {
-        if(defaultValue === undefined) return;
+      const setNotNull = async (isNull: boolean) => {
+        if(isNull === notNull) return;
 
-        const statement = `ALTER TABLE ${tableName} ALTER COLUMN ${fieldName} SET DEFAULT ${defaultValue}`;
+        const statement = `ALTER TABLE ${tableName} ALTER COLUMN ${fieldName} ${notNull ? "SET" : "DROP"} NOT NULL`;
 
         this.log(statement);
         await this.client.query(statement);
       };
 
-      const setNotNull = async (isNull: boolean) => {
-        if(isNull === notNull) return;
+      const setDefault = async (isNull: boolean) => {
+        if(defaultValue !== undefined) {
+          let statement = `ALTER TABLE ${tableName} ALTER COLUMN ${fieldName} SET DEFAULT ${defaultValue}`;
 
-        const statement = `ALTER TABLE ${tableName} ALTER COLUMN ${fieldName} ${notNull ? "SET" : "DROP"} NOT NULL`;
+          this.log(statement);
+          await this.client.query(statement);
 
-        this.log(statement);
-        await this.client.query(statement);
+          if(isNull) {
+            statement = `UPDATE ${tableName} SET ${fieldName} = ${defaultValue} WHERE ${fieldName} IS NULL`;
+
+            this.log(statement);
+            this.client.query(statement);
+          }
+        }
+
+        await setNotNull(isNull);
       };
 
       if(! res.rowCount) {
         await addField();
-        await setDefault();
-        await setNotNull(false);
+        await setDefault(false);
       } else {
         const { adsrc, attnotnull, atttypmod, typname } = res.rows[0];
 
         if(types[typname] !== base || (base === "VARCHAR" && (size ? size + 4 !== atttypmod : atttypmod !== -1))) {
-          if(needDrop.filter(([type, name]) => field.type === type && typname === name).length) {
+          if(needDrop.filter(([type, name]) => attribute.type === type && typname === name).length) {
             await this.dropField(tableName, fieldName);
             await addField();
-            await setDefault();
-            await setNotNull(false);
+            await setDefault(false);
           } else {
             if(adsrc) dropDefault();
 
-            const using = needUsing.filter(([type, name]) => field.type === type && typname === name).length ? " USING " + fieldName + "::" + type : "";
+            const using = needUsing.filter(([type, name]) => attribute.type === type && typname === name).length ? " USING " + fieldName + "::" + type : "";
             const statement = `ALTER TABLE ${tableName} ALTER COLUMN ${fieldName} TYPE ${type}${using}`;
 
             this.log(statement);
             await this.client.query(statement);
-            await setDefault();
-            await setNotNull(attnotnull);
+            await setDefault(attnotnull);
           }
         } else if(defaultValue === undefined) {
           if(adsrc) dropDefault();
           await setNotNull(attnotnull);
-        } else if(! adsrc || adsrc.split("::")[0] !== defaultValue) {
-          await setDefault();
-          await setNotNull(attnotnull);
-        }
+        } else if(! adsrc || adsrc.split("::")[0] !== defaultValue) await setDefault(attnotnull);
       }
     }
   }
@@ -259,10 +256,10 @@ export class PGDB extends DB {
     const { indexes, tableName } = table;
 
     for(const index of indexes) {
-      const { fields, name, type, unique } = index;
+      const { fields, indexName, type, unique } = index;
 
-      if(this.indexes.indexOf(name) === -1) {
-        const statement = `CREATE${unique ? " UNIQUE" : ""} INDEX ${name} ON ${tableName} USING ${type} (${fields.join(", ")})`;
+      if(! this.indexes.includes(indexName)) {
+        const statement = `CREATE${unique ? " UNIQUE" : ""} INDEX ${indexName} ON ${tableName} USING ${type} (${fields.join(", ")})`;
 
         this.log(statement);
         await this.client.query(statement);
@@ -312,7 +309,7 @@ export class PGDB extends DB {
 
       if(resParent.rowCount) {
         if(! table.parent) drop = true;
-        else if(this.tables[table.parent.tableName].oid === resParent.rows[0].inhparent) return;
+        else if(this.findTable(table.parent.tableName).oid === resParent.rows[0].inhparent) return;
 
         drop = true;
       } else if(table.parent) drop = true;

package/package.json

@@ -6,26 +6,29 @@
     "@types/pg-format": "1.0.2",
     "pg": "8.7.1",
     "pg-format": "1.0.4",
-    "sedentary": "0.0.12"
+    "sedentary": "0.0.16"
   },
   "description": "The ORM which never needs to migrate - PostgreSQL",
   "devDependencies": {
     "@types/mocha": "9.0.0",
-    "@types/node": "16.11.6",
+    "@types/node": "16.11.10",
     "@types/yamljs": "0.2.31",
-    "@typescript-eslint/eslint-plugin": "5.3.0",
-    "@typescript-eslint/parser": "5.3.0",
-    "eslint": "8.2.0",
+    "@typescript-eslint/eslint-plugin": "5.4.0",
+    "@typescript-eslint/parser": "5.4.0",
+    "eslint": "8.3.0",
     "mocha": "9.1.3",
     "nyc": "15.1.0",
-    "prettier": "2.4.1",
+    "prettier": "2.5.0",
     "ts-node": "10.4.0",
-    "typescript": "4.4.4",
+    "typescript": "4.5.2",
     "yamljs": "0.3.0"
   },
   "engines": {
     "node": ">=12.0"
   },
+  "funding": {
+    "url": "https://blockchain.info/address/1Md9WFAHrXTb3yPBwQWmUfv2RmzrtbHioB"
+  },
   "homepage": "https://github.com/iccicci/sedentary-pg#readme",
   "keywords": [
     "DB",
@@ -59,5 +62,5 @@
     "version": "node -r ts-node/register utils.ts version"
   },
   "types": "index.d.ts",
-  "version": "0.0.12"
+  "version": "0.0.16"
 }