prostgles-server 4.2.160 → 4.2.162

package/lib/DboBuilder/DboBuilder.ts

@@ -0,0 +1,319 @@
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Stefan L. All rights reserved.
+ *  Licensed under the MIT License. See LICENSE in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import {
+  PG_COLUMN_UDT_DATA_TYPE,
+  SQLOptions,
+  getJoinHandlers,
+  isDefined,
+  tryCatch
+} from "prostgles-types";
+import { getDBSchema } from "../DBSchemaBuilder";
+import {
+  DB, Prostgles
+} from "../Prostgles";
+import { Join } from "../ProstglesTypes";
+import { PubSubManager } from "../PubSubManager/PubSubManager";
+import { getCreatePubSubManagerError } from "../PubSubManager/getCreatePubSubManagerError";
+import {
+  DbTableInfo,
+  PublishParser
+} from "../PublishParser/PublishParser";
+import { Graph } from "../shortestPath";
+import { clone } from "../utils";
+import { DBHandlerServer, DbTxTableHandlers, LocalParams, TX, TableSchema, TxCB } from "./DboBuilderTypes";
+import { QueryStreamer } from "./QueryStreamer";
+import { TableHandler } from "./TableHandler/TableHandler";
+import { JoinPaths, ViewHandler } from "./ViewHandler/ViewHandler";
+import { parseJoinPath } from "./ViewHandler/parseJoinPath";
+import { PGConstraint, getCanExecute, getConstraints, getErrorAsObject, getSerializedClientErrorFromPGError } from "./dboBuilderUtils";
+import { getTablesForSchemaPostgresSQL } from "./getTablesForSchemaPostgresSQL";
+import { prepareShortestJoinPaths } from "./prepareShortestJoinPaths";
+import { cacheDBTypes, runSQL } from "./runSQL";
+import { runClientTransactionStatement } from "./runTransaction";
+
+export * from "./DboBuilderTypes";
+export * from "./dboBuilderUtils";
+
+type OidInfo = {
+  /**
+   * Oid
+   */
+  relid: number;
+  relname: string;
+  schemaname: string;
+};
+
+type TableOidInfo = OidInfo & {
+  pkey_columns: string[] | null;
+};
+
+type TableOidColumnInfo = OidInfo & {
+  column_name: string;
+  udt_name: string;
+  ordinal_position: number;
+};
+
+
+export class DboBuilder {
+  tablesOrViews?: TableSchema[];
+  /**
+   * Used in obtaining column names for error messages
+   */
+  constraints?: PGConstraint[];
+
+  db: DB;
+
+  dbo: DBHandlerServer;
+
+  /**
+   * Undefined if cannot create table triggers
+   */
+  private _pubSubManager?: PubSubManager;
+
+  /**
+   * Used for db.sql field type details
+   */
+  DATA_TYPES: { oid: string, typname: PG_COLUMN_UDT_DATA_TYPE }[] | undefined;
+  DATA_TYPES_DBKEY = "";
+  USER_TABLES: TableOidInfo[] | undefined;
+  USER_TABLE_COLUMNS: TableOidColumnInfo[] | undefined;
+  
+  queryStreamer: QueryStreamer;
+
+  get tables(): DbTableInfo[] {
+    return (this.tablesOrViews ?? [])
+      .map(({ name, columns }) => {
+        const info = this.dbo[name]?.tableOrViewInfo;
+        if(!info) return undefined;
+        return {
+          name,
+          columns,
+          info
+      }})
+      .filter(isDefined);
+  }
+
+  getPubSubManager = async (): Promise<PubSubManager> => {
+    if (!this._pubSubManager) {
+
+      const canExecute = await getCanExecute(this.db)
+      if (!canExecute) throw "PubSubManager based subscriptions not possible: Cannot run EXECUTE statements on this connection";
+
+      const { pubSubManager, error, hasError } = await tryCatch(async () => {
+        const pubSubManager = await PubSubManager.create({
+          dboBuilder: this,
+        });
+        return { pubSubManager };
+      });
+      this._pubSubManager = pubSubManager;
+      if (hasError || !this._pubSubManager ) {
+        await this.prostgles.opts.onLog?.({
+          type: "debug",
+          command: "PubSubManager.create",
+          duration: 0,
+          error: getErrorAsObject(error)
+        });
+        throw "Could not create this._pubSubManager check logs";
+      }
+    }
+
+    return this._pubSubManager;
+  }
+
+  tsTypesDefinition?: string;
+  joinGraph?: Graph;
+  private shortestJoinPaths: JoinPaths = [];
+
+  prostgles: Prostgles;
+  publishParser?: PublishParser;
+
+  onSchemaChange?: (event: { command: string; query: string }) => void;
+
+  private constructor(prostgles: Prostgles) {
+    this.prostgles = prostgles;
+    if (!this.prostgles.db) throw "db missing"
+    this.db = this.prostgles.db;
+    this.dbo = {} as unknown as DBHandlerServer;
+    this.queryStreamer = new QueryStreamer(this);
+  }
+
+  private init = async () => {
+
+    await this.build();
+    /* If watchSchema is enabled then PubSubManager must be created (if possible) because it creates the event trigger */
+    if (
+      this.prostgles.schemaWatch?.type.watchType === "DDL_trigger"
+    ) {
+      await this.getPubSubManager()
+    }
+
+    return this;
+  }
+
+  public static create = async (prostgles: Prostgles): Promise<DboBuilder> => {
+    const res = new DboBuilder(prostgles)
+    return await res.init();
+  }
+
+
+  destroy() {
+    this._pubSubManager?.destroy();
+  }
+
+  _joins?: Join[];
+  get joins(): Join[] {
+    return clone(this._joins ?? []).filter(j => j.tables[0] !== j.tables[1]) as Join[];
+  }
+
+  set joins(j: Join[]) {
+    this._joins = clone(j);
+  }
+
+  getAllJoinPaths() {
+    return this.shortestJoinPaths;
+  }
+
+  prepareShortestJoinPaths = async () => {
+    const { joins, shortestJoinPaths, joinGraph } = await prepareShortestJoinPaths(this);
+    this.joinGraph = joinGraph;
+    this.joins = joins;
+    this.shortestJoinPaths = shortestJoinPaths;
+  }
+
+  runSQL = async (query: string, params: any, options: SQLOptions | undefined, localParams?: LocalParams) => {
+    return runSQL.bind(this)(query, params, options, localParams).catch(error => Promise.reject(getSerializedClientErrorFromPGError(error, { type: "sql" })));
+  }
+
+  canSubscribe = false;
+  checkingCanSubscribe = false;
+  async build(): Promise<DBHandlerServer> {
+    if(!this.canSubscribe && !this.checkingCanSubscribe){
+      this.checkingCanSubscribe = true;
+      const subscribeError = await getCreatePubSubManagerError(this);
+      if(subscribeError){
+        console.error(
+          "Could not initiate PubSubManager. Realtime data/Subscriptions will not work. Error: ",
+          subscribeError
+        );
+        this.canSubscribe = false;
+      } else {
+        this.canSubscribe = true;
+      }
+      this.checkingCanSubscribe = false;
+    }
+    const start = Date.now();
+    const tablesOrViewsReq = await getTablesForSchemaPostgresSQL(this, this.prostgles.opts.schema);
+    await this.prostgles.opts.onLog?.({
+      type: "debug",
+      command: "DboBuilder.getTablesForSchemaPostgresSQL",
+      data: tablesOrViewsReq.durations,
+      duration: Date.now() - start,
+    })
+    this.tablesOrViews = tablesOrViewsReq.result;
+
+    this.constraints = await getConstraints(this.db, this.prostgles.opts.schema);
+    await this.prepareShortestJoinPaths();
+
+    this.dbo = {};
+    this.tablesOrViews.map(tov => {
+      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));
+      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);
+
+      if (this.shortestJoinPaths && this.shortestJoinPaths.find(jp => [jp.t1, jp.t2].includes(tov.name))) {
+
+        const table = tov.name;
+
+        this.dbo.innerJoin ??= {};
+        this.dbo.leftJoin ??= {};
+        this.dbo.innerJoinOne ??= {};
+        this.dbo.leftJoinOne ??= {};
+
+        const joinHandlers = getJoinHandlers(table);
+        //@ts-ignore
+        this.dbo.leftJoin[table] = joinHandlers.leftJoin;
+        this.dbo.innerJoin[table] = joinHandlers.innerJoin;
+        this.dbo.leftJoinOne[table] = joinHandlers.leftJoinOne;
+        this.dbo.innerJoinOne[table] = joinHandlers.innerJoinOne;
+      }
+    });
+
+    if (this.prostgles.opts.transactions) {
+      let txKey = "tx";
+      if (typeof this.prostgles.opts.transactions === "string") txKey = this.prostgles.opts.transactions;
+
+      (this.dbo[txKey] as unknown as TX) = (cb: TxCB) => this.getTX(cb);
+    }
+
+    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"`)
+    }
+
+    this.tsTypesDefinition = [
+      `/* SCHEMA DEFINITON. Table names have been altered to work with Typescript */`,
+      `/* DBO Definition */`,
+      getDBSchema(this)
+    ].join("\n");
+
+    return this.dbo;
+  }
+
+  getShortestJoinPath = (viewHandler: ViewHandler, target: string): JoinPaths[number] | undefined => {
+    const source = viewHandler.name;
+    if(source === target){
+      const joinPath = parseJoinPath({
+        rawPath: target,
+        rootTable: source,
+        viewHandler
+      });
+
+      if(!joinPath) return undefined;
+
+      return {
+        t1: source,
+        t2: target,
+        path: [source]
+      }
+    }
+
+    const jp = this.shortestJoinPaths.find(jp => jp.t1 === source && jp.t2 === target);
+    return jp;
+  }
+
+  getTX = async (cb: TxCB) => {
+    const transaction = await this.db.tx(t => {
+      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.sql = (q, args, opts, localP) => this.runSQL(q, args, opts, { tx: { dbTX, t }, ...(localP ?? {}) })
+
+      return cb(dbTX, t);
+    });
+
+    return transaction;
+  }
+
+  cacheDBTypes = cacheDBTypes.bind(this);
+
+  runClientTransactionStatement = (statement: string) => {
+    return runClientTransactionStatement(statement, this.prostgles.opts.dbConnection as any);
+  }
+}

package/lib/DboBuilder/DboBuilderTypes.ts

@@ -0,0 +1,361 @@
+
+/*---------------------------------------------------------------------------------------------
+ *  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 {
+  AnyObject,
+  ColumnInfo,
+  DbJoinMaker,
+  EXISTS_KEY,
+  RawJoinPath,
+  SQLHandler,
+  TableInfo as TInfo,
+  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 { TableHandler } from "./TableHandler/TableHandler";
+import { ParsedJoinPath } from "./ViewHandler/parseJoinPath";
+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>>;
+}
+
+export type TableSchema = {
+  schema: string;
+  name: string;
+  escaped_identifier: string;
+  oid: number;
+  comment: string;
+  columns: TableSchemaColumn[];
+  is_view: boolean;
+  view_definition: string | null;
+  parent_tables: string[];
+  privileges: {
+    insert: boolean;
+    select: boolean;
+    update: boolean;
+    delete: boolean;
+  };
+  /** Cannot add triggers to hyperTables */
+  isHyperTable?: boolean;
+}
+
+export type SortItem = {
+  asc: boolean;
+  nulls?: "first" | "last";
+  nullEmpty?: boolean;
+  key: string;
+  nested?: {
+    table: string;
+    selectItemAlias: string;
+    isNumeric: boolean;
+    wrapperQuerySortItem: string;
+    joinAlias: string;
+  };
+} & ({
+  type: "query";
+  fieldQuery: string;
+} | {
+  type: "position";
+  fieldPosition: number;
+});
+
+export type Media = {
+  id?: string;
+  title?: string;
+  extension?: string;
+  content_type?: string;
+  content_length?: number;
+  url?: string;
+  added?: Date;
+  signed_url?: string;
+  signed_url_expires?: number;
+  name?: string;
+  original_name?: string;
+  etag?: string;
+  deleted?: string | null;
+  deleted_from_storage?: string | null;
+};
+
+export type ParsedMedia = Required<Pick<Media, "extension" | "content_type">>;
+
+export type TxCB<TH = DbTxTableHandlers> = {
+  (t: TH & Pick<DBHandlerServer, "sql">, _t: pgPromise.ITask<{}>): (any | void);
+}
+export type TX<TH = TableHandlers> = {
+  (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">;
+}
+
+
+export type DBHandlerServerExtra<TH = TableHandlers, WithTransactions = true> = {
+  sql: SQLHandler;
+} & (
+  WithTransactions extends true? { tx: TX<TH> } :
+  Record<string, never>
+);
+
+// export type DBHandlerServer<TH = TableHandlers> =
+//   TH &
+//   Partial<DbJoinMaker> & {
+//     sql?: SQLHandler
+//   } & {
+//     tx?: TX<TH>
+//   }
+
+export type DBHandlerServer<TH = TableHandlers> =
+  TH &
+  Partial<DbJoinMaker> & {
+    sql?: SQLHandler
+  } & {
+    tx?: TX<TH>
+  }
+
+
+export const pgp: PGP = pgPromise({
+  // ,query: function (e) { console.log({psql: e.query, params: e.params}); }
+});
+
+export type TableInfo = TInfo & {
+  schema: string;
+  name: string;
+  oid: number;
+  comment: string;
+  columns: ColumnInfo[];
+}
+
+export type ViewInfo = TableInfo & {
+  parent_tables: string[]
+}
+
+export type TableOrViewInfo = TableInfo & ViewInfo & {
+  is_view: boolean;
+}
+
+export type PRGLIOSocket = {
+  readonly id: string;
+
+  readonly handshake: {
+    query?: Record<string, string | string[] | undefined>;
+    /**
+     * IP Address
+     */
+    address: string;
+    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 emit: (channel: string, message?: any, cb?: BasicCallback) => any;
+
+  readonly once: (channel: string, cb: (_data: any, cb: BasicCallback) => void) => void;
+
+  readonly removeAllListeners: (channel: string) => void;
+
+  readonly disconnect: () => void;
+
+  readonly request: {
+    url?: string;
+    connection: { remoteAddress?: string; }
+  }
+
+  /** Used for session caching */
+  __prglCache?: {
+    session: BasicSession;
+    user: UserLike;
+    clientUser: UserLike;
+  }
+
+  _user?: AnyObject
+
+  /** Used for publish error caching */
+  prostgles?: AnyObject;
+};
+
+export type LocalParams = {
+  httpReq?: ExpressReq;
+  socket?: PRGLIOSocket;
+  func?: () => any;
+  isRemoteRequest?: {
+    user?: UserLike | undefined;
+  };
+  testRule?: boolean;
+  tableAlias?: string;
+  // subOne?: boolean;
+
+  tx?: {
+    dbTX: TableHandlers;
+    t: pgPromise.ITask<{}>;
+  }
+
+  /** Used to exclude certain logs */
+  noLog?: boolean;
+
+  returnQuery?: boolean | "noRLS" | "where-condition";
+  returnNewQuery?: boolean;
+  /** Used for count/size queries */
+  bypassLimit?: boolean;
+
+  nestedInsert?: {
+    depth: number;
+    previousData: AnyObject;
+    previousTable: string;
+    referencingColumn?: string;
+  }
+}
+
+
+export type Aggregation = {
+  field: string,
+  query: string,
+  alias: string,
+  getQuery: (alias: string) => string;
+};
+
+export type Filter = AnyObject | { $and: Filter[] } | { $or: Filter[] };
+
+export type JoinInfo = {
+  /**
+   * If true then all joins involve unique columns and the result is a 1 to 1 join
+   */
+  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,
+
+    /**
+     * 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  
+     * e.g.:    [[source_table_column: string, table_column: string]]
+     */
+    on: [string, string][][],
+
+    /**
+     * Source table name
+     */
+    source: string,
+
+    /**
+     * Target table name
+     */
+    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. 
+   */
+  getColumns?: PublishAllOrNothing;
+
+  /**
+   * True by default. Allows clients to get table information (oid, comment, label, has_media). 
+   */
+  getInfo?: PublishAllOrNothing
+}
+
+export type ValidatedTableRules = CommonTableRules & {
+
+  /* All columns of the view/table. Includes computed fields as well */
+  allColumns: FieldSpec[];
+
+  select: {
+    /* Fields you can select */
+    fields: string[];
+
+    /* Fields you can select */
+    orderByFields: string[];
+
+    /* Filter applied to every select */
+    filterFields: string[];
+
+    /* Filter applied to every select */
+    forcedFilter: any;
+
+    /* 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[];
+
+    /* Fields you can return after updating */
+    returningFields: string[];
+
+    /* Fields you can use in filtering when updating */
+    filterFields: string[];
+
+    /* Filter applied to every update. Filter fields cannot be updated */
+    forcedFilter: any;
+
+    /* Data applied to every update */
+    forcedData: any;
+  },
+  insert: {
+    /* Fields you can insert */
+    fields: string[];
+
+    /* Fields you can return after inserting. Will return select.fields by default */
+    returningFields: string[];
+
+    /* Data applied to every insert */
+    forcedData: any;
+  },
+  delete: {
+    /* Fields to filter by when deleting */
+    filterFields: string[];
+
+    /* Filter applied to every deletes */
+    forcedFilter: any;
+
+    /* Fields you can return after deleting */
+    returningFields: string[];
+  }
+}
+
+export type ExistsFilterConfig = {
+  existType: EXISTS_KEY;
+  /**
+   * 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;
+});