prostgles-server 4.2.183 → 4.2.185

package/lib/DBSchemaBuilder.ts

@@ -10,7 +10,11 @@ import {
 } from "prostgles-types";
 import prostgles from ".";
 import { Auth } from "./Auth/AuthTypes";
-import { DboBuilder, escapeTSNames, postgresToTsType } from "./DboBuilder/DboBuilder";
+import {
+  DboBuilder,
+  escapeTSNames,
+  postgresToTsType,
+} from "./DboBuilder/DboBuilder";
 import {
   PublishAllOrNothing,
   PublishParams,
@@ -18,14 +22,28 @@ import {
   PublishViewRule,
 } from "./PublishParser/PublishParser";
 import { getJSONBSchemaTSTypes } from "./JSONBValidation/validation";
-import { DBHandlerServer, TableSchemaColumn, TX } from "./DboBuilder/DboBuilderTypes";
+import {
+  DBHandlerServer,
+  TableSchemaColumn,
+  TX,
+} from "./DboBuilder/DboBuilderTypes";
 
 export const getDBSchema = (dboBuilder: DboBuilder): string => {
   const tables: string[] = [];
 
-  const getColTypeForDBSchema = (udt_name: TableSchemaColumn["udt_name"]): string => {
+  const getColTypeForDBSchema = (
+    udt_name: TableSchemaColumn["udt_name"],
+  ): string => {
     if (udt_name === "interval") {
-      const units = ["years", "months", "days", "hours", "minutes", "seconds", "milliseconds"];
+      const units = [
+        "years",
+        "months",
+        "days",
+        "hours",
+        "minutes",
+        "seconds",
+        "milliseconds",
+      ];
 
       return `{ ${units.map((u) => `${u}?: number;`).join(" ")} }`;
     }
@@ -38,13 +56,23 @@ export const getDBSchema = (dboBuilder: DboBuilder): string => {
     ?.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));
+      const cols = tov.columns
+        .slice(0)
+        .sort((a, b) => a.name.localeCompare(b.name));
       const getColType = (c: (typeof cols)[number]) => {
         let type: string =
-          (c.is_nullable ? "null | " : "") + getColTypeForDBSchema(c.udt_name) + ";";
-        const colConf = dboBuilder.prostgles.tableConfigurator?.getColumnConfig(tov.name, c.name);
+          (c.is_nullable ? "null | " : "") +
+          getColTypeForDBSchema(c.udt_name) +
+          ";";
+        const colConf = dboBuilder.prostgles.tableConfigurator?.getColumnConfig(
+          tov.name,
+          c.name,
+        );
         if (colConf) {
-          if (isObject(colConf) && (colConf.jsonbSchema || colConf.jsonbSchemaType)) {
+          if (
+            isObject(colConf) &&
+            (colConf.jsonbSchema || colConf.jsonbSchemaType)
+          ) {
             const schema: JSONB.JSONBSchema = colConf.jsonbSchema || {
               ...colConf,
               type: colConf.jsonbSchemaType,
@@ -54,11 +82,13 @@ export const getDBSchema = (dboBuilder: DboBuilder): string => {
               schema,
               { nullable: colConf.nullable },
               "      ",
-              dboBuilder.tablesOrViews ?? []
+              dboBuilder.tablesOrViews ?? [],
             );
           } else if (isObject(colConf) && "enum" in colConf) {
             if (!colConf.enum) throw "colConf.enum missing";
-            const types = colConf.enum.map((t) => (typeof t === "number" ? t : JSON.stringify(t)));
+            const types = colConf.enum.map((t) =>
+              typeof t === "number" ? t : JSON.stringify(t),
+            );
             if (colConf.nullable) {
               types.unshift("null");
             }
@@ -80,7 +110,7 @@ export const getDBSchema = (dboBuilder: DboBuilder): string => {
     columns: {${cols
       .map(
         (c) => `
-      ${getColType(c)}`
+      ${getColType(c)}`,
       )
       .join("")}
     };
@@ -102,12 +132,11 @@ type ServerTableHandler<
   Schema extends DBSchema | void = void,
 > = TableHandler<T, Schema> & { is_view: boolean };
 
-export type DBTableHandlersFromSchema<Schema = void> =
-  Schema extends DBSchema ?
-    {
-      [tov_name in keyof Schema]: Schema[tov_name]["is_view"] extends true ?
-        ServerViewHandler<Schema[tov_name]["columns"], Schema>
-      : ServerTableHandler<Schema[tov_name]["columns"], Schema>;
+export type DBTableHandlersFromSchema<Schema = void> = Schema extends DBSchema
+  ? {
+      [tov_name in keyof Schema]: Schema[tov_name]["is_view"] extends true
+        ? ServerViewHandler<Schema[tov_name]["columns"], Schema>
+        : ServerTableHandler<Schema[tov_name]["columns"], Schema>;
     }
   : Record<string, Partial<ServerTableHandler>>;
 
@@ -125,17 +154,22 @@ export type DBHandlerServerExtra<
 export type DBOFullyTyped<Schema = void> = DBTableHandlersFromSchema<Schema> &
   DBHandlerServerExtra<DBTableHandlersFromSchema<Schema>>;
 
-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"], Schema>
-            : PublishTableRule<Schema[tov_name]["columns"], Schema>);
-      }
-  : PublishAllOrNothing | Record<string, PublishViewRule | PublishTableRule | PublishAllOrNothing>;
+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"], Schema>
+                : PublishTableRule<Schema[tov_name]["columns"], Schema>);
+        }
+  :
+      | PublishAllOrNothing
+      | Record<
+          string,
+          PublishViewRule | PublishTableRule | PublishAllOrNothing
+        >;
 
 /** Type checks */
 () => {

package/lib/DboBuilder/DboBuilder.ts

@@ -167,7 +167,9 @@ export class DboBuilder {
 
   _joins?: Join[];
   get joins(): Join[] {
-    return clone(this._joins ?? []).filter((j) => j.tables[0] !== j.tables[1]) as Join[];
+    return clone(this._joins ?? []).filter(
+      (j) => j.tables[0] !== j.tables[1],
+    ) as Join[];
   }
 
   set joins(j: Join[]) {
@@ -179,7 +181,8 @@ export class DboBuilder {
   }
 
   prepareShortestJoinPaths = async () => {
-    const { joins, shortestJoinPaths, joinGraph } = await prepareShortestJoinPaths(this);
+    const { joins, shortestJoinPaths, joinGraph } =
+      await prepareShortestJoinPaths(this);
     this.joinGraph = joinGraph;
     this.joins = joins;
     this.shortestJoinPaths = shortestJoinPaths;
@@ -189,12 +192,17 @@ export class DboBuilder {
     query: string,
     params: any,
     options: SQLOptions | undefined,
-    localParams?: LocalParams
+    localParams?: LocalParams,
   ) => {
     return runSQL
       .bind(this)(query, params, options, localParams)
       .catch((error) =>
-        Promise.reject(getSerializedClientErrorFromPGError(error, { type: "sql", localParams }))
+        Promise.reject(
+          getSerializedClientErrorFromPGError(error, {
+            type: "sql",
+            localParams,
+          }),
+        ),
       );
   };
 
@@ -207,7 +215,7 @@ export class DboBuilder {
       if (subscribeError) {
         console.error(
           "Could not initiate PubSubManager. Realtime data/Subscriptions will not work. Error: ",
-          subscribeError
+          subscribeError,
         );
         this.canSubscribe = false;
       } else {
@@ -218,7 +226,7 @@ export class DboBuilder {
     const start = Date.now();
     const tablesOrViewsReq = await getTablesForSchemaPostgresSQL(
       this,
-      this.prostgles.opts.schemaFilter
+      this.prostgles.opts.schemaFilter,
     );
     await this.prostgles.opts.onLog?.({
       type: "debug",
@@ -228,28 +236,31 @@ export class DboBuilder {
     });
     this.tablesOrViews = tablesOrViewsReq.result;
 
-    this.constraints = await getConstraints(this.db, this.prostgles.opts.schemaFilter);
+    this.constraints = await getConstraints(
+      this.db,
+      this.prostgles.opts.schemaFilter,
+    );
     await this.prepareShortestJoinPaths();
 
     this.dbo = {};
     this.tablesOrViews.map((tov) => {
-      const columnsForTypes = tov.columns.slice(0).sort((a, b) => a.name.localeCompare(b.name));
+      const columnsForTypes = tov.columns
+        .slice(0)
+        .sort((a, b) => a.name.localeCompare(b.name));
 
       const filterKeywords = Object.values(this.prostgles.keywords);
-      const $filterCol = columnsForTypes.find((c) => filterKeywords.includes(c.name));
+      const $filterCol = columnsForTypes.find((c) =>
+        filterKeywords.includes(c.name),
+      );
       if ($filterCol) {
         throw `DboBuilder init error: \n\nTable ${JSON.stringify(tov.name)} column ${JSON.stringify($filterCol.name)} is colliding with Prostgles filtering functionality ($filter keyword)
                 Please provide a replacement keyword name using the $filter_keyName init option. 
                 Alternatively you can rename the table column\n`;
       }
 
-      this.dbo[tov.escaped_identifier] = new (tov.is_view ? ViewHandler : TableHandler)(
-        this.db,
-        tov,
-        this,
-        undefined,
-        this.shortestJoinPaths
-      );
+      this.dbo[tov.escaped_identifier] = new (
+        tov.is_view ? ViewHandler : TableHandler
+      )(this.db, tov, this, undefined, this.shortestJoinPaths);
 
       if (
         this.shortestJoinPaths &&
@@ -282,7 +293,9 @@ export class DboBuilder {
     if (!this.dbo.sql) {
       this.dbo.sql = this.runSQL;
     } else {
-      console.warn(`Could not create dbo.sql handler because there is already a table named "sql"`);
+      console.warn(
+        `Could not create dbo.sql handler because there is already a table named "sql"`,
+      );
     }
 
     this.tsTypesDefinition = [
@@ -296,7 +309,7 @@ export class DboBuilder {
 
   getShortestJoinPath = (
     viewHandler: ViewHandler,
-    target: string
+    target: string,
   ): JoinPaths[number] | undefined => {
     const source = viewHandler.name;
     if (source === target) {
@@ -315,7 +328,9 @@ export class DboBuilder {
       };
     }
 
-    const jp = this.shortestJoinPaths.find((jp) => jp.t1 === source && jp.t2 === target);
+    const jp = this.shortestJoinPaths.find(
+      (jp) => jp.t1 === source && jp.t2 === target,
+    );
     return jp;
   };
 
@@ -324,7 +339,13 @@ export class DboBuilder {
       const dbTX: DbTxTableHandlers & Pick<DBHandlerServer, "sql"> = {};
       this.tablesOrViews?.map((tov) => {
         const handlerClass = tov.is_view ? ViewHandler : TableHandler;
-        dbTX[tov.name] = new handlerClass(this.db, tov, this, { t, dbTX }, this.shortestJoinPaths);
+        dbTX[tov.name] = new handlerClass(
+          this.db,
+          tov,
+          this,
+          { t, dbTX },
+          this.shortestJoinPaths,
+        );
       });
       dbTX.sql = (q, args, opts, localP) =>
         this.runSQL(q, args, opts, { tx: { dbTX, t }, ...(localP ?? {}) });
@@ -338,6 +359,9 @@ export class DboBuilder {
   cacheDBTypes = cacheDBTypes.bind(this);
 
   runClientTransactionStatement = (statement: string) => {
-    return runClientTransactionStatement(statement, this.prostgles.opts.dbConnection as any);
+    return runClientTransactionStatement(
+      statement,
+      this.prostgles.opts.dbConnection as any,
+    );
   };
 }

package/lib/DboBuilder/DboBuilderTypes.ts

@@ -1,10 +1,9 @@
-
 /*---------------------------------------------------------------------------------------------
  *  Copyright (c) Stefan L. All rights reserved.
  *  Licensed under the MIT License. See LICENSE in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import * as pgPromise from 'pg-promise';
+import * as pgPromise from "pg-promise";
 import {
   AnyObject,
   ClientSchema,
@@ -14,25 +13,23 @@ import {
   RawJoinPath,
   SQLHandler,
   TableInfo as TInfo,
-  UserLike
+  UserLike,
 } from "prostgles-types";
 import { BasicSession, ExpressReq } from "../Auth/AuthTypes";
 import { BasicCallback } from "../PubSubManager/PubSubManager";
-import {
-  PublishAllOrNothing
-} from "../PublishParser/PublishParser";
-import { FieldSpec, } from "./QueryBuilder/Functions";
+import { PublishAllOrNothing } from "../PublishParser/PublishParser";
+import { FieldSpec } from "./QueryBuilder/Functions";
 import { TableHandler } from "./TableHandler/TableHandler";
 import { ParsedJoinPath } from "./ViewHandler/parseJoinPath";
-import pg = require('pg-promise/typescript/pg-subset');
-
+import pg = require("pg-promise/typescript/pg-subset");
 
 type PGP = pgPromise.IMain<{}, pg.IClient>;
 
-
 export type TableSchemaColumn = ColumnInfo & {
-  privileges: Partial<Record<"INSERT" | "REFERENCES" | "SELECT" | "UPDATE", true>>;
-}
+  privileges: Partial<
+    Record<"INSERT" | "REFERENCES" | "SELECT" | "UPDATE", true>
+  >;
+};
 
 export type TableSchema = Pick<TableInfo, "uniqueColumnGroups"> & {
   schema: string;
@@ -52,7 +49,7 @@ export type TableSchema = Pick<TableInfo, "uniqueColumnGroups"> & {
   };
   /** Cannot add triggers to hyperTables */
   isHyperTable?: boolean;
-}
+};
 
 export type SortItem = {
   asc: boolean;
@@ -66,13 +63,16 @@ export type SortItem = {
     wrapperQuerySortItem: string;
     joinAlias: string;
   };
-} & ({
-  type: "query";
-  fieldQuery: string;
-} | {
-  type: "position";
-  fieldPosition: number;
-});
+} & (
+  | {
+      type: "query";
+      fieldQuery: string;
+    }
+  | {
+      type: "position";
+      fieldPosition: number;
+    }
+);
 
 export type Media = {
   id?: string;
@@ -94,26 +94,27 @@ export type Media = {
 export type ParsedMedia = Required<Pick<Media, "extension" | "content_type">>;
 
 export type TxCB<TH = DbTxTableHandlers> = {
-  (t: TH & Pick<DBHandlerServer, "sql">, _t: pgPromise.ITask<{}>): (any | void);
-}
+  (t: TH & Pick<DBHandlerServer, "sql">, _t: pgPromise.ITask<{}>): any | void;
+};
 export type TX<TH = TableHandlers> = {
-  (t: TxCB<TH>): Promise<(any | void)>;
-}
+  (t: TxCB<TH>): Promise<any | void>;
+};
 
 export type TableHandlers = {
   [key: string]: Partial<TableHandler>;
-}
+};
 export type DbTxTableHandlers = {
-  [key: string]: Omit<Partial<TableHandler>, "dbTx"> | Omit<TableHandler, "dbTx">;
-}
-
+  [key: string]:
+    | Omit<Partial<TableHandler>, "dbTx">
+    | Omit<TableHandler, "dbTx">;
+};
 
-export type DBHandlerServerExtra<TH = TableHandlers, WithTransactions = true> = {
+export type DBHandlerServerExtra<
+  TH = TableHandlers,
+  WithTransactions = true,
+> = {
   sql: SQLHandler;
-} & (
-  WithTransactions extends true? { tx: TX<TH> } :
-  Record<string, never>
-);
+} & (WithTransactions extends true ? { tx: TX<TH> } : Record<string, never>);
 
 // export type DBHandlerServer<TH = TableHandlers> =
 //   TH &
@@ -123,14 +124,12 @@ export type DBHandlerServerExtra<TH = TableHandlers, WithTransactions = true> =
 //     tx?: TX<TH>
 //   }
 
-export type DBHandlerServer<TH = TableHandlers> =
-  TH &
+export type DBHandlerServer<TH = TableHandlers> = TH &
   Partial<DbJoinMaker> & {
-    sql?: SQLHandler
+    sql?: SQLHandler;
   } & {
-    tx?: TX<TH>
-  }
-
+    tx?: TX<TH>;
+  };
 
 export const pgp: PGP = pgPromise({
   // ,query: function (e) { console.log({psql: e.query, params: e.params}); }
@@ -142,15 +141,16 @@ export type TableInfo = TInfo & {
   oid: number;
   comment: string;
   columns: ColumnInfo[];
-}
+};
 
 export type ViewInfo = TableInfo & {
-  parent_tables: string[]
-}
+  parent_tables: string[];
+};
 
-export type TableOrViewInfo = TableInfo & ViewInfo & {
-  is_view: boolean;
-}
+export type TableOrViewInfo = TableInfo &
+  ViewInfo & {
+    is_view: boolean;
+  };
 
 export type PRGLIOSocket = {
   readonly id: string;
@@ -161,15 +161,22 @@ export type PRGLIOSocket = {
      * IP Address
      */
     address: string;
-    headers?: AnyObject & { cookie?: string; };  //  e.g.: "some_arg=dwdaw; otherarg=23232"
+    headers?: AnyObject & { cookie?: string }; //  e.g.: "some_arg=dwdaw; otherarg=23232"
     auth?: Record<string, any>;
-  }
+  };
 
-  readonly on: (channel: string, params: any, cb?: (err: any, res?: any) => void) => any;// Promise<void>;
+  readonly on: (
+    channel: string,
+    params: any,
+    cb?: (err: any, res?: any) => void,
+  ) => any; // Promise<void>;
 
   readonly emit: (channel: string, message?: any, cb?: BasicCallback) => any;
 
-  readonly once: (channel: string, cb: (_data: any, cb: BasicCallback) => void) => void;
+  readonly once: (
+    channel: string,
+    cb: (_data: any, cb: BasicCallback) => void,
+  ) => void;
 
   readonly removeAllListeners: (channel: string) => void;
 
@@ -177,17 +184,17 @@ export type PRGLIOSocket = {
 
   readonly request: {
     url?: string;
-    connection: { remoteAddress?: string; }
-  }
+    connection: { remoteAddress?: string };
+  };
 
   /** Used for session caching */
   __prglCache?: {
     session: BasicSession;
     user: UserLike;
     clientUser: UserLike;
-  }
+  };
 
-  _user?: AnyObject
+  _user?: AnyObject;
 
   /** Used for publish error caching */
   prostgles?: ClientSchema;
@@ -207,7 +214,7 @@ export type LocalParams = {
   tx?: {
     dbTX: TableHandlers;
     t: pgPromise.ITask<{}>;
-  }
+  };
 
   /** Used to exclude certain logs */
   noLog?: boolean;
@@ -222,14 +229,13 @@ export type LocalParams = {
     previousData: AnyObject;
     previousTable: string;
     referencingColumn?: string;
-  }
-}
-
+  };
+};
 
 export type Aggregation = {
-  field: string,
-  query: string,
-  alias: string,
+  field: string;
+  query: string;
+  alias: string;
   getQuery: (alias: string) => string;
 };
 
@@ -239,50 +245,46 @@ export type JoinInfo = {
   /**
    * If true then all joins involve unique columns and the result is a 1 to 1 join
    */
-  expectOne?: boolean,
+  expectOne?: boolean;
   paths: {
-
     /**
      * The table that JOIN ON columns refer to.
      * columns in index = 1 refer to this table. index = 0 columns refer to previous JoinInfo.table
      */
-    table: string,
+    table: string;
 
     /**
      * Source and target JOIN ON column groups for each existing constraint
-     * Each inner array group will be combined with AND and outer arrays with OR to allow multiple references to the same table  
+     * Each inner array group will be combined with AND and outer arrays with OR to allow multiple references to the same table
      * e.g.:    [[source_table_column: string, table_column: string]]
      */
-    on: [string, string][][],
+    on: [string, string][][];
 
     /**
      * Source table name
      */
-    source: string,
+    source: string;
 
     /**
      * Target table name
      */
-    target: string
-  }[]
-}
-
+    target: string;
+  }[];
+};
 
 export type CommonTableRules = {
-
   /**
-   * True by default. Allows clients to get column information on any columns that are allowed in (select, insert, update) field rules. 
+   * True by default. Allows clients to get column information on any columns that are allowed in (select, insert, update) field rules.
    */
   getColumns?: PublishAllOrNothing;
 
   /**
-   * True by default. Allows clients to get table information (oid, comment, label, has_media). 
+   * True by default. Allows clients to get table information (oid, comment, label, has_media).
    */
-  getInfo?: PublishAllOrNothing
-}
+  getInfo?: PublishAllOrNothing;
+};
 
 export type ValidatedTableRules = CommonTableRules & {
-
   /* All columns of the view/table. Includes computed fields as well */
   allColumns: FieldSpec[];
 
@@ -301,7 +303,7 @@ export type ValidatedTableRules = CommonTableRules & {
 
     /* Max limit allowed for each select. 1000 by default. If null then an unlimited select is allowed when providing { limit: null } */
     maxLimit: number | null;
-  },
+  };
   update: {
     /* Fields you can update */
     fields: string[];
@@ -317,7 +319,7 @@ export type ValidatedTableRules = CommonTableRules & {
 
     /* Data applied to every update */
     forcedData: any;
-  },
+  };
   insert: {
     /* Fields you can insert */
     fields: string[];
@@ -327,7 +329,7 @@ export type ValidatedTableRules = CommonTableRules & {
 
     /* Data applied to every insert */
     forcedData: any;
-  },
+  };
   delete: {
     /* Fields to filter by when deleting */
     filterFields: string[];
@@ -337,8 +339,8 @@ export type ValidatedTableRules = CommonTableRules & {
 
     /* Fields you can return after deleting */
     returningFields: string[];
-  }
-}
+  };
+};
 
 export type ExistsFilterConfig = {
   existType: EXISTS_KEY;
@@ -346,17 +348,19 @@ export type ExistsFilterConfig = {
    * Target table filter. target table is the last table from tables
    */
   targetTableFilter: Filter;
-
-} & ({
-  isJoined: true;
-  /**
-   * list of join tables in their order
-   * If table path starts with "**" then get shortest join to first table
-   * e.g.: "**.users" means finding the shortest join from root table to users table
-   */
-  path: RawJoinPath;
-  parsedPath: ParsedJoinPath[]
-} | {
-  isJoined: false;
-  targetTable: string;
-});
+} & (
+  | {
+      isJoined: true;
+      /**
+       * list of join tables in their order
+       * If table path starts with "**" then get shortest join to first table
+       * e.g.: "**.users" means finding the shortest join from root table to users table
+       */
+      path: RawJoinPath;
+      parsedPath: ParsedJoinPath[];
+    }
+  | {
+      isJoined: false;
+      targetTable: string;
+    }
+);