prostgles-server 4.2.158 → 4.2.159

package/lib/DboBuilder/DboBuilder.ts

@@ -1,319 +0,0 @@
-
-/*---------------------------------------------------------------------------------------------
- *  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

@@ -1,361 +0,0 @@
-
-/*---------------------------------------------------------------------------------------------
- *  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;
-});