sedentary 0.0.15 → 0.0.19

package/lib/minidb.js

@@ -21,40 +21,47 @@ class MiniDB extends db_1.DB {
         }
     }
     async dropConstraints(table) {
-        const { constraints } = this.body.tables[table.tableName];
+        const { constraints } = this.body.tables[table.tableName] || { constraints: { f: {}, u: {} } };
         for (const constraint of Object.keys(constraints.f).sort()) {
-            if (!table.constraints.filter(({ constraintName, type }) => constraintName === constraint && type === "f").length) {
-                this.log(`'${table.tableName}': Removing foreign key: '${constraint}'`);
-                delete constraints.f[constraint];
+            const arr = table.constraints.filter(({ constraintName, type }) => constraintName === constraint && type === "f");
+            const dbOptions = arr.length ? arr[0].attribute.foreignKey.options : { onDelete: "delete", onUpdate: "delete" };
+            const inOptions = constraints.f[constraint].options;
+            if (dbOptions.onDelete !== inOptions.onDelete || dbOptions.onUpdate !== inOptions.onUpdate) {
+                this.syncLog(`'${table.tableName}': Removing foreign key: '${constraint}'`);
+                if (this.sync)
+                    delete constraints.f[constraint];
             }
         }
         for (const constraint of Object.keys(constraints.u).sort()) {
             if (!table.constraints.filter(({ constraintName, type }) => constraintName === constraint && type === "u").length) {
-                this.log(`'${table.tableName}': Removing unique constraint from field: '${constraints.u[constraint].fieldName}'`);
-                delete constraints.u[constraint];
+                this.syncLog(`'${table.tableName}': Removing unique constraint from field: '${constraints.u[constraint].on}'`);
+                if (this.sync)
+                    delete constraints.u[constraint];
             }
         }
         await this.save();
         return [];
     }
     async dropFields(table) {
-        const { fields } = this.body.tables[table.tableName];
-        for (const attribute in fields) {
+        const { fields } = this.body.tables[table.tableName] || { fields: {} };
+        for (const attribute of Object.keys(fields).sort()) {
             if (!table.findField(attribute)) {
-                this.log(`'${table.tableName}': Removing field: '${attribute}'`);
-                delete fields[attribute];
+                this.syncLog(`'${table.tableName}': Removing field: '${attribute}'`);
+                if (this.sync)
+                    delete fields[attribute];
             }
         }
         await this.save();
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     async dropIndexes(table, constraintIndexes) {
-        const { indexes } = this.body.tables[table.tableName];
-        for (const name in indexes) {
+        const { indexes } = this.body.tables[table.tableName] || { indexes: {} };
+        for (const name of Object.keys(indexes).sort()) {
             const index = table.indexes.filter(_ => _.indexName === name);
             if (index.length === 0 || !this.indexesEq(indexes[name], index[0])) {
-                this.log(`'${table.tableName}': Removing index: '${name}'`);
-                delete indexes[name];
+                this.syncLog(`'${table.tableName}': Removing index: '${name}'`);
+                if (this.sync)
+                    delete indexes[name];
             }
         }
         await this.save();
@@ -64,72 +71,84 @@ class MiniDB extends db_1.DB {
         await writeFile(this.file, JSON.stringify(this.body));
     }
     async syncConstraints(table) {
-        const { constraints } = this.body.tables[table.tableName];
+        const { constraints } = this.body.tables[table.tableName] || { constraints: { f: {}, u: {} } };
         for (const constraint of table.constraints) {
-            const { constraintName, type } = constraint;
-            const { fieldName, foreignKey } = constraint.attribute;
+            const { attribute, constraintName, type } = constraint;
             if (!constraints[type][constraintName]) {
-                switch (type) {
-                    case "f":
-                        this.log(`'${table.tableName}': Adding foreign key '${constraint.constraintName}' on field: '${fieldName}' references '${foreignKey.tableName}(${foreignKey.fieldName})'`);
-                        constraints[type][constraintName] = { fieldName, toField: foreignKey.fieldName, toTable: foreignKey.tableName };
-                        break;
-                    case "u":
-                        this.log(`'${table.tableName}': Adding unique constraint on field: '${fieldName}'`);
-                        constraints[type][constraintName] = { fieldName };
-                        break;
+                if (type === "f") {
+                    const { fieldName, options, tableName } = attribute.foreignKey;
+                    const onDelete = options.onDelete !== "no action" ? ` on delete ${options.onDelete}` : "";
+                    const onUpdate = options.onUpdate !== "no action" ? ` on update ${options.onUpdate}` : "";
+                    this.syncLog(`'${table.tableName}': Adding foreign key '${constraint.constraintName}' on field: '${attribute.fieldName}' references '${tableName}(${fieldName})'${onDelete}${onUpdate}`);
+                    if (this.sync)
+                        constraints[type][constraintName] = { on: attribute.fieldName, options, fieldName, tableName };
+                }
+                else {
+                    this.syncLog(`'${table.tableName}': Adding unique constraint on field: '${attribute.fieldName}'`);
+                    if (this.sync)
+                        constraints[type][constraintName] = { on: attribute.fieldName };
                 }
             }
         }
         await this.save();
     }
     async syncIndexes(table) {
-        const { indexes } = this.body.tables[table.tableName];
+        const { indexes } = this.body.tables[table.tableName] || { indexes: {} };
         for (const index of table.indexes) {
             const { indexName } = index;
             if (!(indexName in indexes)) {
-                this.log(`'${table.tableName}': Adding index: '${indexName}' on (${index.fields.map(_ => `'${_}'`).join(", ")}) type '${index.type}'${index.unique ? " unique" : ""}`);
-                indexes[indexName] = index;
+                this.syncLog(`'${table.tableName}': Adding index: '${indexName}' on (${index.fields.map(_ => `'${_}'`).join(", ")}) type '${index.type}'${index.unique ? " unique" : ""}`);
+                if (this.sync)
+                    indexes[indexName] = index;
             }
         }
         await this.save();
     }
     async syncFields(table) {
         for (const attribute of table.attributes) {
-            const { fields } = this.body.tables[table.tableName];
+            const { fields } = this.body.tables[table.tableName] || { fields: {} };
             const { defaultValue, fieldName, notNull, size, type } = attribute;
             let field = fields[fieldName];
             if (!field) {
-                this.log(`'${table.tableName}': Adding field: '${fieldName}' '${type}' '${size || ""}'`);
-                field = fields[fieldName] = { size, type };
+                this.syncLog(`'${table.tableName}': Adding field: '${fieldName}' '${type}' '${size || ""}'`);
+                if (this.sync)
+                    field = fields[fieldName] = { size, type };
+                else
+                    field = {};
             }
             if (field.size !== size || field.type !== type) {
-                this.log(`'${table.tableName}': Changing field type: '${fieldName}' '${type}' '${size || ""}'`);
-                field = fields[fieldName] = Object.assign(Object.assign({}, field), { size, type });
+                this.syncLog(`'${table.tableName}': Changing field type: '${fieldName}' '${type}' '${size || ""}'`);
+                if (this.sync)
+                    field = fields[fieldName] = Object.assign(Object.assign({}, field), { size, type });
             }
             if (field.default) {
                 if (!defaultValue) {
-                    this.log(`'${table.tableName}': Dropping default value for field: '${fieldName}'`);
-                    delete field.default;
+                    this.syncLog(`'${table.tableName}': Dropping default value for field: '${fieldName}'`);
+                    if (this.sync)
+                        delete field.default;
                 }
                 else if (field.default !== defaultValue) {
-                    this.log(`'${table.tableName}': Changing default value to '${defaultValue}' for field: '${fieldName}'`);
-                    field.default = defaultValue;
+                    this.syncLog(`'${table.tableName}': Changing default value to '${defaultValue}' for field: '${fieldName}'`);
+                    if (this.sync)
+                        field.default = defaultValue;
                 }
             }
             else if (defaultValue) {
-                this.log(`'${table.tableName}': Setting default value '${defaultValue instanceof Date ? defaultValue.toISOString() : defaultValue}' for field: '${fieldName}'`);
-                field.default = defaultValue;
+                this.syncLog(`'${table.tableName}': Setting default value '${defaultValue instanceof Date ? defaultValue.toISOString() : defaultValue}' for field: '${fieldName}'`);
+                if (this.sync)
+                    field.default = defaultValue;
             }
             if (field.notNull) {
                 if (!notNull) {
-                    this.log(`'${table.tableName}': Dropping not null for field: '${fieldName}'`);
-                    delete field.notNull;
+                    this.syncLog(`'${table.tableName}': Dropping not null for field: '${fieldName}'`);
+                    if (this.sync)
+                        delete field.notNull;
                 }
             }
             else if (notNull) {
-                this.log(`'${table.tableName}': Setting not null for field: '${fieldName}'`);
-                field.notNull = true;
+                this.syncLog(`'${table.tableName}': Setting not null for field: '${fieldName}'`);
+                if (this.sync)
+                    field.notNull = true;
             }
         }
         await this.save();
@@ -145,20 +164,24 @@ class MiniDB extends db_1.DB {
                 }
                 else if (!this.body.tables[table.tableName].parent)
                     return;
-                this.log(`Removing table: '${table.tableName}'`);
-                delete this.body.tables[table.tableName];
+                this.syncLog(`Removing table: '${table.tableName}'`);
+                if (this.sync)
+                    delete this.body.tables[table.tableName];
             })();
         }
         if (!this.body.tables[table.tableName]) {
-            this.log(`Adding table: '${table.tableName}'`);
-            this.body.tables[table.tableName] = { constraints: { f: {}, u: {} }, fields: {}, indexes: {} };
+            this.syncLog(`Adding table: '${table.tableName}'`);
+            if (this.sync)
+                this.body.tables[table.tableName] = { constraints: { f: {}, u: {} }, fields: {}, indexes: {} };
             if (table.parent) {
-                this.log(`Setting parent: '${table.parent.tableName}' - to table: '${table.tableName}'`);
-                this.body.tables[table.tableName].parent = table.parent.tableName;
+                this.syncLog(`Setting parent: '${table.parent.tableName}' - to table: '${table.tableName}'`);
+                if (this.sync)
+                    this.body.tables[table.tableName].parent = table.parent.tableName;
             }
             if (table.autoIncrement && !this.body.next[table.tableName]) {
-                this.log(`Setting auto increment: '${table.tableName}'`);
-                this.body.next[table.tableName] = 1;
+                this.syncLog(`Setting auto increment: '${table.tableName}'`);
+                if (this.sync)
+                    this.body.next[table.tableName] = 1;
             }
         }
         await this.save();

package/package.json

@@ -5,16 +5,17 @@
   "description": "The ORM which never needs to migrate",
   "devDependencies": {
     "@types/mocha": "9.0.0",
-    "@types/node": "16.11.10",
+    "@types/node": "17.0.0",
     "@types/yamljs": "0.2.31",
-    "@typescript-eslint/eslint-plugin": "5.4.0",
-    "@typescript-eslint/parser": "5.4.0",
-    "eslint": "8.3.0",
+    "@typescript-eslint/eslint-plugin": "5.7.0",
+    "@typescript-eslint/parser": "5.7.0",
+    "eslint": "8.5.0",
     "mocha": "9.1.3",
     "nyc": "15.1.0",
-    "prettier": "2.5.0",
+    "prettier": "2.5.1",
     "ts-node": "10.4.0",
-    "typescript": "4.5.2",
+    "tsd": "0.19.0",
+    "typescript": "4.5.4",
     "yamljs": "0.3.0"
   },
   "engines": {
@@ -55,6 +56,11 @@
     "tsc": "tsc --declaration",
     "version": "node -r ts-node/register utils.ts version"
   },
+  "tsd": {
+    "compilerOptions": {
+      "strict": false
+    }
+  },
   "types": "index.d.ts",
-  "version": "0.0.15"
+  "version": "0.0.19"
 }

package/requirements.txt

@@ -0,0 +1,2 @@
+sphinx
+sphinx_rtd_theme

package/sedentary-pg/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2017 Daniele Ricci
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/sedentary-pg/README.md

@@ -1,34 +0,0 @@
-# sedentary-pg
-
-[![Build Status][travis-badge]][travis-url]
-[![Code Climate][code-badge]][code-url]
-[![Test Coverage][cover-badge]][code-url]
-
-[![NPM version][npm-badge]][npm-url]
-[![NPM downloads][npm-downloads-badge]][npm-url]
-[![Stars][stars-badge]][github-url]
-
-[![Types][types-badge]][npm-url]
-[![Dependents][deps-badge]][npm-url]
-[![Donate][donate-badge]][donate-url]
-
-[code-badge]: https://codeclimate.com/github/iccicci/sedentary-pg/badges/gpa.svg
-[code-url]: https://codeclimate.com/github/iccicci/sedentary-pg
-[cover-badge]: https://codeclimate.com/github/iccicci/sedentary-pg/badges/coverage.svg
-[deps-badge]: https://badgen.net/npm/dependents/sedentary-pg?icon=npm&cache=300
-[donate-badge]: https://badgen.net/badge/donate/bitcoin?icon=bitcoin&cache=300
-[donate-url]: https://blockchain.info/address/1Md9WFAHrXTb3yPBwQWmUfv2RmzrtbHioB
-[github-url]: https://github.com/iccicci/sedentary-pg
-[npm-downloads-badge]: https://badgen.net/npm/dw/sedentary-pg?icon=npm&cache=300
-[npm-badge]: https://badgen.net/npm/v/sedentary-pg?color=green&icon=npm&cache=300
-[npm-url]: https://www.npmjs.com/package/sedentary-pg
-[stars-badge]: https://badgen.net/github/stars/iccicci/sedentary-pg?icon=github&cache=300
-[travis-badge]: https://badgen.net/travis/iccicci/sedentary-pg?icon=travis&cache=300
-[travis-url]: https://app.travis-ci.com/github/iccicci/sedentary-pg
-[types-badge]: https://badgen.net/npm/types/sedentary-pg?color=green&icon=typescript&cache=300
-
-# under development
-
-https://www.postgresql.org/support/versioning/
-
-https://bucardo.org/postgres_all_versions.html

package/sedentary-pg/lib/pgdb.ts

@@ -1,340 +0,0 @@
-import { Pool, PoolClient, PoolConfig } from "pg";
-import format from "pg-format";
-import { Attribute, DB, Index, Natural, Table } from "sedentary/lib/db";
-
-const needDrop = [
-  ["DATETIME", "int2"],
-  ["DATETIME", "int4"],
-  ["DATETIME", "int8"],
-  ["INT", "timestamptz"],
-  ["INT8", "timestamptz"]
-];
-const needUsing = [
-  ["DATETIME", "varchar"],
-  ["INT", "varchar"],
-  ["INT8", "varchar"]
-];
-const types = { int2: "SMALLINT", int4: "INTEGER", int8: "BIGINT", varchar: "VARCHAR" };
-
-export class PGDB extends DB {
-  private client: PoolClient;
-  private indexes: string[];
-  private pool: Pool;
-  private version: number;
-
-  constructor(connection: PoolConfig, log: (message: string) => void) {
-    super(log);
-
-    this.pool = new Pool(connection);
-  }
-
-  async connect(): Promise<void> {
-    this.client = await this.pool.connect();
-
-    const res = await this.client.query("SELECT version()");
-
-    this.version = parseInt(res.rows[0].version.split(" ")[1].split(".")[0], 10);
-  }
-
-  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 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: string, fieldName: string): Promise<void> {
-    const statement = `ALTER TABLE ${tableName} DROP COLUMN ${fieldName}`;
-
-    this.log(statement);
-    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.findField(res.rows[i].attname)) await this.dropField(table.tableName, res.rows[i].attname);
-  }
-
-  async dropIndexes(table: Table, constraintIndexes: number[]): Promise<void> {
-    const { indexes, oid } = table;
-    const iobject: { [key: string]: Index } = {};
-    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, 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 { 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);
-    }
-  }
-
-  async end(): Promise<void> {
-    await this.pool.end();
-  }
-
-  fieldType(attribute: Attribute<Natural, unknown>): string[] {
-    const { size, type } = attribute;
-    let ret;
-
-    switch(type) {
-    case "DATETIME":
-      return ["DATETIME", "TIMESTAMP (3) WITH TIME ZONE"];
-    case "INT":
-      ret = size === 2 ? "SMALLINT" : "INTEGER";
-
-      return [ret, ret];
-    case "INT8":
-      return ["BIGINT", "BIGINT"];
-    case "VARCHAR":
-      return ["VARCHAR", "VARCHAR" + (size ? `(${size})` : "")];
-    }
-
-    throw new Error(`Unknown type: '${type}', '${size}'`);
-  }
-
-  async syncDataBase(): Promise<void> {
-    let err: Error;
-
-    try {
-      await super.syncDataBase();
-    } catch(e) {
-      err = e;
-    }
-
-    this.client.release();
-
-    if(err) throw err;
-  }
-
-  async syncConstraints(table: Table): Promise<void> {
-    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,
-        attribute.fieldName
-      ]);
-
-      if(! res.rowCount) {
-        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);
-      }
-    }
-  }
-
-  async syncFields(table: Table): Promise<void> {
-    const { attributes, oid, tableName } = table;
-
-    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 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);
-        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 setNotNull = async (isNull: boolean) => {
-        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);
-      };
-
-      const setDefault = async (isNull: boolean) => {
-        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(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]) => attribute.type === type && typname === name).length) {
-            await this.dropField(tableName, fieldName);
-            await addField();
-            await setDefault(false);
-          } else {
-            if(adsrc) dropDefault();
-
-            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(attnotnull);
-          }
-        } else if(defaultValue === undefined) {
-          if(adsrc) dropDefault();
-          await setNotNull(attnotnull);
-        } else if(! adsrc || adsrc.split("::")[0] !== defaultValue) await setDefault(attnotnull);
-      }
-    }
-  }
-
-  async syncIndexes(table: Table): Promise<void> {
-    const { indexes, tableName } = table;
-
-    for(const index of indexes) {
-      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);
-      }
-    }
-  }
-
-  async syncSequence(table: Table): Promise<void> {
-    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);
-  }
-
-  async syncTable(table: Table): Promise<void> {
-    if(table.autoIncrement) {
-      await (async () => {
-        try {
-          await this.client.query(`SELECT currval('${table.tableName}_id_seq')`);
-        } catch(e) {
-          if(e.code === "55000") return;
-          if(e.code === "42P01") {
-            const statement = `CREATE SEQUENCE ${table.tableName}_id_seq`;
-
-            this.log(statement);
-            await this.client.query(statement);
-            table.autoIncrementOwn = true;
-
-            return;
-          }
-
-          throw e;
-        }
-      })();
-    }
-
-    let create: boolean;
-    const resTable = await this.client.query("SELECT oid FROM pg_class WHERE relname = $1", [table.tableName]);
-
-    if(resTable.rowCount) {
-      table.oid = resTable.rows[0].oid;
-
-      let drop: boolean;
-      const resParent = await this.client.query("SELECT inhparent FROM pg_inherits WHERE inhrelid = $1", [table.oid]);
-
-      if(resParent.rowCount) {
-        if(! table.parent) drop = true;
-        else if(this.findTable(table.parent.tableName).oid === resParent.rows[0].inhparent) return;
-
-        drop = true;
-      } else if(table.parent) drop = true;
-
-      if(drop) {
-        const statement = `DROP TABLE ${table.tableName} CASCADE`;
-
-        create = true;
-        this.log(statement);
-        await this.client.query(statement);
-      }
-    } else create = true;
-
-    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);
-
-      const resTable = await this.client.query("SELECT oid FROM pg_class WHERE relname = $1", [table.tableName]);
-
-      table.oid = resTable.rows[0].oid;
-    }
-  }
-}
-
-// farray[0].defaultValue = "nextval('" + tname + "_id_seq'::regclass)";