prostgles-server 4.2.179 → 4.2.181

package/lib/initProstgles.ts

@@ -1,7 +1,6 @@
 import * as pgPromise from "pg-promise";
 import pg from "pg-promise/typescript/pg-subset";
 import { getKeys, isEmpty } from "prostgles-types";
-import { AuthHandler } from "./Auth/AuthHandler";
 import { DBEventsManager } from "./DBEventsManager";
 import { DBOFullyTyped } from "./DBSchemaBuilder";
 import { DBHandlerServer, Prostgles, getIsSuperUser } from "./Prostgles";
@@ -10,38 +9,48 @@ import { DbTableInfo, PublishParser } from "./PublishParser/PublishParser";
 import { SchemaWatch } from "./SchemaWatch/SchemaWatch";
 import { sleep } from "./utils";
 
-export type DbConnection = string | pg.IConnectionParameters<pg.IClient>;
+/**
+ * Database connection details
+ */
+export type DbConnection =
+  /**
+   * Connection URI
+   */
+  string | pg.IConnectionParameters<pg.IClient>;
 export type DbConnectionOpts = pg.IDefaults;
 
 export type PGP = pgPromise.IMain<{}, pg.IClient>;
 export type DB = pgPromise.IDatabase<{}, pg.IClient>;
 
-export type UpdateableOptions = Pick<ProstglesInitOptions, "fileTable" | "restApi" | "tableConfig" | "schema" | "auth">;
-export type OnInitReason = 
-  | { 
-    type: "schema change"; 
-    query: string; 
-    command: string; 
-  } 
+export type UpdateableOptions = Pick<
+  ProstglesInitOptions,
+  "fileTable" | "restApi" | "tableConfig" | "schema" | "auth"
+>;
+export type OnInitReason =
   | {
-    type: "prgl.update";
-    newOpts: Omit<UpdateableOptions, typeof clientOnlyUpdateKeys[number]>;
-  }
-  | { 
-    type: "init" | "prgl.restart" | "TableConfig"
-  };
+      type: "schema change";
+      query: string;
+      command: string;
+    }
+  | {
+      type: "prgl.update";
+      newOpts: Omit<UpdateableOptions, (typeof clientOnlyUpdateKeys)[number]>;
+    }
+  | {
+      type: "init" | "prgl.restart" | "TableConfig";
+    };
 
 type OnReadyParamsCommon = {
   db: DB;
   tables: DbTableInfo[];
   reason: OnInitReason;
-}
+};
 export type OnReadyParamsBasic = OnReadyParamsCommon & {
-  dbo: DBHandlerServer; 
-}
+  dbo: DBHandlerServer;
+};
 export type OnReadyParams<S> = OnReadyParamsCommon & {
-  dbo: DBOFullyTyped<S>; 
-}
+  dbo: DBOFullyTyped<S>;
+};
 
 export type OnReadyCallback<S = void> = (params: OnReadyParams<S>) => any;
 export type OnReadyCallbackBasic = (params: OnReadyParamsBasic) => any;
@@ -57,48 +66,54 @@ export type InitResult = {
    */
   getTSSchema: () => string;
   update: (newOpts: UpdateableOptions) => Promise<void>;
-  restart: () => Promise<InitResult>; 
+  restart: () => Promise<InitResult>;
   options: ProstglesInitOptions;
-}
+};
 
 const clientOnlyUpdateKeys = ["auth"] as const satisfies (keyof UpdateableOptions)[];
 
-export const initProstgles = async function(this: Prostgles, onReady: OnReadyCallbackBasic, reason: OnInitReason): Promise<InitResult> {
+export const initProstgles = async function (
+  this: Prostgles,
+  onReady: OnReadyCallbackBasic,
+  reason: OnInitReason
+): Promise<InitResult> {
   this.loaded = false;
 
   if (!this.db) {
     let existingAppName = "";
     let connString = "";
-    if(typeof this.opts.dbConnection === "string"){
+    if (typeof this.opts.dbConnection === "string") {
       connString = this.opts.dbConnection;
-    } else if(this.opts.dbConnection.connectionString){
+    } else if (this.opts.dbConnection.connectionString) {
       connString = this.opts.dbConnection.connectionString;
     } else {
       existingAppName = this.opts.dbConnection.application_name ?? "";
     }
 
-    if(connString){
+    if (connString) {
       try {
         const url = new URL(connString);
-        existingAppName = url.searchParams.get("application_name") ?? url.searchParams.get("ApplicationName") ?? "";
-      } catch (e) {
-
-      }
+        existingAppName =
+          url.searchParams.get("application_name") ?? url.searchParams.get("ApplicationName") ?? "";
+      } catch (e) {}
     }
 
-    const conObj = typeof this.opts.dbConnection === "string" ? { connectionString: this.opts.dbConnection } : this.opts.dbConnection 
+    const conObj =
+      typeof this.opts.dbConnection === "string" ?
+        { connectionString: this.opts.dbConnection }
+      : this.opts.dbConnection;
     const application_name = `prostgles ${this.appId} ${existingAppName}`;
 
     /* 1. Connect to db */
     const { db, pgp } = getDbConnection({
       ...this.opts,
-      dbConnection: { ...conObj, application_name }, 
-      onNotice: notice => {
+      dbConnection: { ...conObj, application_name },
+      onNotice: (notice) => {
         if (this.opts.onNotice) this.opts.onNotice(notice);
         if (this.dbEventsManager) {
-          this.dbEventsManager.onNotice(notice)
+          this.dbEventsManager.onNotice(notice);
         }
-      }
+      },
     });
     this.db = db;
     this.pgp = pgp;
@@ -115,7 +130,6 @@ export const initProstgles = async function(this: Prostgles, onReady: OnReadyCal
   }
 
   try {
-
     await this.refreshDBO();
     await this.initTableConfig(reason);
     await this.initFileTable();
@@ -124,7 +138,6 @@ export const initProstgles = async function(this: Prostgles, onReady: OnReadyCal
     this.schemaWatch = await SchemaWatch.create(this.dboBuilder);
 
     if (this.opts.publish) {
-
       if (!this.opts.io) {
         console.warn("IO missing. Publish has no effect without io");
       }
@@ -132,34 +145,39 @@ export const initProstgles = async function(this: Prostgles, onReady: OnReadyCal
       /* 3.9 Check auth config */
       await this.initAuthHandler();
 
-      this.publishParser = new PublishParser(this.opts.publish, this.opts.publishMethods as any, this.opts.publishRawSQL, this.dbo!, this.db, this as any);
+      this.publishParser = new PublishParser(
+        this.opts.publish,
+        this.opts.publishMethods as any,
+        this.opts.publishRawSQL,
+        this.dbo!,
+        this.db,
+        this as any
+      );
       this.dboBuilder.publishParser = this.publishParser;
 
       /* 4. Set publish and auth listeners */
       await this.setSocketEvents();
-
     } else if (this.opts.auth) {
       throw "Auth config does not work without publish";
     }
 
     this.dbEventsManager = new DBEventsManager(db, pgp);
 
-
     this.writeDBSchema();
 
     /* 5. Finish init and provide DBO object */
     try {
       if (this.destroyed) {
-        console.trace("Prostgles: Instance is destroyed")
+        console.trace("Prostgles: Instance is destroyed");
       }
       onReady({
-        dbo: this.dbo as any, 
-        db: this.db, 
+        dbo: this.dbo as any,
+        db: this.db,
         tables: this.dboBuilder.tables,
-        reason
+        reason,
       });
     } catch (err) {
-      console.error("Prostgles: Error within onReady: \n", err)
+      console.error("Prostgles: Error within onReady: \n", err);
     }
 
     this.loaded = true;
@@ -171,36 +189,36 @@ export const initProstgles = async function(this: Prostgles, onReady: OnReadyCal
       getTSSchema: this.getTSFileContent,
       options: this.opts,
       update: async (newOpts) => {
-
-        getKeys(newOpts).forEach(k => {
+        getKeys(newOpts).forEach((k) => {
           //@ts-ignore
           this.opts[k] = newOpts[k];
         });
 
-
-        if("fileTable" in newOpts){
+        if ("fileTable" in newOpts) {
           await this.initFileTable();
         }
-        if("restApi" in newOpts){
+        if ("restApi" in newOpts) {
           await this.initRestApi();
         }
-        if("tableConfig" in newOpts){
+        if ("tableConfig" in newOpts) {
           await this.initTableConfig({ type: "prgl.update", newOpts });
         }
-        if("schema" in newOpts){
+        if ("schema" in newOpts) {
           await this.refreshDBO();
         }
-        if("auth" in newOpts){
+        if ("auth" in newOpts) {
           await this.initAuthHandler();
         }
 
-        if(isEmpty(newOpts)) return;
+        if (isEmpty(newOpts)) return;
 
-        /** 
-         * Some of these changes require clients to reconnect 
+        /**
+         * Some of these changes require clients to reconnect
          * While others also affect the server and onReady should be called
-        */
-        if(getKeys(newOpts).every(updatedKey => clientOnlyUpdateKeys.includes(updatedKey as any))){
+         */
+        if (
+          getKeys(newOpts).every((updatedKey) => clientOnlyUpdateKeys.includes(updatedKey as any))
+        ) {
           await this.setSocketEvents();
         } else {
           await this.init(onReady, { type: "prgl.update", newOpts });
@@ -208,22 +226,22 @@ export const initProstgles = async function(this: Prostgles, onReady: OnReadyCal
       },
       restart: () => this.init(onReady, { type: "prgl.restart" }),
       destroy: async () => {
-        console.log("destroying prgl instance")
+        console.log("destroying prgl instance");
         this.destroyed = true;
         if (this.opts.io) {
           this.opts.io.on("connection", () => {
-            console.log("Socket connected to destroyed instance")
+            console.log("Socket connected to destroyed instance");
           });
 
           /** Try to close IO without stopping http server */
-          if(this.opts.io.sockets.constructor.name === "Namespace"){
+          if (this.opts.io.sockets.constructor.name === "Namespace") {
             for (const socket of this.opts.io.sockets.sockets.values()) {
               socket._onclose("server shutting down");
             }
           }
-          if(this.opts.io.engine.constructor.name === 'Server'){
+          if (this.opts.io.engine.constructor.name === "Server") {
             this.opts.io.engine.close();
-          } 
+          }
         }
         this.fileManager?.destroy();
         this.dboBuilder?.destroy();
@@ -234,57 +252,73 @@ export const initProstgles = async function(this: Prostgles, onReady: OnReadyCal
         await db.$pool.end();
         await sleep(1000);
         return true;
-      }
+      },
     };
   } catch (e: any) {
-    console.trace(e)
+    console.trace(e);
     throw "init issues: " + e.toString();
   }
-}
-
-type GetDbConnectionArgs = Pick<ProstglesInitOptions, "DEBUG_MODE" | "onQuery" | "dbConnection" | "dbOptions" | "onNotice">;
-const getDbConnection = function({ dbConnection, onQuery, DEBUG_MODE, dbOptions, onNotice  }: GetDbConnectionArgs): { db: DB, pgp: PGP } {
-  
-  const onQueryOrError: undefined | ((error: any, ctx: pgPromise.IEventContext<pg.IClient>) => void) = !onQuery && !DEBUG_MODE? undefined : (error, ctx) => {
-    if (onQuery) {
-      onQuery(error, ctx);
-    } else if (DEBUG_MODE) {
-      if(error){
-        console.error(error, ctx);
-      } else {
-        console.log(ctx)
-      }
-    }
-  };
-  
-  const pgp: PGP = pgPromise({
-    ...(onQueryOrError ? {
-      query: ctx => onQueryOrError(undefined, ctx),
-      error: onQueryOrError
-    } : {}),
-    ...((onNotice || DEBUG_MODE) ? {
-      connect: function ({ client, useCount }) {
-        const isFresh = !useCount;
-        if (isFresh && !client.listeners('notice').length) {
-          client.on('notice', function (msg) {
-            if (onNotice) {
-              onNotice(msg, msg?.message);
-            } else {
-              console.log("notice: %j", msg?.message);
-            }
-          });
-        }
-        if (isFresh && !client.listeners('error').length) {
-          client.on('error', function (msg) {
-            if (onNotice) {
-              onNotice(msg, msg?.message);
-            } else {
-              console.log("error: %j", msg?.message);
-            }
-          });
+};
+
+type GetDbConnectionArgs = Pick<
+  ProstglesInitOptions,
+  "DEBUG_MODE" | "onQuery" | "dbConnection" | "onNotice"
+>;
+const getDbConnection = function ({
+  dbConnection,
+  onQuery,
+  DEBUG_MODE,
+  onNotice,
+}: GetDbConnectionArgs): { db: DB; pgp: PGP } {
+  const onQueryOrError:
+    | undefined
+    | ((error: any, ctx: pgPromise.IEventContext<pg.IClient>) => void) =
+    !onQuery && !DEBUG_MODE ?
+      undefined
+    : (error, ctx) => {
+        if (onQuery) {
+          onQuery(error, ctx);
+        } else if (DEBUG_MODE) {
+          if (error) {
+            console.error(error, ctx);
+          } else {
+            console.log(ctx);
+          }
         }
-      },
-    } : {})
+      };
+
+  const pgp: PGP = pgPromise({
+    ...(onQueryOrError ?
+      {
+        query: (ctx) => onQueryOrError(undefined, ctx),
+        error: onQueryOrError,
+      }
+    : {}),
+    ...(onNotice || DEBUG_MODE ?
+      {
+        connect: function ({ client, useCount }) {
+          const isFresh = !useCount;
+          if (isFresh && !client.listeners("notice").length) {
+            client.on("notice", function (msg) {
+              if (onNotice) {
+                onNotice(msg, msg?.message);
+              } else {
+                console.log("notice: %j", msg?.message);
+              }
+            });
+          }
+          if (isFresh && !client.listeners("error").length) {
+            client.on("error", function (msg) {
+              if (onNotice) {
+                onNotice(msg, msg?.message);
+              } else {
+                console.log("error: %j", msg?.message);
+              }
+            });
+          }
+        },
+      }
+    : {}),
   });
   // pgp.pg.defaults.max = 70;
 
@@ -301,17 +335,16 @@ const getDbConnection = function({ dbConnection, onQuery, DEBUG_MODE, dbOptions,
   // pgp.pg.types.setTypeParser(1114, v => v); // timestamp without time zone
   // pgp.pg.types.setTypeParser(1184, v => v); // timestamp with time zone
   // pgp.pg.types.setTypeParser(1182, v => v); // date
-  pgp.pg.types.setTypeParser(pgp.pg.types.builtins.TIMESTAMP, v => v); // timestamp without time zone
-  pgp.pg.types.setTypeParser(pgp.pg.types.builtins.TIMESTAMPTZ, v => v); // timestamp with time zone
-  pgp.pg.types.setTypeParser(pgp.pg.types.builtins.DATE, v => v); // date
-  
+  pgp.pg.types.setTypeParser(pgp.pg.types.builtins.TIMESTAMP, (v) => v); // timestamp without time zone
+  pgp.pg.types.setTypeParser(pgp.pg.types.builtins.TIMESTAMPTZ, (v) => v); // timestamp with time zone
+  pgp.pg.types.setTypeParser(pgp.pg.types.builtins.DATE, (v) => v); // date
 
-  if (dbOptions) {
-    Object.assign(pgp.pg.defaults, dbOptions);
-  }
+  // if (dbOptions) {
+  //   Object.assign(pgp.pg.defaults, dbOptions);
+  // }
 
   return {
     db: pgp(dbConnection),
-    pgp
+    pgp,
   };
-}
+};

package/lib/typeTests/DBoGenerated.d.ts

@@ -1,4 +1,4 @@
-export type DBSchemaGenerated = {
+export type DBGeneratedSchema = {
   items: {
     is_view: false;
     select: true;
@@ -188,20 +188,25 @@ export type DBSchemaGenerated = {
     update: true;
     delete: true;
     columns: {
-      colOneOf: "a" | "b" | "c"
-      json: {    a: boolean;   arr: '1' | '2' | '3';   arr1: 1 | 2 | 3;   arr2: number[];   arrStr?: null | string[];   o?: | null
- |  {  o1: number; }
- |  {  o2: boolean; };  };
-      jsonOneOf?: 
-       | null
-       |  {  command: 'a'; }
-       |  {  command: 'b';  option: number[]; }
-      status?: 
-       | null
-       |  {  ok: string; }
-       |  {  err: string; }
-       |  {  loading: {  loaded: number;  total: number; }; }
-      table_config?: null | {    referencedTables?: (  {  name: string;  minFiles: number; } )[];   recType?: null | Record<'a' | 'b',  {  bools: boolean[]; }>;  };
+      colOneOf: "a" | "b" | "c";
+      json: {
+        a: boolean;
+        arr: "1" | "2" | "3";
+        arr1: 1 | 2 | 3;
+        arr2: number[];
+        arrStr?: null | string[];
+        o?: null | { o1: number } | { o2: boolean };
+      };
+      jsonOneOf?: null | { command: "a" } | { command: "b"; option: number[] };
+      status?:
+        | null
+        | { ok: string }
+        | { err: string }
+        | { loading: { loaded: number; total: number } };
+      table_config?: null | {
+        referencedTables?: { name: string; minFiles: number }[];
+        recType?: null | Record<"a" | "b", { bools: boolean[] }>;
+      };
     };
   };
   tr1: {
@@ -261,8 +266,8 @@ export type DBSchemaGenerated = {
     columns: {
       email: string;
       id?: number;
-      preferences: {    showIntro?: boolean;   theme?: 'light' | 'dark' | 'auto';   others: any[];  };
-      status: "active" | "disabled" | "pending"
+      preferences: { showIntro?: boolean; theme?: "light" | "dark" | "auto"; others: any[] };
+      status: "active" | "disabled" | "pending";
     };
   };
   users_public_info: {
@@ -316,5 +321,4 @@ export type DBSchemaGenerated = {
       tsv?: null | string;
     };
   };
-  
-}
+};

package/lib/typeTests/dboTypeCheck.ts

@@ -2,7 +2,7 @@ import { ViewHandler } from "prostgles-types";
 import type { DBOFullyTyped } from "../DBSchemaBuilder";
 import type { DBHandlerServer } from "../DboBuilder/DboBuilder";
 import { Publish } from "../PublishParser/PublishParser";
-import { DBSchemaGenerated } from "./DBoGenerated";
+import { DBGeneratedSchema } from "./DBoGenerated";
 
 type DBSchema2 = {
   tr2: {
@@ -18,24 +18,27 @@ type DBSchema2 = {
       tr1_id?: null | number;
     };
   };
-}
-export const testDboTypes =  () => {
-  (async () => {
+};
+export const testDboTypes = () => {
+  async () => {
     const dbo = {} as DBOFullyTyped;
     dbo.someTable?.find;
 
     const dbo1 = {} as DBHandlerServer;
     dbo1.w?.find;
 
-    const db = {} as DBOFullyTyped<DBSchemaGenerated>;
+    const db = {} as DBOFullyTyped<DBGeneratedSchema>;
     db.items2.find;
 
-    const r = await db.items2.find({ }, { 
-      select: { id: 1 }, 
-      orderBy: { 
-        id: 1,
-      } 
-    });
+    const r = await db.items2.find(
+      {},
+      {
+        select: { id: 1 },
+        orderBy: {
+          id: 1,
+        },
+      }
+    );
 
     r[0]?.id;
 
@@ -43,39 +46,50 @@ export const testDboTypes =  () => {
     r[0]?.bad_col;
 
     const tr2 = {} as ViewHandler<DBSchema2["tr2"]["columns"], DBSchema2>;
-    tr2.find({}, {
-      select: { id: 1 },
-      orderBy: { tr1_id: 1 } 
-    });
+    tr2.find(
+      {},
+      {
+        select: { id: 1 },
+        orderBy: { tr1_id: 1 },
+      }
+    );
 
-    tr2.find({}, {
-      //@ts-expect-error
-      select: { bad_col: 1 } 
-    });
+    tr2.find(
+      {},
+      {
+        //@ts-expect-error
+        select: { bad_col: 1 },
+      }
+    );
 
-    tr2.find({}, {
-      //@ts-expect-error
-      orderBy: { bad_col: 1 } 
-    });
+    tr2.find(
+      {},
+      {
+        //@ts-expect-error
+        orderBy: { bad_col: 1 },
+      }
+    );
 
-    (await db.items2.find({}, { select: { items_id: 1 }, returnType: "values" })) satisfies (number | null)[];
-    
+    (await db.items2.find({}, { select: { items_id: 1 }, returnType: "values" })) satisfies (
+      | number
+      | null
+    )[];
 
-    const publish: Publish<DBSchemaGenerated> = {
+    const publish: Publish<DBGeneratedSchema> = {
       items: {
         insert: {
-          fields: { 
-            name: 1, 
+          fields: {
+            name: 1,
             //@ts-expect-error
-            bad_col: 1
+            bad_col: 1,
           },
           validate: async (row) => ({
             ...row,
-            h: [""]
-          })
-        }
-      }
+            h: [""],
+          }),
+        },
+      },
     };
     publish;
-  })
-}
+  };
+};

package/lib/utils.ts

@@ -1,15 +1,14 @@
-
 export { get } from "prostgles-types";
 export const clone = <T extends any[] | Record<string, any>>(obj: T): T => {
-  if(typeof structuredClone !== "undefined"){
+  if (typeof structuredClone !== "undefined") {
     return structuredClone(obj);
   }
-  
+
   return JSON.parse(JSON.stringify(obj));
-}
+};
 
 export const sleep = function (ms: number) {
   return new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
-} 
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-server",
-  "version": "4.2.179",
+  "version": "4.2.181",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,7 +15,8 @@
     "test-only": "cd tests/ && ./test.sh",
     "test-quick": "cd tests/ && ./test.sh -quick",
     "test": "rm -rf ./node_modules/* && rm -rf ./dist/* && npm i && npm run lint && npm run test-only",
-    "pushpublish": "npm version patch --git-tag-version false && git push && npm publish"
+    "generate-docs": "rm -f ./documentation/*.md && cd documentation/utils && npm start",
+    "pushpublish": "npm run generate-docs && npm version patch --git-tag-version false && git push && npm publish"
   },
   "repository": {
     "type": "git",
@@ -54,7 +55,7 @@
     "pg": "^8.11.5",
     "pg-cursor": "^2.11.0",
     "pg-promise": "^11.9.1",
-    "prostgles-types": "^4.0.112"
+    "prostgles-types": "^4.0.119"
   },
   "devDependencies": {
     "@types/express": "^4.17.21",
@@ -67,6 +68,7 @@
     "@typescript-eslint/eslint-plugin": "^8.15.0",
     "@typescript-eslint/parser": "^8.15.0",
     "eslint": "^8.51.0",
+    "prettier": "^3.4.2",
     "socket.io": "^4.8.1",
     "typescript": "^5.3.3"
   }

package/examples/server/typescript/index.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=index.d.ts.map

package/examples/server/typescript/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":""}