sedentary-pg 0.0.17 → 0.0.22

package/README.md

@@ -33,6 +33,34 @@
 
 The **PostgreSQL** specilized package of [Sedentary](https://www.npmjs.com/package/sedentary).
 
+# Usage
+
+```javascript
+import { SedentaryPG } from "sedentary-pg";
+
+const db = new SedentaryPG(/* PG connection */);
+
+class Items extends db.model("Item", {
+  num: db.INT,
+  str: db.VARCHAR(30)
+});
+
+(async function () {
+  await db.connect();
+
+  const item = Items.create();
+
+  item.num = 0;
+  item.str = "0";
+
+  await item.save();
+
+  const records = await Items.load({});
+
+  console.log(records); // [{ id: 1, num: 0, str: "0" }]
+})();
+```
+
 # Installation
 
 With [npm](https://www.npmjs.com/package/sedentary-pg):

package/index.d.ts

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

package/index.js

@@ -1,12 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Package = exports.SedentaryPG = exports.Type = exports.Entry = void 0;
+exports.Package = exports.SedentaryPG = exports.Type = exports.EntryBase = 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; } });
+Object.defineProperty(exports, "EntryBase", { enumerable: true, get: function () { return sedentary_2.EntryBase; } });
+Object.defineProperty(exports, "Type", { enumerable: true, get: function () { return sedentary_2.Type; } });
 class SedentaryPG extends sedentary_1.Sedentary {
     constructor(connection, options) {
         super("", options);
@@ -14,11 +13,11 @@ 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) {
+    FKEY(attribute, options) {
         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);
+        return super.FKEY(attribute, options);
     }
 }
 exports.SedentaryPG = SedentaryPG;

package/lib/pgdb.js

@@ -21,10 +21,14 @@ const needUsing = [
     ["INT8", "varchar"]
 ];
 const types = { int2: "SMALLINT", int4: "INTEGER", int8: "BIGINT", varchar: "VARCHAR" };
+const actions = { cascade: "c", "no action": "a", restrict: "r", "set default": "d", "set null": "n" };
 class PGDB extends db_1.DB {
     constructor(connection, log) {
         super(log);
+        this.client = {};
+        this.indexes = [];
         this.pool = new pg_1.Pool(connection);
+        this.version = 0;
     }
     async connect() {
         this.client = await this.pool.connect();
@@ -33,17 +37,25 @@ class PGDB extends db_1.DB {
     }
     async dropConstraints(table) {
         const indexes = [];
-        const res = await this.client.query("SELECT * FROM pg_constraint WHERE conrelid = $1 ORDER BY conname", [table.oid]);
+        const res = await this.client.query("SELECT confdeltype, confupdtype, conindid, conname, contype 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 arr = table.constraints.filter(_ => _.constraintName === row.conname && _.type === row.contype);
+            let drop = false;
+            if (arr.length === 0)
+                drop = true;
+            else if (row.contype === "u")
+                indexes.push(row.conindid);
+            else {
+                const { options } = arr[0].attribute.foreignKey;
+                if (actions[options.onDelete] !== row.confdeltype || actions[options.onUpdate] !== row.confupdtype)
+                    drop = true;
+            }
+            if (drop) {
                 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;
     }
@@ -127,14 +139,14 @@ class PGDB extends db_1.DB {
             ]);
             if (!res.rowCount) {
                 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;
+                if (type === "f") {
+                    const { fieldName, options, tableName } = attribute.foreignKey;
+                    const onDelete = options.onDelete !== "no action" ? ` ON DELETE ${options.onDelete.toUpperCase()}` : "";
+                    const onUpdate = options.onUpdate !== "no action" ? ` ON UPDATE ${options.onUpdate.toUpperCase()}` : "";
+                    query = `FOREIGN KEY (${attribute.fieldName}) REFERENCES ${tableName}(${fieldName})${onDelete}${onUpdate}`;
                 }
+                else
+                    query = `UNIQUE(${attribute.fieldName})`;
                 const statement = `ALTER TABLE ${table.tableName} ADD CONSTRAINT ${constraintName} ${query}`;
                 this.syncLog(statement);
                 if (this.sync)
@@ -246,9 +258,9 @@ class PGDB extends db_1.DB {
                     await this.client.query(`SELECT currval('${table.tableName}_id_seq')`);
                 }
                 catch (e) {
-                    if (e.code === "55000")
+                    if (e instanceof pg_1.DatabaseError && e.code === "55000")
                         return;
-                    if (e.code === "42P01") {
+                    if (e instanceof pg_1.DatabaseError && e.code === "42P01") {
                         const statement = `CREATE SEQUENCE ${table.tableName}_id_seq`;
                         this.syncLog(statement);
                         if (this.sync)
@@ -260,11 +272,11 @@ class PGDB extends db_1.DB {
                 }
             })();
         }
-        let create;
+        let create = false;
         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;
+            let drop = false;
             const resParent = await this.client.query("SELECT inhparent FROM pg_inherits WHERE inhrelid = $1", [table.oid]);
             if (resParent.rowCount) {
                 if (!table.parent)

package/lib/pgdb.ts

@@ -1,6 +1,6 @@
-import { Pool, PoolClient, PoolConfig } from "pg";
+import { DatabaseError, Pool, PoolClient, PoolConfig } from "pg";
 import format from "pg-format";
-import { Attribute, DB, Index, Natural, Table } from "sedentary/lib/db";
+import { Attribute, DB, ForeignKeyActions, Index, Natural, Table } from "sedentary/lib/db";
 import { adsrc } from "./adsrc";
 
 const needDrop = [
@@ -17,6 +17,8 @@ const needUsing = [
 ];
 const types = { int2: "SMALLINT", int4: "INTEGER", int8: "BIGINT", varchar: "VARCHAR" };
 
+const actions: { [k in ForeignKeyActions]: string } = { cascade: "c", "no action": "a", restrict: "r", "set default": "d", "set null": "n" };
+
 export class PGDB extends DB {
   private client: PoolClient;
   private indexes: string[];
@@ -26,7 +28,10 @@ export class PGDB extends DB {
   constructor(connection: PoolConfig, log: (message: string) => void) {
     super(log);
 
+    this.client = {} as PoolClient;
+    this.indexes = [];
     this.pool = new Pool(connection);
+    this.version = 0;
   }
 
   async connect(): Promise<void> {
@@ -39,17 +44,26 @@ export class PGDB extends DB {
 
   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]);
+    const res = await this.client.query("SELECT confdeltype, confupdtype, conindid, conname, contype 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);
+      const arr = table.constraints.filter(_ => _.constraintName === row.conname && _.type === row.contype);
+      let drop = false;
+
+      if(arr.length === 0) drop = true;
+      else if(row.contype === "u") indexes.push(row.conindid);
+      else {
+        const { options } = arr[0].attribute.foreignKey as { attributeName: string; fieldName: string; options: { onDelete: ForeignKeyActions; onUpdate: ForeignKeyActions }; tableName: string };
+
+        if(actions[options.onDelete] !== row.confdeltype || actions[options.onUpdate] !== row.confupdtype) drop = true;
+      }
 
-      if(constraint.length === 0) {
+      if(drop) {
         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;
@@ -128,7 +142,7 @@ export class PGDB extends DB {
   }
 
   async syncDataBase(): Promise<void> {
-    let err: Error;
+    let err: unknown;
 
     try {
       await super.syncDataBase();
@@ -152,14 +166,18 @@ export class PGDB extends DB {
       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;
-        }
+        if(type === "f") {
+          const { fieldName, options, tableName } = attribute.foreignKey as {
+            attributeName: string;
+            fieldName: string;
+            options: { onDelete: ForeignKeyActions; onUpdate: ForeignKeyActions };
+            tableName: string;
+          };
+          const onDelete = options.onDelete !== "no action" ? ` ON DELETE ${options.onDelete.toUpperCase()}` : "";
+          const onUpdate = options.onUpdate !== "no action" ? ` ON UPDATE ${options.onUpdate.toUpperCase()}` : "";
+
+          query = `FOREIGN KEY (${attribute.fieldName}) REFERENCES ${tableName}(${fieldName})${onDelete}${onUpdate}`;
+        } else query = `UNIQUE(${attribute.fieldName})`;
 
         const statement = `ALTER TABLE ${table.tableName} ADD CONSTRAINT ${constraintName} ${query}`;
 
@@ -230,7 +248,7 @@ export class PGDB extends DB {
       } else {
         const { adsrc, attnotnull, atttypmod, typname } = res.rows[0];
 
-        if(types[typname] !== base || (base === "VARCHAR" && (size ? size + 4 !== atttypmod : atttypmod !== -1))) {
+        if(types[typname as keyof typeof types] !== 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();
@@ -283,8 +301,8 @@ export class PGDB extends DB {
         try {
           await this.client.query(`SELECT currval('${table.tableName}_id_seq')`);
         } catch(e) {
-          if(e.code === "55000") return;
-          if(e.code === "42P01") {
+          if(e instanceof DatabaseError && e.code === "55000") return;
+          if(e instanceof DatabaseError && e.code === "42P01") {
             const statement = `CREATE SEQUENCE ${table.tableName}_id_seq`;
 
             this.syncLog(statement);
@@ -299,13 +317,13 @@ export class PGDB extends DB {
       })();
     }
 
-    let create: boolean;
+    let create = false;
     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;
+      let drop = false;
       const resParent = await this.client.query("SELECT inhparent FROM pg_inherits WHERE inhrelid = $1", [table.oid]);
 
       if(resParent.rowCount) {

package/package.json

@@ -1,26 +1,31 @@
 {
   "author": "Daniele Ricci <daniele.icc@gmail.com> (https://github.com/iccicci)",
   "bugs": "https://github.com/iccicci/sedentary-pg/issues",
+  "contributors": [
+    "Daniele Ricci <daniele.icc@gmail.com> (https://github.com/iccicci)",
+    "yossarian <sergiybiluk@gmail.com> (https://github.com/captain-yossarian)"
+  ],
   "dependencies": {
-    "@types/pg": "8.6.1",
-    "@types/pg-format": "1.0.2",
     "pg": "8.7.1",
     "pg-format": "1.0.4",
-    "sedentary": "0.0.17"
+    "sedentary": "0.0.22"
   },
   "description": "The ORM which never needs to migrate - PostgreSQL",
   "devDependencies": {
     "@types/mocha": "9.0.0",
-    "@types/node": "16.11.10",
+    "@types/node": "17.0.5",
+    "@types/pg": "8.6.3",
+    "@types/pg-format": "1.0.2",
     "@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.8.1",
+    "@typescript-eslint/parser": "5.8.1",
+    "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": {
@@ -61,6 +66,23 @@
     "tsc": "tsc --declaration",
     "version": "node -r ts-node/register utils.ts version"
   },
+  "tsd": {
+    "compilerOptions": {
+      "alwaysStrict": true,
+      "declaration": true,
+      "esModuleInterop": true,
+      "module": "commonjs",
+      "noImplicitAny": true,
+      "noImplicitReturns": true,
+      "noImplicitThis": true,
+      "strict": true,
+      "strictBindCallApply": true,
+      "strictFunctionTypes": true,
+      "strictNullChecks": true,
+      "strictPropertyInitialization": true,
+      "target": "es2017"
+    }
+  },
   "types": "index.d.ts",
-  "version": "0.0.17"
+  "version": "0.0.22"
 }