prostgles-server 1.5.122 → 2.0.3

package/lib/Prostgles.ts

@@ -6,19 +6,20 @@
 import * as promise from "bluebird";
 import * as pgPromise from 'pg-promise';
 import pg = require('pg-promise/typescript/pg-subset');
+import FileManager, { ImageOptions, LocalConfig, S3Config } from "./FileManager";
 
 const pkgj = require('../package.json');
 const version = pkgj.version;
 
+console.log("Add a basic auth mode where user and sessions table are created");
+
 import { get } from "./utils";
-import { DboBuilder, DbHandler, DbHandlerTX, TableHandler, ViewHandler, isPlainObject } from "./DboBuilder";
+import { DboBuilder, DbHandler, TableHandler, ViewHandler, isPlainObject, LocalParams } from "./DboBuilder";
 import { PubSubManager, DEFAULT_SYNC_BATCH_SIZE, asValue } from "./PubSubManager";
- 
+export { DbHandler }
 export type PGP = pgPromise.IMain<{}, pg.IClient>;
 
-
-export { DbHandler, DbHandlerTX } from "./DboBuilder";
-import { SQLRequest, SQLOptions, CHANNELS, asName, DBHandler, AnyObject } from "prostgles-types";
+import { SQLRequest, SQLOptions, CHANNELS, AnyObject } from "prostgles-types";
 
 import { DBEventsManager } from "./DBEventsManager";
 
@@ -66,9 +67,6 @@ function getDbConnection(dbConnection: DbConnection, options: DbConnectionOpts,
 }
 
 
-const QueryFile = require('pg-promise').QueryFile;
-
-
 import { Socket } from "dgram";
 import { FieldFilter, SelectParamsBasic as SelectParams } from "prostgles-types";
 
@@ -98,6 +96,8 @@ export type UpdateRequestDataBatch = {
 }
 export type UpdateRequestData = UpdateRequestDataOne | UpdateRequestDataBatch;
 
+export type ValidateRow = (row: AnyObject) => AnyObject | Promise<AnyObject>;
+
 export type SelectRule = {
 
     /**
@@ -153,14 +153,14 @@ export type InsertRule = {
     returningFields?: FieldFilter;
 
     /**
-     * Validation logic to check/update data for each request. Happens before field check
+     * Validation logic to check/update data for each request. Happens before publish rule checks (for fields, forcedData/forcedFilter)
      */
-    preValidate?: (row: object) => object | Promise<object>
+    preValidate?: ValidateRow
 
     /**
-     * Validation logic to check/update data for each request. Happens after field check
+     * Validation logic to check/update data for each request. Happens after publish rule checks (for fields, forcedData/forcedFilter)
      */
-    validate?: (row: object) => object | Promise<object>
+    validate?: ValidateRow
 }
 export type UpdateRule = {
 
@@ -193,7 +193,7 @@ export type UpdateRule = {
     /**
      * Validation logic to check/update data for each request
      */
-    validate?: (row: object) => object | Promise<object>
+    validate?: ValidateRow
 }
 export type DeleteRule = {
     
@@ -215,7 +215,7 @@ export type DeleteRule = {
     /**
      * Validation logic to check/update data for each request
      */
-    validate?(...UpdateRequestData): UpdateRequestData
+    validate?(...args): UpdateRequestData
 }
 export type SyncRule = {
     
@@ -274,9 +274,21 @@ export type PublishViewRule = {
 //     tablesOrViews: {[key:string]: TableRule | ViewRule | "*" }
 // }
 export type RequestParams = { dbo?: DbHandler, socket?: any };
-export type PublishAllOrNothing = string | "*" | false | null;
-export type PublishedTablesAndViews = PublishAllOrNothing | { [key: string]: (PublishTableRule | PublishViewRule | PublishAllOrNothing ) } ;
-export type Publish = PublishedTablesAndViews | ((socket?: any, dbo?: DbHandler | DbHandlerTX | any, db?: DB, user?: any) => (PublishedTablesAndViews | Promise<PublishedTablesAndViews>)); 
+export type PublishAllOrNothing = "*" | false | null;
+export type PublishObject = { 
+    [table_name: string]: (PublishTableRule | PublishViewRule | PublishAllOrNothing ) 
+};
+export type PublishTable = { 
+    [table_name: string]: (PublishTableRule | PublishViewRule) 
+};
+export type PublishedResult = PublishAllOrNothing | PublishObject ;
+export type PublishParams<DBO = DbHandler> = {
+    sid?: string;
+    dbo?: DBO;
+    db?: DB;
+    user?: AnyObject;
+}
+export type Publish<DBO> =(params: PublishParams<DBO>) => (PublishedResult | Promise<PublishedResult>); 
 
 export type Method = (...args: any) => ( any | Promise<any> );
 export const JOIN_TYPES = ["one-many", "many-one", "one-one", "many-many"] as const;
@@ -287,18 +299,48 @@ export type Join = {
 };
 export type Joins = Join[] | "inferred";
 
-export type publishMethods = (socket?: any, dbo?: DbHandler | DbHandlerTX | any, db?: DB, user?: any) => { [key:string]: Method } | Promise<{ [key:string]: Method }>;
+export type PublishMethods<DBO> = (params: PublishParams<DBO>) => { [key:string]: Method } | Promise<{ [key:string]: Method }>;
 
 export type BasicSession = { sid: string, expires: number };
-export type SessionIDs = { sidCookie?: string; sidQuery?: string; sid: string; };
-export type Auth = {
-    sidQueryParamName?: string; /* Name of the websocket handshake query parameter that represents the session id. Takes precedence over cookie. If provided, Prostgles will attempt to get the user on socket connection */
-    sidCookieName?: string; /* Name of the cookie that represents the session id. If provided, Prostgles will attempt to get the user on socket connection */
-    getUser: (params: SessionIDs, dbo: any, db: DB, socket: any) => Promise<object | null | undefined>;    /* User data used on server */
-    getClientUser: (params: SessionIDs, dbo: any, db: DB, socket: any) => Promise<object>;                 /* User data sent to client */
-    register?: (params, dbo: any, db: DB, socket: any) => Promise<BasicSession>;
-    login?: (params, dbo: any, db: DB, socket: any) => Promise<BasicSession>;
-    logout?: (params: SessionIDs, dbo: any, db: DB, socket: any) => Promise<any>;
+
+export type AuthClientRequest = { socket: any } | { httpReq: any }
+export type Auth<DBO = DbHandler> = {
+    /**
+     * Name of the cookie or socket hadnshake query param that represents the session id. 
+     * Defaults to "session_id"
+     */
+    sidKeyName?: string;
+    expressConfig?: {
+        /**
+         * Express app instance. If provided Prostgles will attempt to set sidKeyName to user cookie
+         */
+        app: any;
+
+        /**
+         * Used in allowing logging in through express
+         */
+        loginPostPath: string;
+    }
+
+    /**
+     * User data used on server
+     */
+    getUser: (sid: string, dbo: DBO, db: DB) => Promise<AnyObject | null | undefined>;
+
+    /**
+     * User data sent to client
+     */
+    getClientUser: (sid: string, dbo: DBO, db: DB) => Promise<AnyObject | null | undefined>;
+
+    register?: (params: AnyObject, dbo: DBO, db: DB) => Promise<BasicSession>;
+    login?: (params: AnyObject, dbo: DBO, db: DB) => Promise<BasicSession>;
+    logout?: (sid: string, dbo: DBO, db: DB) => Promise<any>;
+}
+
+export type ClientInfo = {
+    user?: AnyObject;
+    clientUser?: AnyObject;
+    sid?: string;
 }
 
 type Keywords = {
@@ -321,29 +363,83 @@ export type I18N_CONFIG<LANG_IDS = { en: 1, fr: 1 }> = {
     }>;
 }
 
-export type ProstglesInitOptions = {
+type ExpressApp = {
+    get: (
+        routePath: string, 
+        cb: (
+            req: { 
+                params: { name: string },
+                cookies: { sid: string }
+            },
+            res: {
+                redirect: (redirectUrl: string) => any;
+                contentType: (type: string) => void;
+                sendFile: (fileName: string, opts?: { root: string }) => any;
+                status: (code: number) => {
+                    json: (response: AnyObject) => any;
+                }
+            }
+        ) => any
+    ) => any
+};
+
+/**
+ * Allows uploading and downloading files.
+ * Currently supports only S3.
+ * 
+ * @description
+ * Will create a media table that contains file metadata and urls
+ * Inserting a file into this table through prostgles will upload it to S3 and insert the relevant metadata into the media table
+ * Requesting a file from HTTP GET {fileUrlPath}/{fileId} will:
+ *  1. check auth (if provided) 
+ *  2. check the permissions in publish (if provided)
+ *  3. redirect the request to the signed url (if allowed)
+ * 
+ * Specifying referencedTables will:
+ *  1. create a column in that table called media
+ *  2. create a lookup table lookup_media_{referencedTable} that joins referencedTable to the media table 
+ */
+export type FileTableConfig = {
+    tableName?: string; /* defaults to 'media' */
+    fileUrlPath?: string; // defaults to tableName
+    awsS3Config?: S3Config;
+    localConfig?: LocalConfig;
+    //  {
+    //     region: string; 
+    //     bucket: string; 
+    //     accessKeyId: string;
+    //     secretAccessKey: string;
+    // },
+    expressApp: ExpressApp;
+    referencedTables?: {
+        [tableName: string]: "one" | "many"
+    },
+    imageOptions?: ImageOptions
+};
+
+export type ProstglesInitOptions<DBO = DbHandler> = {
     dbConnection: DbConnection;
     dbOptions?: DbConnectionOpts;
     tsGeneratedTypesDir?: string;
     io?: any;
-    publish?: Publish;
-    publishMethods?: publishMethods;
-    publishRawSQL?(socket?: any, dbo?: DbHandler | DbHandlerTX | any, db?: DB, user?: any): ( (boolean | "*") | Promise<(boolean | "*")>);
+    publish?: Publish<DBO>;
+    publishMethods?: PublishMethods<DBO>;
+    publishRawSQL?(params: PublishParams<DBO>): ( (boolean | "*") | Promise<(boolean | "*")>);
     joins?: Joins;
     schema?: string;
     sqlFilePath?: string;
-    onReady(dbo: any, db: DB): void;
-    // auth, 
+    onReady(dbo: DBO, db: DB): void;
     transactions?: string | boolean;
     wsChannelNamePrefix?: string;
-    onSocketConnect?(socket: Socket, dbo: any, db?: DB);
-    onSocketDisconnect?(socket: Socket, dbo: any, db?: DB);
-    auth?: Auth;
+    onSocketConnect?(socket: Socket, dbo: DBO, db?: DB);
+    onSocketDisconnect?(socket: Socket, dbo: DBO, db?: DB);
+    auth?: Auth<DBO>;
     DEBUG_MODE?: boolean;
     watchSchema?: boolean | "hotReloadMode" | ((event: { command: string; query: string }) => void);
     keywords?: Keywords;
     onNotice?: (msg: any) => void;
     i18n?: I18N_CONFIG<AnyObject>;
+    fileTable?: FileTableConfig;
 }
 
 // interface ISocketSetup {
@@ -377,50 +473,68 @@ const DEFAULT_KEYWORDS = {
 };
 
 const fs = require('fs');
-export class Prostgles {
-
-    // o: ProstglesInitOptions;
-
-    dbConnection: DbConnection = {
-        host: "localhost",
-        port: 5432,
-        application_name: "prostgles_app"
+export class Prostgles<DBO = DbHandler> {
+
+    opts: ProstglesInitOptions<DBO> = {
+        DEBUG_MODE: false,
+        dbConnection: {
+            host: "localhost",
+            port: 5432,
+            application_name: "prostgles_app"
+        },
+        onReady: () => {},
+        schema: "public",
+        watchSchema: false,
     };
-    dbOptions: DbConnectionOpts;
+
+    // dbConnection: DbConnection = {
+    //     host: "localhost",
+    //     port: 5432,
+    //     application_name: "prostgles_app"
+    // };
+    // dbOptions: DbConnectionOpts;
     db: DB;
     pgp: PGP;
-    dbo: DbHandler | DbHandlerTX;
+    dbo: DbHandler;
     dboBuilder: DboBuilder;
-
-    publishMethods?: publishMethods;
-    io: any;
-    publish?: Publish;
-    joins?: Joins;
-    schema: string = "public";
-    transactions?: string | boolean;
-    // auth, 
-    publishRawSQL?: any;
-    wsChannelNamePrefix: string = "_psqlWS_";
-    onSocketConnect?(socket: Socket | any, dbo: any, db?: DB);
-    onSocketDisconnect?(socket: Socket | any, dbo: any, db?: DB);
-    sqlFilePath?: string;
-    tsGeneratedTypesDir?: string;
     publishParser: PublishParser;
-    auth?: Auth;
-    DEBUG_MODE?: boolean = false;
-    watchSchema?: boolean | "hotReloadMode" | ((event: { command: string; query: string }) => void) = false;
-    private loaded = false;
-    keywords = DEFAULT_KEYWORDS;
-    onReady: (dbo: any, db: DB) => void;
 
-    /**
-     * Postgres on notice callback
-     */
-    onNotice?: ProstglesInitOptions["onNotice"];
+    // publishMethods?: ProstglesInitOptions<DBO>["publishMethods"];
+    // io: any;
+    // publish?: ProstglesInitOptions<DBO>["publish"];
+    // joins?: Joins;
+    // schema: string = "public";
+    // transactions?: string | boolean;
+    
+    // publishRawSQL?: ProstglesInitOptions<DBO>["publishRawSQL"];
+    // wsChannelNamePrefix: string = "_psqlWS_";
+    // onSocketConnect?(socket: Socket | any, dbo: DBO, db?: DB);
+    // onSocketDisconnect?(socket: Socket | any, dbo: DBO, db?: DB);
+    // sqlFilePath?: string;
+    // tsGeneratedTypesDir?: string;
+    // auth?: ProstglesInitOptions["auth"];
+    // DEBUG_MODE?: boolean = false;
+    // watchSchema?: ProstglesInitOptions["watchSchema"];// boolean | "hotReloadMode" | ((event: { command: string; query: string }) => void) = false;
+    // onReady: (dbo: any, db: DB) => void;
+    // i18n?: ProstglesInitOptions["i18n"];
+    // fileTable?: FileTableConfig;
+    // /**
+    //  * Postgres on notice callback
+    //  */
+    // onNotice?: ProstglesInitOptions["onNotice"];
+
+
+    keywords = DEFAULT_KEYWORDS;
+    private loaded = false;
 
     dbEventsManager: DBEventsManager;
 
-    i18n?: ProstglesInitOptions["i18n"];
+
+    fileManager?: FileManager;
+
+    isMedia(tableName: string){
+        return this.opts?.fileTable?.tableName === tableName;
+    }
 
     constructor(params: ProstglesInitOptions){
         if(!params) throw "ProstglesInitOptions missing";
@@ -432,14 +546,21 @@ export class Prostgles {
             "onReady", "dbConnection", "dbOptions", "publishMethods", "io", 
             "publish", "schema", "publishRawSQL", "wsChannelNamePrefix", "onSocketConnect", 
             "onSocketDisconnect", "sqlFilePath", "auth", "DEBUG_MODE", "watchSchema", 
-            "i18n"
+            "i18n", "fileTable"
         ];
         const unknownParams = Object.keys(params).filter((key: string) => !(config as string[]).includes(key))
         if(unknownParams.length){ 
             console.error(`Unrecognised ProstglesInitOptions params: ${unknownParams.join()}`);
         }
         
-        Object.assign(this, params);
+        Object.assign(this.opts, params);
+
+        /* set defaults */
+        if(this.opts?.fileTable){
+            this.opts.fileTable.tableName = this.opts?.fileTable?.tableName || "media";
+        }
+        this.opts.schema = this.opts.schema || "public";
+
         this.keywords = {
             ...DEFAULT_KEYWORDS,
             ...params.keywords,
@@ -449,15 +570,16 @@ export class Prostgles {
     destroyed = false;
 
     async onSchemaChange(event: { command: string; query: string }){
-        if(this.watchSchema && this.loaded){
+        const { watchSchema, onReady, tsGeneratedTypesDir } = this.opts;
+        if(watchSchema && this.loaded){
             console.log("Schema changed");
             
-            if(typeof this.watchSchema === "function"){
+            if(typeof watchSchema === "function"){
                 /* Only call the provided func */
-                this.watchSchema(event);
+                watchSchema(event);
 
-            } else if(this.watchSchema === "hotReloadMode") {
-                if(this.tsGeneratedTypesDir) {
+            } else if(watchSchema === "hotReloadMode") {
+                if(tsGeneratedTypesDir) {
                     /* Hot reload integration. Will only touch tsGeneratedTypesDir */
                     console.log("watchSchema: Re-writing TS schema");
 
@@ -465,10 +587,10 @@ export class Prostgles {
                     this.writeDBSchema(true);
                 }
 
-            } else if(this.watchSchema === true){
+            } else if(watchSchema === true){
                 /* Full re-init. Sockets must reconnect */
                 console.log("watchSchema: Full re-initialisation")
-                this.init(this.onReady);
+                this.init(onReady);
             }
         }  
     }
@@ -479,7 +601,7 @@ export class Prostgles {
 
     getTSFileName(){
         const fileName = "DBoGenerated.d.ts" //`dbo_${this.schema}_types.ts`;
-        const fullPath = (this.tsGeneratedTypesDir || "") + fileName;
+        const fullPath = (this.opts.tsGeneratedTypesDir || "") + fileName;
         return { fileName, fullPath }
     }
 
@@ -494,7 +616,7 @@ export class Prostgles {
 
     writeDBSchema(force = false){
 
-        if(this.tsGeneratedTypesDir){
+        if(this.opts.tsGeneratedTypesDir){
             const { fullPath, fileName } = this.getTSFileName();
             const header = `/* This file was generated by Prostgles \n` +
             // `* ${(new Date).toUTCString()} \n` 
@@ -511,13 +633,14 @@ export class Prostgles {
         }
     }
 
-    async refreshDBO(){
-        this.dboBuilder = await DboBuilder.create(this);
-        this.dbo = this.dboBuilder.dbo;
+    refreshDBO = async () => {
+        this.dboBuilder = await DboBuilder.create(this as any) as any;
+        this.dbo = this.dboBuilder.dbo as any;
+        return this.dbo;
     }
 
-    async init(onReady: (dbo: DbHandler | DbHandlerTX, db: DB) => any): Promise<{
-        db: DbHandlerTX;
+    async init(onReady: (dbo: DBO, db: DB) => any): Promise<{
+        db: DbHandler;
         _db: DB;
         pgp: PGP;
         io?: any;
@@ -526,14 +649,14 @@ export class Prostgles {
         this.loaded = false;
 
 
-        if(this.watchSchema === "hotReloadMode" && !this.tsGeneratedTypesDir) {
+        if(this.opts.watchSchema === "hotReloadMode" && !this.opts.tsGeneratedTypesDir) {
             throw "tsGeneratedTypesDir option is needed for watchSchema: hotReloadMode to work ";
         }
 
         /* 1. Connect to db */
         if(!this.db){
-            const { db, pgp } = getDbConnection(this.dbConnection, this.dbOptions, this.DEBUG_MODE, notice => { 
-                if(this.onNotice) this.onNotice(notice);
+            const { db, pgp } = getDbConnection(this.opts.dbConnection, this.opts.dbOptions, this.opts.DEBUG_MODE, notice => { 
+                if(this.opts.onNotice) this.opts.onNotice(notice);
                 if(this.dbEventsManager){
                     this.dbEventsManager.onNotice(notice)
                 }
@@ -545,32 +668,46 @@ export class Prostgles {
         const { db, pgp } = this;
 
         /* 2. Execute any SQL file if provided */
-        if(this.sqlFilePath){
-            await this.runSQLFile(this.sqlFilePath);
+        if(this.opts.sqlFilePath){
+            await this.runSQLFile(this.opts.sqlFilePath);
         }
 
         try {
             /* 3. Make DBO object from all tables and views */
             await this.refreshDBO();
+            
+            /* Create media table if required */
+            if(this.opts.fileTable){
+                const { awsS3Config, localConfig, imageOptions } = this.opts.fileTable;
+                if(!awsS3Config && !localConfig) throw "fileTable missing param: Must provide awsS3Config OR localConfig";
+                await this.refreshDBO();
+                this.fileManager = new FileManager(awsS3Config || localConfig, imageOptions);
+                await this.fileManager.init(this as any);
+            }
+            await this.refreshDBO();
 
-            this.writeDBSchema();
 
-            if(this.publish){
+            if(this.opts.publish){
+
+                if(!this.opts.io) console.warn("IO missing. Publish has no effect without io");
+
                 /* 3.9 Check auth config */
-                if(this.auth){
-                    const { sidCookieName, login, getUser, getClientUser } = this.auth;
-                    if(typeof sidCookieName !== "string" && !login){
-                        throw "Invalid auth: Provide { sidCookieName: string } OR  { login: Function } ";
+                if(this.opts.auth){
+                    this.opts.auth.sidKeyName = this.opts.auth.sidKeyName || "session_id";
+
+                    const { sidKeyName, login, getUser, getClientUser } = this.opts.auth;
+                    if(typeof sidKeyName !== "string" && !login){
+                        throw "Invalid auth: Provide { sidKeyName: string } ";
                     }
                     if(!getUser || !getClientUser) throw "getUser OR getClientUser missing from auth config";
                 }
 
-                this.publishParser = new PublishParser(this.publish, this.publishMethods, this.publishRawSQL, this.dbo, this.db, this);
+                this.publishParser = new PublishParser(this.opts.publish, this.opts.publishMethods, this.opts.publishRawSQL, this.dbo, this.db, this as any);
                 this.dboBuilder.publishParser = this.publishParser;
                 /* 4. Set publish and auth listeners */ //makeDBO(db, allTablesViews, pubSubManager, false)
                 await this.setSocketEvents();
 
-            } else if(this.auth) throw "Auth config does not work without publish";
+            } else if(this.opts.auth) throw "Auth config does not work without publish";
             
             // if(this.watchSchema){
             //     if(!(await isSuperUser(db))) throw "Cannot watchSchema without a super user schema. Set watchSchema=false or provide a super user";
@@ -578,12 +715,15 @@ export class Prostgles {
 
             this.dbEventsManager = new DBEventsManager(db, pgp);
             
+
+            this.writeDBSchema();
+            
             /* 5. Finish init and provide DBO object */
             try {
                 if(this.destroyed) {
                     console.trace(1)
                 }
-                onReady(this.dbo, this.db);
+                onReady(this.dbo as any, this.db);
             } catch(err){
                 console.error("Prostgles: Error within onReady: \n", err)
             }
@@ -593,16 +733,16 @@ export class Prostgles {
                 db: this.dbo,
                 _db: db,
                 pgp,
-                io: this.io,
+                io: this.opts.io,
                 destroy: async () => {
                     console.log("destroying prgl instance")
                     this.destroyed = true;
-                    if(this.io){
-                        this.io.on("connection", (socket) => {
+                    if(this.opts.io){
+                        this.opts.io.on("connection", (socket) => {
                             console.log("Socket connected to destroyed instance")
                         });
-                        if(typeof this.io.close === "function"){
-                            this.io.close();
+                        if(typeof this.opts.io.close === "function"){
+                            this.opts.io.close();
                             console.log("this.io.close")
                         }
                     }
@@ -628,8 +768,8 @@ export class Prostgles {
 
         return this.db.multi(fileContent).then((data)=>{
             console.log("Prostgles: SQL file executed successfuly \n    -> " + filePath);
-            return true
-        }).catch((err)=>{
+            return data
+        }).catch((err) => {
             const { position, length } = err,
                 lines = fileContent.split("\n");
             let errMsg = filePath + " error: ";
@@ -647,30 +787,31 @@ export class Prostgles {
         });
     }
 
-    getSID(socket: any): SessionIDs {
-        if(!this.auth) return null;
+    /**
+     * Will return first sid value found in : http cookie or query params
+     * Based on sid names in auth
+     * @param localParams 
+     * @returns string
+     */
+    getSID(localParams: LocalParams): string {
+        if(!this.opts.auth) return null;
 
-        const { sidCookieName, sidQueryParamName } = this.auth;
+        const { sidKeyName } = this.opts.auth;
 
-        if(!sidCookieName && !sidQueryParamName) return null;
+        if(!sidKeyName || !localParams) return null;
 
-        let result = {
-            sidCookie: null, 
-            sidQuery: null,
-            sid: null
-        }
+        if(localParams.socket){
+            const querySid = localParams.socket?.handshake?.query?.[sidKeyName];
+            if(!querySid){
+                const cookie_str = get(localParams.socket, "handshake.headers.cookie");
+                const cookie = parseCookieStr(cookie_str);
+                return cookie[sidKeyName];
+            }
 
-        if(sidQueryParamName){
-            result.sidQuery = get(socket, `handshake.query.${sidQueryParamName}`);
-        }
+        } else if(localParams.httpReq){
+            return localParams.httpReq?.cookies?.[sidKeyName];
 
-        if(sidCookieName){
-            const cookie_str = get(socket, "handshake.headers.cookie");
-            const cookie = parseCookieStr(cookie_str);
-            if(socket && cookie){
-                result.sidCookie = cookie[sidCookieName];
-            }
-        }
+        } else throw "socket OR httpReq missing from localParams";
 
         function parseCookieStr(cookie_str: string): any {
             if(!cookie_str || typeof cookie_str !== "string") return {}
@@ -680,38 +821,23 @@ export class Prostgles {
                 return prev
             }, {});
         }
-
-        result.sid = result.sidQuery || result.sidCookie;
-
-        return result;
     }
 
-    async getUser(socket: any){
-
-        if(this.auth){
-            const { getUser } = this.auth;
+    async getClientInfo(localParams: Pick<LocalParams, "socket" | "httpReq">): Promise<ClientInfo>{
+        if(this.opts.auth){
+            const { getUser, getClientUser } = this.opts.auth;
     
-            if(getUser){
-                const params = this.getSID(socket);
-                return await getUser(params, this.dbo, this.db, socket);
+            if(getUser && localParams && (localParams.httpReq || localParams.socket)){
+                const sid = this.getSID(localParams);
+                return {
+                    sid,
+                    user: await getUser(sid, this.dbo as any, this.db),
+                    clientUser: await getClientUser(sid, this.dbo as any, this.db)
+                }
             }
         }
 
-        return null;
-    }
-
-    async getUserFromCookieSession(socket: any): Promise<null | { user: any, clientUser: any }>{
-       
-        // console.log("conn", socket.handshake.query, socket._session)
-        const params = this.getSID(socket);
-
-        const { getUser, getClientUser } = this.auth;
-
-        const user = await getUser(params, this.dbo, this.db, socket);
-        const clientUser = await getClientUser(params, this.dbo, this.db, socket);
-
-        if(!user) return undefined;
-        return { user, clientUser };
+        return {};
     }
 
     connectedSockets: any[] = [];
@@ -720,10 +846,10 @@ export class Prostgles {
 
         if(!this.dbo) throw "dbo missing";
 
-        let publishParser = new PublishParser(this.publish, this.publishMethods, this.publishRawSQL, this.dbo, this.db, this);
+        let publishParser = new PublishParser(this.opts.publish, this.opts.publishMethods, this.opts.publishRawSQL, this.dbo, this.db, this as any);
         this.publishParser = publishParser;
 
-        if(!this.io) return;
+        if(!this.opts.io) return;
 
         /* Already initialised. Only reconnect sockets */
         if(this.connectedSockets.length){
@@ -735,7 +861,7 @@ export class Prostgles {
         }
         
         /* Initialise */
-        this.io.on('connection', async (socket) => {
+        this.opts.io.on('connection', async (socket) => {
             if(this.destroyed){
                 console.log("Socket connected to destroyed instance");
                 socket.disconnect();
@@ -747,7 +873,7 @@ export class Prostgles {
             let { dbo, db, pgp } = this;
             
             try {
-                if(this.onSocketConnect) await this.onSocketConnect(socket, dbo, db);
+                if(this.opts.onSocketConnect) await this.opts.onSocketConnect(socket, dbo as any, db);
 
                 
                 /*  RUN Client request from Publish.
@@ -762,8 +888,8 @@ export class Prostgles {
                             throw "socket missing??!!";
                         }
 
-                        const user = await this.getUser(socket);
-                        let valid_table_command_rules = await this.publishParser.getValidatedRequestRule({ tableName, command, socket }, user);
+                        const clientInfo = await this.getClientInfo({ socket });
+                        let valid_table_command_rules = await this.publishParser.getValidatedRequestRule({ tableName, command, localParams: { socket } }, clientInfo);
                         if(valid_table_command_rules){
                             let res = await this.dbo[tableName][command](param1, param2, param3, valid_table_command_rules, { socket, has_rules: true }); 
                             cb(null, res);
@@ -783,8 +909,8 @@ export class Prostgles {
                     this.dbEventsManager.removeNotify(socket);
                     this.connectedSockets = this.connectedSockets.filter(s => s.id !== socket.id);
                     // subscriptions = subscriptions.filter(sub => sub.socket.id !== socket.id);
-                    if(this.onSocketDisconnect){
-                        this.onSocketDisconnect(socket, dbo);
+                    if(this.opts.onSocketDisconnect){
+                        this.opts.onSocketDisconnect(socket, dbo as any);
                     };
                 });
 
@@ -819,16 +945,21 @@ export class Prostgles {
     pushSocketSchema = async (socket: any) => {
 
         let auth: any = {};
-        if(this.auth){
-            const { register, login, logout, sidQueryParamName } = this.auth;
-            if(sidQueryParamName === "sid") throw "sidQueryParamName cannot be 'sid' please provide another name."
+        if(this.opts.auth){
+            const { register, login, logout, sidKeyName } = this.opts.auth;
+
+            /**
+             * Why ??? Collision with socket.io ???
+             */
+            if(sidKeyName === "sid") throw "sidQueryParamName cannot be 'sid' please provide another name.";
+
             let handlers = [
                 { func: register,   ch: CHANNELS.REGISTER,   name: "register"    },
                 { func: login,      ch: CHANNELS.LOGIN,      name: "login"       },
                 { func: logout,     ch: CHANNELS.LOGOUT,     name: "logout"      }
             ].filter(h => h.func);
 
-            const usrData = await this.getUserFromCookieSession(socket);
+            const usrData = await this.getClientInfo({ socket });
             if(usrData){
                 auth.user = usrData.clientUser;
                 handlers = handlers.filter(h => h.name === "logout");
@@ -843,7 +974,7 @@ export class Prostgles {
                     try {
                         if(!socket) throw "socket missing??!!";
 
-                        const res = await func(params, dbo, db, socket);
+                        const res = await func(params, dbo as any, db);
                         if(name === "login" && res && res.sid){
                             /* TODO: Re-send schema to client */
                         }
@@ -859,9 +990,9 @@ export class Prostgles {
 
         }
         
-        let needType = this.publishRawSQL && typeof this.publishRawSQL === "function";
-        let DATA_TYPES = !needType? [] : await this.db.any("SELECT oid, typname FROM pg_type");
-        let USER_TABLES = !needType? [] :  await this.db.any("SELECT relid, relname FROM pg_catalog.pg_statio_user_tables");
+        // let needType = this.publishRawSQL && typeof this.publishRawSQL === "function";
+        // let DATA_TYPES = !needType? [] : await this.db.any("SELECT oid, typname FROM pg_type");
+        // let USER_TABLES = !needType? [] :  await this.db.any("SELECT relid, relname FROM pg_catalog.pg_statio_user_tables");
 
         let schema: any = {};
         let publishValidationError;
@@ -870,7 +1001,6 @@ export class Prostgles {
         const { dbo, db, pgp, publishParser } = this;
         try {
             schema = await publishParser.getSchemaFromPublish(socket);
-            // console.log("getSchemaFromPublish", Object.keys(schema), this.dboBuilder.tablesOrViews.map(t => `${t.name} (${t.columns.map(c => c.name).join(", ")})`))
         } catch(e){
             publishValidationError = "Server Error: PUBLISH VALIDATION ERROR";
             console.error(`\nProstgles PUBLISH VALIDATION ERROR (after socket connected):\n    ->`, e);
@@ -881,73 +1011,88 @@ export class Prostgles {
         */
         let fullSchema = [];
         let allTablesViews = this.dboBuilder.tablesOrViews;
-        if(this.publishRawSQL && typeof this.publishRawSQL === "function"){
+        if(this.opts.publishRawSQL && typeof this.opts.publishRawSQL === "function"){
             const canRunSQL = async () => {
-                let res = await this.publishRawSQL(socket, dbo, db, await this.getUser(socket));
+                const publishParams = await this.publishParser.getPublishParams({ socket })
+                let res = await this.opts.publishRawSQL(publishParams as any);
                 return Boolean(res && typeof res === "boolean" || res === "*");
             } 
 
-            // console.log("canRunSQL", canRunSQL, socket.handshake.headers["x-real-ip"]);//, allTablesViews);
-
             if(await canRunSQL()){
                 socket.removeAllListeners(CHANNELS.SQL)
                 socket.on(CHANNELS.SQL, async ({ query, params, options }: SQLRequest, cb = (...callback) => {}) => {
 
-                    if(!(await canRunSQL())) {
-                        cb("Dissallowed", null);
-                        return;
-                    }
+                    if(!this.dbo.sql) throw "Internal error: sql handler missing";
 
-                    const { returnType }: SQLOptions = options || ({} as any);
-                    if(returnType === "noticeSubscription"){
+                    this.dbo.sql(query, params, options, { socket }).then(res => {
+                        cb(null, res)
+                    }).catch(err => {
+                        makeSocketError(cb, err);
+                    })
 
-                        const sub = await this.dbEventsManager.addNotice(socket);
+                    // if(!(await canRunSQL())) {
+                    //     cb("Dissallowed", null);
+                    //     return;
+                    // }
 
-                        cb(null, sub);
-                    } else if(returnType === "statement"){
-                        try {
-                            cb(null, pgp.as.format(query, params));
-                        } catch (err){
-                            cb(err.toString());
-                        }
-                    } else if(db) {
+                    // const { returnType }: SQLOptions = options || ({} as any);
+                    // if(returnType === "noticeSubscription"){
 
-                        db.result(query, params)
-                            .then(async (qres: any) => {
-                                const { duration, fields, rows, command } = qres;
+                    //     const sub = await this.dbEventsManager.addNotice(socket);
 
-                                if(command === "LISTEN"){
-                                    const sub = await this.dbEventsManager.addNotify(query, socket);
+                    //     cb(null, sub);
+                    // } else if(returnType === "statement"){
+                    //     try {
+                    //         cb(null, pgp.as.format(query, params));
+                    //     } catch (err){
+                    //         cb(err.toString());
+                    //     }
+                    // } else if(db) {
+
+                    //     db.result(query, params)
+                    //         .then(async (qres: any) => {
+                    //             const { duration, fields, rows, command } = qres;
+
+                    //             if(command === "LISTEN"){
+                    //                 const sub = await this.dbEventsManager.addNotify(query, socket);
                                     
-                                    cb(null, sub);
+                    //                 cb(null, sub);
 
-                                } else if(returnType === "rows") {
-                                    cb(null, rows);
+                    //             } else if(returnType === "rows") {
+                    //                 cb(null, rows);
                                     
-                                } else {
-                                    if(fields && DATA_TYPES.length){
-                                        qres.fields = fields.map(f => {
-                                            const dataType = DATA_TYPES.find(dt => +dt.oid === +f.dataTypeID),
-                                                tableName = USER_TABLES.find(t => +t.relid === +f.tableID),
-                                                { name } = f;
+                    //             } else if(returnType === "row") {
+                    //                 cb(null, rows[0]);
+                                    
+                    //             } else if(returnType === "value") {
+                    //                 cb(null, Object.values(rows[0])[0]);
+                                    
+                    //             } else if(returnType === "values") {
+                    //                 cb(null, rows.map(r => Object.values(r[0])));
+                                    
+                    //             } else {
+                    //                 if(fields && DATA_TYPES.length){
+                    //                     qres.fields = fields.map(f => {
+                    //                         const dataType = DATA_TYPES.find(dt => +dt.oid === +f.dataTypeID),
+                    //                             tableName = USER_TABLES.find(t => +t.relid === +f.tableID);
     
-                                            return {
-                                                ...f,
-                                                ...(dataType? { dataType: dataType.typname } : {}),
-                                                ...(tableName? { tableName: tableName.relname } : {}),
-                                            }
-                                        });
-                                    }
-                                    cb(null, qres)
-                                }
+                    //                         return {
+                    //                             ...f,
+                    //                             ...(dataType? { dataType: dataType.typname } : {}),
+                    //                             ...(tableName? { tableName: tableName.relname } : {}),
+                    //                         }
+                    //                     });
+                    //                 }
+                    //                 cb(null, qres)
+                    //             }
                                 
-                            })
-                            .catch(err => { 
-                                makeSocketError(cb, err);
-                                // Promise.reject(err.toString());
-                            });
+                    //         })
+                    //         .catch(err => { 
+                    //             makeSocketError(cb, err);
+                    //             // Promise.reject(err.toString());
+                    //         });
 
-                    } else console.error("db missing");
+                    // } else console.error("db missing");
                 });
                 if(db){
                     // let allTablesViews = await db.any(STEP2_GET_ALL_TABLES_AND_COLUMNS);
@@ -959,7 +1104,7 @@ export class Prostgles {
 
         // let joinTables = [];
         let joinTables2 = [];
-        if(this.joins){
+        if(this.opts.joins){
             // joinTables = Array.from(new Set(flat(this.dboBuilder.getJoins().map(j => j.tables)).filter(t => schema[t])));
             let _joinTables2 = this.dboBuilder.getJoinPaths()
             .filter(jp => 
@@ -1015,14 +1160,17 @@ type callback = {
 
 
 type Request = {
-    socket: any;
+    socket?: any;
+    httpReq?: any;
 }
 
 type DboTable = Request & {
     tableName: string;
+    localParams: LocalParams;
 }
 type DboTableCommand = Request & DboTable & {
     command: string;
+    localParams: LocalParams;
 }
 
 // const insertParams: Array<keyof InsertRule> = ["fields", "forcedData", "returningFields", "validate"];
@@ -1082,7 +1230,7 @@ export function flat(arr){
     let res =  arr.reduce(function (farr, toFlatten) {
         return farr.concat(Array.isArray(toFlatten) ? flat(toFlatten) : toFlatten);
       }, []);
-    // console.log(arr, res)
+      
     return res;
 }
 
@@ -1090,11 +1238,11 @@ export class PublishParser {
     publish: any;
     publishMethods?: any;
     publishRawSQL?: any;
-    dbo: DbHandler | DbHandlerTX;
+    dbo: DbHandler;
     db: DB
     prostgles: Prostgles;
 
-    constructor(publish: any, publishMethods: any, publishRawSQL: any, dbo: DbHandler | DbHandlerTX, db: DB, prostgles: Prostgles){
+    constructor(publish: any, publishMethods: any, publishRawSQL: any, dbo: DbHandler, db: DB, prostgles: Prostgles){
         this.publish = publish;
         this.publishMethods = publishMethods;
         this.publishRawSQL = publishRawSQL;
@@ -1105,11 +1253,19 @@ export class PublishParser {
         if(!this.dbo || !this.publish) throw "INTERNAL ERROR: dbo and/or publish missing";
     }
 
+    async getPublishParams(localParams: LocalParams, clientInfo?: ClientInfo): Promise<PublishParams> {
+        return {
+            ...(clientInfo || await this.prostgles.getClientInfo(localParams)),
+            dbo: this.dbo,
+            db: this.db
+        }
+    }
+
     async getMethods(socket: any){
         let methods = {};
     
-        const user = await this.prostgles.getUser(socket);
-        const _methods = await applyParamsIfFunc(this.publishMethods, socket, this.dbo, this.db, user);
+        const publishParams = await this.getPublishParams({ socket });
+        const _methods = await applyParamsIfFunc(this.publishMethods, publishParams);
     
         if(_methods && Object.keys(_methods).length){
             Object.keys(_methods).map(key => {
@@ -1129,8 +1285,9 @@ export class PublishParser {
      * @param socket 
      * @param user 
      */
-    async getPublish(socket, user){
-        let _publish = await applyParamsIfFunc(this.publish, socket, this.dbo, this.db, user);
+    async getPublish(localParams: LocalParams, clientInfo?: ClientInfo): Promise<PublishObject> {
+        const publishParams: PublishParams = await this.getPublishParams(localParams, clientInfo)
+        let _publish = await applyParamsIfFunc(this.publish, publishParams );
 
         if(_publish === "*"){
             let publish = {}
@@ -1142,12 +1299,12 @@ export class PublishParser {
 
         return _publish;
     }
-    async getValidatedRequestRuleWusr({ tableName, command, socket }: DboTableCommand): Promise<TableRule>{
-        const user = await this.prostgles.getUser(socket);
-        return await this.getValidatedRequestRule({ tableName, command, socket }, user);
+    async getValidatedRequestRuleWusr({ tableName, command, localParams }: DboTableCommand): Promise<TableRule>{
+        const clientInfo = await this.prostgles.getClientInfo(localParams);
+        return await this.getValidatedRequestRule({ tableName, command, localParams }, clientInfo);
     }
     
-    async getValidatedRequestRule({ tableName, command, socket }: DboTableCommand, user): Promise<TableRule>{
+    async getValidatedRequestRule({ tableName, command, localParams }: DboTableCommand, clientInfo: ClientInfo): Promise<TableRule>{
         if(!this.dbo) throw "INTERNAL ERROR: dbo is missing";
 
         if(!command || !tableName) throw "command OR tableName are missing";
@@ -1158,18 +1315,17 @@ export class PublishParser {
         }
 
         /* Must be local request -> allow everything */
-        if(!socket) return undefined;
+        if(!localParams || (!localParams.socket && !localParams.httpReq)) return undefined;
 
         /* Must be from socket. Must have a publish */
         if(!this.publish) throw "publish is missing";
 
         /* Get any publish errors for socket */
-        const schm = get(socket, `prostgles.schema.${tableName}.${command}`);
+        const schm = localParams?.socket?.prostgles?.schema?.[tableName]?.[command];
 
-        // console.log(schm, get(socket, `prostgles.schema`));
         if(schm && schm.err) throw schm.err;
 
-        let table_rule = await this.getTableRules({ tableName, socket }, user);
+        let table_rule = await this.getTableRules({ tableName, localParams }, clientInfo);
         if(!table_rule) throw "Invalid or disallowed table: " + tableName;
 
         if(command === "upsert"){
@@ -1183,14 +1339,14 @@ export class PublishParser {
         } else throw `Invalid or disallowed command: ${command}`;
     }
     
-    async getTableRules({ tableName, socket }: DboTable, user){
+    async getTableRules({ tableName, localParams }: DboTable, clientInfo: ClientInfo): Promise<PublishTable> {
         
         try {
-            if(!socket || !tableName) throw "publish OR socket OR dbo OR tableName are missing";
+            if(!localParams || !tableName) throw "publish OR socket OR dbo OR tableName are missing";
     
-            let _publish = await this.getPublish(socket, user);
+            let _publish = await this.getPublish(localParams, clientInfo);
     
-            let table_rules = applyParamsIfFunc(_publish[tableName],  socket, this.dbo, this.db, user);
+            let table_rules = _publish[tableName];// applyParamsIfFunc(_publish[tableName],  localParams, this.dbo, this.db, user);
 
             /* Get view or table specific rules */
             const is_view = (this.dbo[tableName] as TableHandler | ViewHandler).is_view,
@@ -1200,7 +1356,7 @@ export class PublishParser {
             if(table_rules){
 
                 /* All methods allowed. Add no limits for table rules */
-                if([true, "*"].includes(table_rules)){
+                if([true, "*"].includes(table_rules as any)){
                     table_rules = {};
                     MY_RULES.map(r => {
                         table_rules[r.rule] = { ...r.no_limits };
@@ -1217,10 +1373,10 @@ export class PublishParser {
                     if(table_rules[r.rule]){
                         r.methods.map(method => {
                             if(table_rules[method] === undefined){
+                                const publishedTable = (table_rules as PublishTable);
+                                if(method === "updateBatch" && !publishedTable.update){
                                 
-                                if(method === "updateBatch" && !table_rules.update){
-                                
-                                } else if(method === "upsert" && (!table_rules.update || !table_rules.insert)){
+                                } else if(method === "upsert" && (!publishedTable.update || !publishedTable.insert)){
                                     // return;
                                 } else {
                                     table_rules[method] = {};
@@ -1274,14 +1430,14 @@ export class PublishParser {
                                 const sr = MY_RULES.find(r => r.rule === "subscribe");
                                 if(sr){
                                     table_rules[sr.rule] = { ...sr.no_limits };
-                                    table_rules.subscribeOne = { ...sr.no_limits };
+                                    (table_rules as PublishTable).subscribeOne = { ...sr.no_limits };
                                 }
                             }
                         });                
                 }
             }
             
-            return table_rules;
+            return table_rules as PublishTable;
         } catch (e) {
             throw e;
         }
@@ -1295,14 +1451,14 @@ export class PublishParser {
         
         try {
             /* Publish tables and views based on socket */
-            const user = await this.prostgles.getUser(socket);
-            let _publish = await this.getPublish(socket, user);
+            const clientInfo = await this.prostgles.getClientInfo({ socket });
+            let _publish = await this.getPublish(socket, clientInfo);
 
     
             if(_publish && Object.keys(_publish).length){
                 let txKey = "tx";
-                if(!this.prostgles.transactions) txKey = "";
-                if(typeof this.prostgles.transactions === "string") txKey = this.prostgles.transactions;
+                if(!this.prostgles.opts.transactions) txKey = "";
+                if(typeof this.prostgles.opts.transactions === "string") txKey = this.prostgles.opts.transactions;
                 
                 const tableNames = Object.keys(_publish).filter(k => !txKey || txKey !== k);
                 
@@ -1315,7 +1471,7 @@ export class PublishParser {
                             `;
                         }
 
-                        const table_rules = await this.getTableRules({ socket, tableName }, user);
+                        const table_rules = await this.getTableRules({ localParams: {socket}, tableName }, clientInfo);
             
                         if(table_rules && Object.keys(table_rules).length){
                             schema[tableName] = {};
@@ -1339,7 +1495,7 @@ export class PublishParser {
 
                                         let err = null;
                                         try {
-                                            let valid_table_command_rules = await this.getValidatedRequestRule({ tableName, command: method, socket }, user);
+                                            let valid_table_command_rules = await this.getValidatedRequestRule({ tableName, command: method, localParams: {socket} }, clientInfo);
                                             await this.dbo[tableName][method]({}, {}, {}, valid_table_command_rules, { socket, has_rules: true, testRule: true }); 
                                                 
                                         } catch(e) {
@@ -1364,8 +1520,6 @@ export class PublishParser {
             throw e;
         }
 
-    // console.log(schema)
-
         return schema;
     }