prostgles-server 2.0.176 → 2.0.179

package/lib/DBEventsManager.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DBEventsManager = void 0;
+const PostgresNotifListenManager_1 = require("./PostgresNotifListenManager");
+const prostgles_types_1 = require("prostgles-types");
+class DBEventsManager {
+    constructor(db_pg, pgp) {
+        this.notifies = {};
+        this.notice = {
+            socketChannel: prostgles_types_1.CHANNELS.NOTICE_EV,
+            socketUnsubChannel: prostgles_types_1.CHANNELS.NOTICE_EV + "unsubscribe",
+            sockets: []
+        };
+        this.onNotif = ({ channel, payload }) => {
+            // console.log(36, { channel, payload },  Object.keys(this.notifies));
+            Object.keys(this.notifies)
+                .filter(ch => ch === channel)
+                .map(ch => {
+                const sub = this.notifies[ch];
+                sub.sockets.map(s => {
+                    s.emit(sub.socketChannel, payload);
+                });
+                sub.localFuncs.map(lf => {
+                    lf(payload);
+                });
+            });
+        };
+        this.onNotice = (notice) => {
+            if (this.notice && this.notice.sockets.length) {
+                this.notice.sockets.map(s => {
+                    s.emit(this.notice.socketChannel, notice);
+                });
+            }
+        };
+        this.getNotifChannelName = async (channel) => {
+            const c = await this.db_pg.one("SELECT quote_ident($1) as c", channel);
+            return c.c;
+        };
+        this.db_pg = db_pg;
+        this.pgp = pgp;
+    }
+    async addNotify(query, socket, func) {
+        if (typeof query !== "string" || (!socket && !func)) {
+            throw "Expecting (query: string, socket?, localFunc?) But received: " + JSON.stringify({ query, socket, func });
+        }
+        /* Remove comments */
+        let q = query.trim()
+            .replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, '\n')
+            .split("\n").map(v => v.trim()).filter(v => v && !v.startsWith("--"))
+            .join("\n");
+        /* Find the notify channel name */
+        if (!q.toLowerCase().startsWith("listen")) {
+            throw "Expecting a LISTEN query but got: " + query;
+        }
+        q = q.slice(7).trim(); // Remove listen
+        if (q.endsWith(";"))
+            q = q.slice(0, -1);
+        if (q.startsWith('"') && q.endsWith('"')) {
+            q = q.slice(1, -1);
+        }
+        else {
+            /* Replicate PG by lowercasing identifier if not quoted */
+            q = q.toLowerCase();
+        }
+        q = q.replace(/""/g, `"`);
+        let channel = q;
+        let notifChannel = await this.getNotifChannelName(channel);
+        notifChannel = notifChannel.replace(/""/g, `"`);
+        if (notifChannel.startsWith('"'))
+            notifChannel = notifChannel.slice(1, -1);
+        const socketChannel = prostgles_types_1.CHANNELS.LISTEN_EV + notifChannel, socketUnsubChannel = socketChannel + "unsubscribe";
+        if (!this.notifies[notifChannel]) {
+            this.notifies[notifChannel] = {
+                socketChannel,
+                sockets: socket ? [socket] : [],
+                localFuncs: func ? [func] : [],
+                notifMgr: await PostgresNotifListenManager_1.PostgresNotifListenManager.create(this.db_pg, this.onNotif, channel)
+            };
+        }
+        else {
+            if (socket && !this.notifies[notifChannel].sockets.find(s => s.id === socket.id)) {
+                this.notifies[notifChannel].sockets.push(socket);
+            }
+            else if (func) {
+                this.notifies[notifChannel].localFuncs.push(func);
+            }
+        }
+        if (socket) {
+            socket.removeAllListeners(socketUnsubChannel);
+            socket.on(socketUnsubChannel, () => {
+                this.removeNotify(notifChannel, socket);
+            });
+        }
+        return {
+            // unsubscribe: () => this.removeNotify(notifChannel, socket, func),
+            socketChannel,
+            socketUnsubChannel,
+            notifChannel,
+        };
+    }
+    removeNotify(channel, socket, func) {
+        if (channel && this.notifies[channel]) {
+            if (socket) {
+                this.notifies[channel].sockets = this.notifies[channel].sockets.filter(s => s.id !== socket.id);
+            }
+            else if (func) {
+                this.notifies[channel].localFuncs = this.notifies[channel].localFuncs.filter(f => f !== func);
+            }
+            /* UNLISTEN if no listeners ?? */
+        }
+        if (socket) {
+            (0, prostgles_types_1.getKeys)(this.notifies).forEach(channel => {
+                this.notifies[channel].sockets = this.notifies[channel].sockets.filter(s => s.id !== socket.id);
+            });
+        }
+    }
+    addNotice(socket) {
+        if (!socket || !socket.id)
+            throw "Expecting a socket obj with id";
+        if (!this.notice.sockets.find(s => s.id === socket.id)) {
+            this.notice.sockets.push(socket);
+        }
+        const { socketChannel, socketUnsubChannel } = this.notice;
+        socket.removeAllListeners(socketUnsubChannel);
+        socket.on(socketUnsubChannel, () => {
+            this.removeNotice(socket);
+        });
+        return { socketChannel, socketUnsubChannel, };
+    }
+    removeNotice(socket) {
+        if (!socket || !socket.id)
+            throw "Expecting a socket obj with id";
+        this.notice.sockets = this.notice.sockets.filter(s => s.id !== socket.id);
+    }
+}
+exports.DBEventsManager = DBEventsManager;

package/lib/DBSchemaBuilder.d.ts

@@ -0,0 +1,11 @@
+import { DBSchema, TableHandler, ViewHandler } from "prostgles-types";
+import { DBHandlerServer, DboBuilder } from "./DboBuilder";
+import { PublishAllOrNothing, PublishTableRule, PublishViewRule } from "./PublishParser";
+export declare const getDBSchema: (dboBuilder: DboBuilder) => string;
+export declare type DBOFullyTyped<Schema = void> = Schema extends DBSchema ? ({
+    [tov_name in keyof Schema]: Schema[tov_name]["is_view"] extends true ? ViewHandler<Schema[tov_name]["columns"]> : TableHandler<Schema[tov_name]["columns"]>;
+} & Pick<DBHandlerServer, "tx" | "sql">) : DBHandlerServer;
+export declare type PublishFullyTyped<Schema = void> = Schema extends DBSchema ? (PublishAllOrNothing | {
+    [tov_name in keyof Partial<Schema>]: PublishAllOrNothing | (Schema[tov_name]["is_view"] extends true ? PublishViewRule<Schema[tov_name]["columns"]> : PublishTableRule<Schema[tov_name]["columns"]>);
+}) : (PublishAllOrNothing | Record<string, PublishViewRule | PublishTableRule | PublishAllOrNothing>);
+//# sourceMappingURL=DBSchemaBuilder.d.ts.map

package/lib/DBSchemaBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DBSchemaBuilder.d.ts","sourceRoot":"","sources":["DBSchemaBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAGtE,OAAO,EAAE,eAAe,EAAE,UAAU,EAAmC,MAAM,cAAc,CAAC;AAC5F,OAAO,EAAE,mBAAmB,EAAiB,gBAAgB,EAAE,eAAe,EAAI,MAAM,iBAAiB,CAAC;AAG1G,eAAO,MAAM,WAAW,eAAgB,UAAU,KAAG,MAsBpD,CAAA;AAED,oBAAY,aAAa,CAAC,MAAM,GAAG,IAAI,IAAI,MAAM,SAAS,QAAQ,GAAE,CAChE;KACG,QAAQ,IAAI,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,SAAS,IAAI,GAClE,WAAW,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC,GACxC,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC;CAC5C,GAAG,IAAI,CAAC,eAAe,EAAE,IAAI,GAAG,KAAK,CAAC,CACxC,GACD,eAAe,CAAC;AA+DlB,oBAAY,iBAAiB,CAAC,MAAM,GAAG,IAAI,IAAI,MAAM,SAAS,QAAQ,GAAE,CACpE,mBAAmB,GACnB;KACC,QAAQ,IAAI,MAAM,OAAO,CAAC,MAAM,CAAC,GAC9B,mBAAmB,GACnB,CACA,MAAM,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,SAAS,IAAI,GACtC,eAAe,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC,GAC5C,gBAAgB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC,CAChD;CACJ,CACF,GAAG,CACA,mBAAmB,GACnB,MAAM,CAAC,MAAM,EAAE,eAAe,GAAG,gBAAgB,GAAG,mBAAmB,CAAC,CAC3E,CAAC"}

package/lib/DBSchemaBuilder.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDBSchema = void 0;
+const _1 = __importDefault(require("."));
+const DboBuilder_1 = require("./DboBuilder");
+const getDBSchema = (dboBuilder) => {
+    let tables = [];
+    /** Tables and columns are sorted to avoid infinite loops due to changing order */
+    dboBuilder.tablesOrViews?.slice(0).sort((a, b) => a.name.localeCompare(b.name)).forEach(tov => {
+        const cols = tov.columns.slice(0).sort((a, b) => a.name.localeCompare(b.name));
+        tables.push(`${(0, DboBuilder_1.escapeTSNames)(tov.name)}: {
+    is_view: ${tov.is_view};
+    select: ${tov.privileges.select}
+    insert: ${tov.privileges.insert}
+    update: ${tov.privileges.update}
+    delete: ${tov.privileges.delete}
+    columns: {${cols.map(c => `
+      ${(0, DboBuilder_1.escapeTSNames)(c.name)}${c.is_nullable || c.has_default ? "?" : ""}: ${(0, DboBuilder_1.postgresToTsType)(c.udt_name)}${c.is_nullable ? " | null" : ""}`).join(";")}
+    }
+  };\n  `);
+    });
+    return `
+export type DBSchemaGenerated = {
+  ${tables.join("")}
+}
+`;
+};
+exports.getDBSchema = getDBSchema;
+/** Type checks */
+(() => {
+    const ddb = 1;
+    ddb.dwad.insert;
+    ddb.dwad.delete;
+    const d = 1;
+    d.dwad.insert;
+    d.dwad.delete;
+    const p = 1;
+    p.dbo.dwad.insert;
+    ddb.dwad.delete;
+    (0, _1.default)({
+        dbConnection: 1,
+        publish: async (params) => {
+            const row = await params.dbo.dwadwa.find?.({});
+            return "*";
+        },
+        onReady: (dbo) => {
+            dbo.tdwa.find();
+        }
+    });
+    const auth = {
+        sidKeyName: "sid_token",
+        getUser: async (sid, db, _db) => {
+            db.dwadaw.find;
+            return 1;
+        }
+    };
+});
+/** Test the created schema */
+const c = 1;
+const test = c;
+const db = 1;
+const publish = () => {
+    const r = {
+        tbl1: {
+            select: {
+                fields: "*",
+                forcedFilter: { col1: 32, col2: "" }
+            },
+            getColumns: true,
+            getInfo: true,
+            delete: {
+                filterFields: { col1: 1 }
+            }
+        },
+        tbl2: {
+            delete: { forcedFilter: { col1: 2 } }
+        }
+    };
+    const res = {
+        tbl1: {
+            select: {
+                fields: "*",
+                forcedFilter: { col1: 32, col2: "" }
+            },
+            getColumns: true,
+            getInfo: true,
+            delete: {
+                filterFields: { col1: 1 }
+            }
+        },
+        tbl2: {
+            delete: { forcedFilter: { col1: 2 } }
+        }
+    };
+    const res1 = r;
+    const p = 1;
+    p.dbo.dwadaw.find();
+    return res;
+};

package/lib/DBSchemaBuilder.ts

@@ -1,6 +1,8 @@
-import { DBSchemaColumns, DBSchemaInsertColumns, DBSchema, TableHandler, ViewHandler } from "prostgles-types";
+import { DBSchema, TableHandler, ViewHandler } from "prostgles-types";
+import prostgles from ".";
+import { Auth } from "./AuthHandler";
 import { DBHandlerServer, DboBuilder, escapeTSNames, postgresToTsType } from "./DboBuilder";
-import { PublishAllOrNothing, PublishTableRule, PublishViewRule, TableRule, ViewRule } from "./PublishParser";
+import { PublishAllOrNothing, PublishParams, PublishTableRule, PublishViewRule,  } from "./PublishParser";
 
 
 export const getDBSchema = (dboBuilder: DboBuilder): string => {
@@ -15,45 +17,78 @@ tables.push(`${escapeTSNames(tov.name)}: {
     insert: ${tov.privileges.insert}
     update: ${tov.privileges.update}
     delete: ${tov.privileges.delete}
-    dataTypes: { ${cols.map(c => `${escapeTSNames(c.name)}: ${postgresToTsType(c.udt_name)}${c.is_nullable? " | null" : ""}`).join("; ")} };
     columns: {${cols.map(c => `
-      ${escapeTSNames(c.name)}: { type: ${postgresToTsType(c.udt_name)}; is_nullable: ${c.is_nullable}; is_nullable_or_has_default: ${c.is_nullable || c.has_default}; }`).join(";\n")}
+      ${escapeTSNames(c.name)}${c.is_nullable || c.has_default? "?" : ""}: ${postgresToTsType(c.udt_name)}${c.is_nullable? " | null" : ""}`).join(";")}
     }
   };\n  `)
   })
 return `
-type DBSchema = {
+export type DBSchemaGenerated = {
   ${tables.join("")}
 }
 `;
 }
 
-const ccc: DBSchemaInsertColumns<{ col1: { type: string; }; col2: { type: number; is_nullable_or_has_default: true } }> = {
-  col1: "",
-  col2: 22
-}
+export type DBOFullyTyped<Schema = void> = Schema extends DBSchema? (
+    { 
+      [tov_name in keyof Schema]: Schema[tov_name]["is_view"] extends true? 
+        ViewHandler<Schema[tov_name]["columns"]> : 
+        TableHandler<Schema[tov_name]["columns"]>
+    } & Pick<DBHandlerServer, "tx" | "sql">
+  ) : 
+  DBHandlerServer;
+
+
+  
+
+/** Type checks */
+(() => {
 
+  const ddb: DBOFullyTyped = 1 as any;
+  ddb.dwad.insert!;
+  ddb.dwad.delete!;
 
+  const d: DBOFullyTyped<undefined> = 1 as any;
+  d.dwad.insert!;
+  d.dwad.delete!;
 
-export type DBOFullyTyped<Schema extends DBSchema = never> = Schema extends DBSchema? ({ 
-  [tov_name in keyof Schema]: Schema[tov_name]["is_view"] extends true? ViewHandler<DBSchemaColumns<Schema[tov_name]["columns"]>> : TableHandler<DBSchemaColumns<Schema[tov_name]["columns"]>>
-} & Pick<DBHandlerServer, "tx" | "sql">) : DBHandlerServer;
+  const p: PublishParams = 1 as any;
+  p.dbo.dwad.insert!;
+  ddb.dwad.delete!;
+
+  prostgles({
+    dbConnection: 1 as any,
+    publish: async (params) => {
+      const row = await params.dbo.dwadwa.find?.({});
+      
+      return "*" as "*"
+    },
+    onReady: (dbo) => {
+      dbo.tdwa.find!()
+    }
+  });
 
 
+  const auth: Auth = {
+    sidKeyName: "sid_token",
+    getUser: async (sid, db, _db) => {
+      db.dwadaw.find;
+      return 1 as any;
+    }
+  }
+})
 
 type S = {
   tbl1: {
-    dataTypes: {type: string;};
     columns: {
-      col1: { type: number | null;}
-      col2: { type: string; }
+      col1: number | null;
+      col2: string; 
     }
   },
   tbl2: {
-    dataTypes: {type: string;};
     columns: {
-      col1: { type: number | null;}
-      col2: { type: string; }
+      col1: number | null;
+      col2: string; 
     }
   }
 }
@@ -64,16 +99,28 @@ const test: DBSchema = c;
 const db: DBOFullyTyped<S> = 1 as any;
 
 
-export type PublishFullyTyped<Schema extends DBSchema> = { 
-  [tov_name in keyof Partial<Schema>]: PublishAllOrNothing | (Schema[tov_name]["is_view"] extends true? PublishViewRule<Schema[tov_name]> : PublishTableRule<Schema[tov_name]>);
-};
+export type PublishFullyTyped<Schema = void> = Schema extends DBSchema? (
+  | PublishAllOrNothing 
+  | { 
+    [tov_name in keyof Partial<Schema>]: 
+      | PublishAllOrNothing 
+      | (
+        Schema[tov_name]["is_view"] extends true? 
+          PublishViewRule<Schema[tov_name]["columns"]> : 
+          PublishTableRule<Schema[tov_name]["columns"]>
+      );
+  }
+) : (
+  | PublishAllOrNothing 
+  | Record<string, PublishViewRule | PublishTableRule | PublishAllOrNothing>
+);
 
 
 const publish = (): PublishFullyTyped<S> => {
-  const res: PublishFullyTyped<S> = {
+  const r = {
     tbl1: {
       select: {
-        fields: "*",
+        fields: "*" as "*", 
         forcedFilter: { col1: 32, col2: "" }
       },
       getColumns: true,
@@ -86,6 +133,27 @@ const publish = (): PublishFullyTyped<S> => {
       delete: {forcedFilter: {col1: 2}}
     }
   }
+  const res: PublishFullyTyped<S> = {
+    tbl1: {
+      select: {
+        fields: "*",
+        forcedFilter: { col1: 32, col2: "" }
+      },
+      getColumns: true,
+      getInfo: true,
+      delete: {
+        filterFields: { col1: 1 }
+      }
+    },
+    tbl2: {
+      delete: {forcedFilter: { col1: 2 }}
+    }
+  }
+  const res1: PublishFullyTyped = r
+
+  const p: PublishParams<undefined> = 1 as any;
+
+  p.dbo.dwadaw.find!();
 
   return res;
 }