sedentary-pg 0.0.13 → 0.0.14

package/index.d.ts

@@ -1,5 +1,8 @@
-import { SchemaOptions, Sedentary } from "sedentary";
+import { SchemaOptions as SedentarySchemaOptions, Sedentary } from "sedentary";
 import { PoolConfig } from "pg";
+export interface SchemaOptions extends SedentarySchemaOptions {
+    serverless?: boolean;
+}
 export declare class SedentaryPG extends Sedentary {
     constructor(connection: PoolConfig, options?: SchemaOptions);
 }

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,12 +7,12 @@ 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[];
+    fieldType(attribute: Attribute<Natural, unknown>): string[];
     sync(): Promise<void>;
     syncConstraints(table: Table): Promise<void>;
     syncFields(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.attributes.filter(f => f.fieldName === res.rows[i].attname).length === 0)
                 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":
@@ -128,26 +115,35 @@ 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 res = await this.client.query(`SELECT attnotnull, atttypmod, typname, ${this.version >= 12 ? "pg_get_expr(pg_attrdef.adbin, pg_attrdef.adrelid) AS adsrc" : "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 +154,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 +161,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 +201,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);
             }

package/lib/pgdb.ts

@@ -1,6 +1,6 @@
 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";
 
 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.attributes.filter(f => f.fieldName === res.rows[i].attname).length === 0) 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<Natural, Entry>): string[] {
-    const { size, type } = field;
+  fieldType(attribute: Attribute<Natural, unknown>): string[] {
+    const { size, type } = attribute;
     let ret;
 
     switch(type) {
@@ -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,16 +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 res = await this.client.query(
-        `SELECT *${
-          this.version >= 12 ? ", pg_get_expr(pg_attrdef.adbin, pg_attrdef.adrelid) AS adsrc" : ""
+        `SELECT attnotnull, atttypmod, typname, ${
+          this.version >= 12 ? "pg_get_expr(pg_attrdef.adbin, pg_attrdef.adrelid) AS adsrc" : "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 +197,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 +257,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);

package/package.json

@@ -6,7 +6,7 @@
     "@types/pg-format": "1.0.2",
     "pg": "8.7.1",
     "pg-format": "1.0.4",
-    "sedentary": "0.0.13"
+    "sedentary": "0.0.14"
   },
   "description": "The ORM which never needs to migrate - PostgreSQL",
   "devDependencies": {
@@ -59,5 +59,5 @@
     "version": "node -r ts-node/register utils.ts version"
   },
   "types": "index.d.ts",
-  "version": "0.0.13"
+  "version": "0.0.14"
 }