prostgles-server 4.2.183 → 4.2.184

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;
+    }
+);