prostgles-server 4.2.160 → 4.2.161

package/lib/DBSchemaBuilder.ts

@@ -0,0 +1,225 @@
+import { AnyObject, DbJoinMaker, DBSchema, isObject, JSONB, SQLHandler, TableHandler, ViewHandler } from "prostgles-types";
+import prostgles from ".";
+import { Auth } from "./Auth/AuthTypes";
+import { DboBuilder, escapeTSNames, postgresToTsType } from "./DboBuilder/DboBuilder";
+import { PublishAllOrNothing, PublishParams, PublishTableRule, PublishViewRule,  } from "./PublishParser/PublishParser";
+import { getJSONBSchemaTSTypes } from "./JSONBValidation/validation";
+import { DBHandlerServer, TableSchemaColumn, TX } from "./DboBuilder/DboBuilderTypes";
+
+
+export const getDBSchema = (dboBuilder: DboBuilder): string => {
+  const tables: string[] = [];
+
+  const getColTypeForDBSchema = (udt_name: TableSchemaColumn["udt_name"]): string => {
+    if(udt_name === "interval"){
+      const units = [ "years", "months", "days", "hours", "minutes", "seconds", "milliseconds"];
+      
+      return `{ ${units.map(u => `${u}?: number;`).join(" ")} }`;
+    }
+
+    return postgresToTsType(udt_name);
+  }
+  
+  /** Tables and columns are sorted to avoid infinite loops due to changing order */
+  dboBuilder.tablesOrViews?.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 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);
+      if(colConf){
+        if(isObject(colConf) && (colConf.jsonbSchema || colConf.jsonbSchemaType)){
+          const schema: JSONB.JSONBSchema = colConf.jsonbSchema || { ...colConf, type: colConf.jsonbSchemaType };
+          
+          type = getJSONBSchemaTSTypes(schema, { nullable: colConf.nullable }, "      ", 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));
+          if(colConf.nullable){
+            types.unshift("null")
+          }
+          type = types.join(" | ");
+        }
+      }
+      /**
+       * Columns that are nullable or have default values can be ommitted from an insert
+       * Non nullable columns with default values cannot containt null values in an insert so they must contain a valid value or be omitted
+       */
+      return `${escapeTSNames(c.name)}${c.is_nullable || c.has_default? "?" : ""}: ${type}`
+    }
+tables.push(`${escapeTSNames(tov.name)}: {
+    is_view: ${tov.is_view};
+    select: ${tov.privileges.select};
+    insert: ${tov.privileges.insert};
+    update: ${tov.privileges.update};
+    delete: ${tov.privileges.delete};
+    columns: {${cols.map(c => `
+      ${getColType(c)}`).join("")}
+    };
+  };\n  `)
+  })
+return `
+export type DBSchemaGenerated = {
+  ${tables.join("")}
+}
+`;
+}
+
+type ServerViewHandler<T extends AnyObject = AnyObject, Schema extends DBSchema | void = void> = ViewHandler<T, Schema> & { is_view: boolean; }
+type ServerTableHandler<T extends AnyObject = AnyObject, 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>
+} : Record<string, Partial<ServerTableHandler>>;
+
+export type DBHandlerServerExtra<TH = Record<string, Partial<ServerTableHandler>>, WithTransactions = true> = {
+  sql: SQLHandler;
+} & Partial<DbJoinMaker> & (
+  WithTransactions extends true? { tx: TX<TH> } :
+  Record<string, never>
+);
+// export type DBOFullyTyped<Schema = void> = Schema extends DBSchema? (
+//     DBTableHandlersFromSchema<Schema> & DBHandlerServerExtra<DBTableHandlersFromSchema<Schema>>
+//   ) : 
+//   DBHandlerServer;
+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>
+);
+
+
+
+/** Type checks */
+(() => {
+
+  const ddb: DBOFullyTyped = 1 as any;
+  ddb.dwad?.insert;
+  ddb.dwad?.delete;
+
+  const d: DBOFullyTyped<undefined> = 1 as any;
+  d.dwad?.insert;
+  d.dwad?.delete;
+
+  const p: PublishParams = 1 as any;
+  p.dbo.dwad?.insert;
+  ddb.dwad?.delete;
+
+  //@ts-ignore
+  prostgles({
+    dbConnection: 1 as any,
+    publish: async (params) => {
+      const _rows = await params.dbo.dwadwa?.find?.({});
+      
+      return "*" as const
+    },
+    transactions: true,
+    onReady: ({ dbo }) => {
+      dbo.tdwa?.find!();
+      dbo.tx?.(t => {
+        t.dwa?.find!();
+      })
+    }
+  });
+
+
+  const _auth: Auth = {
+    sidKeyName: "sid_token",
+    getUser: async (sid, db, _db) => {
+      db.dwadaw?.find;
+      return 1 as any;
+    }
+  }
+
+
+  type S = {
+    tbl1: {
+      columns: {
+        col1: number | null;
+        col2: string; 
+      }
+    },
+    tbl2: {
+      columns: {
+        col1: number | null;
+        col2: string; 
+      }
+    }
+  }
+
+  /** Test the created schema */
+  const c: S = 1 as any;
+  const _test: DBSchema = c;
+  const dbt: DBOFullyTyped<S> = 1 as any;
+
+  dbt.tx!(t => {
+    t.tbl1.delete();
+  });
+
+  const db: DBHandlerServer = 1 as any;
+  db.tx!(t => {
+    t.wadwa?.find!()
+  });
+  
+  const _publish = (): PublishFullyTyped<S> => {
+    const r = {
+      tbl1: {
+        select: {
+          fields: "*" as const, 
+          forcedFilter: { col1: 32, col2: "" }
+        },
+        getColumns: true,
+        getInfo: true,
+        delete: {
+          filterFields: {col1: 1}
+        }
+      },
+      tbl2: {
+        delete: {
+          filterFields: "*" as const,
+          forcedFilter: {col1: 2}
+        }
+      }
+    }
+    const res: PublishFullyTyped<S> = {
+      tbl1: {
+        select: {
+          fields: "*",
+          forcedFilter: { col1: 32, col2: "" }
+        },
+        getColumns: true,
+        getInfo: true,
+        delete: {
+          filterFields: { col1: 1 }
+        }
+      },
+      tbl2: {
+        delete: {
+          filterFields: "*" as const,
+          forcedFilter: { col1: 2 }
+        }
+      }
+    }
+    const _res1: PublishFullyTyped = r
+  
+    const p: PublishParams<undefined> = 1 as any;
+  
+    p.dbo.dwadaw?.find?.();
+  
+    return res;
+  }
+})

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