sedentary-pg 0.0.13 → 0.0.17

package/README.md

@@ -29,4 +29,49 @@
 
 # under development
 
-https://bucardo.org/postgres_all_versions.html
+# Description
+
+The **PostgreSQL** specilized package of [Sedentary](https://www.npmjs.com/package/sedentary).
+
+# Installation
+
+With [npm](https://www.npmjs.com/package/sedentary-pg):
+
+```sh
+$ npm install --save sedentary-pg
+```
+
+# Documentation
+
+The full documentation is on [sedentary.readthedocs.io](https://sedentary.readthedocs.io/).
+
+# Compatibility
+
+Requires:
+
+- Node.js: **v12**
+- TypeScript: **v4.1** (or none if used in a JavaScript project).
+
+The package is tested under [all version combinations](https://app.travis-ci.com/github/iccicci/sedentary-pg)
+of **Node.js** currently supported accordingly to [Node.js Release](https://github.com/nodejs/Release#readme) and of
+**PostgreSQL** currently supported accordingly to
+[PostgreSQL Versioning](https://www.postgresql.org/support/versioning/).
+
+To work with the package under Windows, be sure to configure `bash.exe` as your _script-shell_.
+
+```
+> npm config set script-shell bash.exe
+```
+
+# Licence
+
+[MIT Licence](https://github.com/iccicci/sedentary-pg/blob/master/LICENSE)
+
+# Bugs
+
+Do not hesitate to report any bug or inconsistency [@github](https://github.com/iccicci/sedentary-pg/issues).
+
+# Donating
+
+If you find useful this package, please consider the opportunity to donate some satoshis to this bitcoin address:
+**1Md9WFAHrXTb3yPBwQWmUfv2RmzrtbHioB**

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, modelName, unique } = attribute;
+        if (!unique)
+            throw new Error(`Sedentary.FKEY: '${modelName}' model: '${attributeName}' attribute: is not unique: can't be used as FKEY target`);
+        return super.FKEY(attribute);
+    }
 }
 exports.SedentaryPG = SedentaryPG;
 exports.Package = SedentaryPG;

package/lib/adsrc.d.ts

@@ -0,0 +1 @@
+export declare function adsrc(version: number): "pg_get_expr(pg_attrdef.adbin, pg_attrdef.adrelid) AS adsrc" | "adsrc";

package/lib/adsrc.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adsrc = void 0;
+function adsrc(version) {
+    return version >= 12 ? "pg_get_expr(pg_attrdef.adbin, pg_attrdef.adrelid) AS adsrc" : "adsrc";
+}
+exports.adsrc = adsrc;

package/lib/adsrc.ts

@@ -0,0 +1,3 @@
+export function adsrc(version: number) {
+  return version >= 12 ? "pg_get_expr(pg_attrdef.adbin, pg_attrdef.adrelid) AS adsrc" : "adsrc";
+}

package/lib/pgdb.d.ts

@@ -1,5 +1,5 @@
 import { PoolConfig } from "pg";
-import { DB, Entry, Field, Natural, 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<Natural, Entry>): 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

@@ -7,6 +7,7 @@ exports.PGDB = void 0;
 const pg_1 = require("pg");
 const pg_format_1 = __importDefault(require("pg-format"));
 const db_1 = require("sedentary/lib/db");
+const adsrc_1 = require("./adsrc");
 const needDrop = [
     ["DATETIME", "int2"],
     ["DATETIME", "int4"],
@@ -31,76 +32,66 @@ 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.syncLog(statement);
+                if (this.sync)
+                    await this.client.query(statement);
+            }
+            else
+                indexes.push(row.conindid);
         }
+        return indexes;
     }
     async dropField(tableName, fieldName) {
         const statement = `ALTER TABLE ${tableName} DROP COLUMN ${fieldName}`;
-        this.log(statement);
-        await this.client.query(statement);
+        this.syncLog(statement);
+        if (this.sync)
+            await this.client.query(statement);
     }
     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()) {
             const statement = `DROP INDEX ${index}`;
-            this.log(statement);
-            await this.client.query(statement);
+            this.syncLog(statement);
+            if (this.sync)
+                await this.client.query(statement);
         }
     }
     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 +106,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,73 +119,93 @@ 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})` : ``}`;
-                this.log(statement);
-                await this.client.query(statement);
+                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.syncLog(statement);
+                if (this.sync)
+                    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 where = "attrelid = $1 AND attnum > 0 AND atttypid = pg_type.oid AND attislocal = 't' AND attname = $2";
+            const res = await this.client.query(`SELECT attnotnull, atttypmod, typname, ${(0, adsrc_1.adsrc)(this.version)} FROM pg_type, pg_attribute LEFT JOIN pg_attrdef ON adrelid = attrelid AND adnum = attnum WHERE ${where}`, [oid, fieldName]);
             const addField = async () => {
                 const statement = `ALTER TABLE ${tableName} ADD COLUMN ${fieldName} ${type}`;
-                this.log(statement);
-                await this.client.query(statement);
+                this.syncLog(statement);
+                if (this.sync)
+                    await this.client.query(statement);
             };
             const dropDefault = async () => {
                 const statement = `ALTER TABLE ${tableName} ALTER COLUMN ${fieldName} DROP DEFAULT`;
-                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);
+                this.syncLog(statement);
+                if (this.sync)
+                    await this.client.query(statement);
             };
             const setNotNull = async (isNull) => {
                 if (isNull === notNull)
                     return;
                 const statement = `ALTER TABLE ${tableName} ALTER COLUMN ${fieldName} ${notNull ? "SET" : "DROP"} NOT NULL`;
-                this.log(statement);
-                await this.client.query(statement);
+                this.syncLog(statement);
+                if (this.sync)
+                    await this.client.query(statement);
+            };
+            const setDefault = async (isNull) => {
+                if (defaultValue !== undefined) {
+                    let statement = `ALTER TABLE ${tableName} ALTER COLUMN ${fieldName} SET DEFAULT ${defaultValue}`;
+                    this.syncLog(statement);
+                    if (this.sync)
+                        await this.client.query(statement);
+                    if (isNull) {
+                        statement = `UPDATE ${tableName} SET ${fieldName} = ${defaultValue} WHERE ${fieldName} IS NULL`;
+                        this.syncLog(statement);
+                        if (this.sync)
+                            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);
+                        this.syncLog(statement);
+                        if (this.sync)
+                            await this.client.query(statement);
+                        await setDefault(attnotnull);
                     }
                 }
                 else if (defaultValue === undefined) {
@@ -202,21 +213,20 @@ 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(", ")})`;
-                this.log(statement);
-                await this.client.query(statement);
+            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.syncLog(statement);
+                if (this.sync)
+                    await this.client.query(statement);
             }
         }
     }
@@ -224,10 +234,12 @@ class PGDB extends db_1.DB {
         if (!table.autoIncrementOwn)
             return;
         const statement = `ALTER SEQUENCE ${table.tableName}_id_seq OWNED BY ${table.tableName}.id`;
-        this.log(statement);
-        await this.client.query(statement);
+        this.syncLog(statement);
+        if (this.sync)
+            await this.client.query(statement);
     }
     async syncTable(table) {
+        var _a;
         if (table.autoIncrement) {
             await (async () => {
                 try {
@@ -238,8 +250,9 @@ class PGDB extends db_1.DB {
                         return;
                     if (e.code === "42P01") {
                         const statement = `CREATE SEQUENCE ${table.tableName}_id_seq`;
-                        this.log(statement);
-                        await this.client.query(statement);
+                        this.syncLog(statement);
+                        if (this.sync)
+                            await this.client.query(statement);
                         table.autoIncrementOwn = true;
                         return;
                     }
@@ -256,7 +269,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;
             }
@@ -265,8 +278,9 @@ class PGDB extends db_1.DB {
             if (drop) {
                 const statement = `DROP TABLE ${table.tableName} CASCADE`;
                 create = true;
-                this.log(statement);
-                await this.client.query(statement);
+                this.syncLog(statement);
+                if (this.sync)
+                    await this.client.query(statement);
             }
         }
         else
@@ -274,10 +288,11 @@ class PGDB extends db_1.DB {
         if (create) {
             const parent = table.parent ? ` INHERITS (${table.parent.tableName})` : "";
             const statement = `CREATE TABLE ${table.tableName} ()${parent}`;
-            this.log(statement);
-            await this.client.query(statement);
+            this.syncLog(statement);
+            if (this.sync)
+                await this.client.query(statement);
             const resTable = await this.client.query("SELECT oid FROM pg_class WHERE relname = $1", [table.tableName]);
-            table.oid = resTable.rows[0].oid;
+            table.oid = (_a = resTable.rows[0]) === null || _a === void 0 ? void 0 : _a.oid;
         }
     }
 }

package/lib/pgdb.ts

@@ -1,6 +1,7 @@
 import { Pool, PoolClient, PoolConfig } from "pg";
 import format from "pg-format";
-import { DB, Entry, Field, IndexDef, Natural, Table } from "sedentary/lib/db";
+import { Attribute, DB, Index, Natural, Table } from "sedentary/lib/db";
+import { adsrc } from "./adsrc";
 
 const needDrop = [
   ["DATETIME", "int2"],
@@ -36,84 +37,69 @@ 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.syncLog(statement);
+        if(this.sync) await this.client.query(statement);
+      } else indexes.push(row.conindid);
     }
+
+    return indexes;
   }
 
   async dropField(tableName: string, fieldName: string): Promise<void> {
     const statement = `ALTER TABLE ${tableName} DROP COLUMN ${fieldName}`;
 
-    this.log(statement);
-    await this.client.query(statement);
+    this.syncLog(statement);
+    if(this.sync) await this.client.query(statement);
   }
 
   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];
       }
     }
 
     for(const index of Object.keys(iobject).sort()) {
       const statement = `DROP INDEX ${index}`;
 
-      this.log(statement);
-      await this.client.query(statement);
+      this.syncLog(statement);
+      if(this.sync) await this.client.query(statement);
     }
   }
 
@@ -121,8 +107,8 @@ export class PGDB extends DB {
     await this.pool.end();
   }
 
-  fieldType(field: Field<Natural, Entry>): string[] {
-    const { size, type } = field;
+  fieldType(attribute: Attribute<Natural, unknown>): string[] {
+    const { size, type } = attribute;
     let ret;
 
     switch(type) {
@@ -141,11 +127,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,101 +142,113 @@ 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);
+        this.syncLog(statement);
+        if(this.sync) await this.client.query(statement);
       }
     }
   }
 
   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 where = "attrelid = $1 AND attnum > 0 AND atttypid = pg_type.oid AND attislocal = 't' AND attname = $2";
 
       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(this.version)} FROM pg_type, pg_attribute LEFT JOIN pg_attrdef ON adrelid = attrelid AND adnum = attnum WHERE ${where}`,
         [oid, fieldName]
       );
 
       const addField = async () => {
         const statement = `ALTER TABLE ${tableName} ADD COLUMN ${fieldName} ${type}`;
 
-        this.log(statement);
-        await this.client.query(statement);
+        this.syncLog(statement);
+        if(this.sync) await this.client.query(statement);
       };
 
       const dropDefault = async () => {
         const statement = `ALTER TABLE ${tableName} ALTER COLUMN ${fieldName} DROP DEFAULT`;
 
-        this.log(statement);
-        await this.client.query(statement);
+        this.syncLog(statement);
+        if(this.sync) 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);
+        this.syncLog(statement);
+        if(this.sync) 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.syncLog(statement);
+          if(this.sync) await this.client.query(statement);
+
+          if(isNull) {
+            statement = `UPDATE ${tableName} SET ${fieldName} = ${defaultValue} WHERE ${fieldName} IS NULL`;
 
-        this.log(statement);
-        await this.client.query(statement);
+            this.syncLog(statement);
+            if(this.sync) 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);
+            this.syncLog(statement);
+            if(this.sync) await this.client.query(statement);
+            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,13 +257,13 @@ 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);
+        this.syncLog(statement);
+        if(this.sync) await this.client.query(statement);
       }
     }
   }
@@ -275,8 +273,8 @@ export class PGDB extends DB {
 
     const statement = `ALTER SEQUENCE ${table.tableName}_id_seq OWNED BY ${table.tableName}.id`;
 
-    this.log(statement);
-    await this.client.query(statement);
+    this.syncLog(statement);
+    if(this.sync) await this.client.query(statement);
   }
 
   async syncTable(table: Table): Promise<void> {
@@ -289,8 +287,8 @@ export class PGDB extends DB {
           if(e.code === "42P01") {
             const statement = `CREATE SEQUENCE ${table.tableName}_id_seq`;
 
-            this.log(statement);
-            await this.client.query(statement);
+            this.syncLog(statement);
+            if(this.sync) await this.client.query(statement);
             table.autoIncrementOwn = true;
 
             return;
@@ -312,7 +310,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;
@@ -321,8 +319,8 @@ export class PGDB extends DB {
         const statement = `DROP TABLE ${table.tableName} CASCADE`;
 
         create = true;
-        this.log(statement);
-        await this.client.query(statement);
+        this.syncLog(statement);
+        if(this.sync) await this.client.query(statement);
       }
     } else create = true;
 
@@ -330,12 +328,12 @@ export class PGDB extends DB {
       const parent = table.parent ? ` INHERITS (${table.parent.tableName})` : "";
       const statement = `CREATE TABLE ${table.tableName} ()${parent}`;
 
-      this.log(statement);
-      await this.client.query(statement);
+      this.syncLog(statement);
+      if(this.sync) await this.client.query(statement);
 
       const resTable = await this.client.query("SELECT oid FROM pg_class WHERE relname = $1", [table.tableName]);
 
-      table.oid = resTable.rows[0].oid;
+      table.oid = resTable.rows[0]?.oid;
     }
   }
 }

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.13"
+    "sedentary": "0.0.17"
   },
   "description": "The ORM which never needs to migrate - PostgreSQL",
   "devDependencies": {
     "@types/mocha": "9.0.0",
-    "@types/node": "16.11.7",
+    "@types/node": "16.11.10",
     "@types/yamljs": "0.2.31",
-    "@typescript-eslint/eslint-plugin": "5.3.1",
-    "@typescript-eslint/parser": "5.3.1",
-    "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.13"
+  "version": "0.0.17"
 }