prostgles-server 2.0.172 → 2.0.175

package/lib/DboBuilder.ts

@@ -42,23 +42,23 @@ export type Media = {
     "etag"?: string;
 }
 
-export interface TxHandler {
-    [key: string]: TableHandler | ViewHandler;
+export type TxHandler = TablesAndViewHandlers;
+export type TxCB<DBO extends TablesAndViewHandlers = TablesAndViewHandlers> = {
+    (t: DBO, _t: pgPromise.ITask<{}>): (any | void);
 }
-export type TxCB = {
-    (t: TxHandler, _t: pgPromise.ITask<{}>): (any | void);
+export type TX<DBO extends TablesAndViewHandlers = TablesAndViewHandlers> = {
+    (t: TxCB<DBO>): Promise<(any | void)>;
 }
-export type TX = {
-    (t: TxCB): Promise<(any | void)>;
+
+type TablesAndViewHandlers = {
+    [key: string]: Partial<TableHandler> | TableHandler;
 }
-export type DbHandler = {
-    [key: string]: Partial<TableHandler>;
-  } & 
-  DbJoinMaker & 
-  {
+export type DBHandlerServer<DBO extends TablesAndViewHandlers = TablesAndViewHandlers>= 
+  TablesAndViewHandlers & 
+  DbJoinMaker & {
     sql?: SQLHandler
   } & {
-    tx?: TX
+    tx?: TX<DBO>
   }
   
 export const getUpdateFilter = (args: { filter?: AnyObject; forcedFilter?: AnyObject; $and_key: string }): AnyObject => {
@@ -76,8 +76,11 @@ export const getUpdateFilter = (args: { filter?: AnyObject; forcedFilter?: AnyOb
 import { get } from "./utils";
 import { getNewQuery, makeQuery, COMPUTED_FIELDS, SelectItem, FieldSpec, asNameAlias, SelectItemBuilder, FUNCTIONS, parseFunction, parseFunctionObject } from "./QueryBuilder";
 import { 
-    DB, TableRule, SelectRule, InsertRule, UpdateRule, DeleteRule, SyncRule, Joins, Join, Prostgles, PublishParser, ValidateRow, ValidateUpdateRow 
+    Join, Prostgles, DB
 } from "./Prostgles";
+import { 
+ TableRule, UpdateRule, SyncRule, PublishParser, ValidateRow, ValidateUpdateRow, PublishAllOrNothing 
+} from "./PublishParser";
 import { PubSubManager, asValue, BasicCallback, pickKeys, omitKeys } from "./PubSubManager";
 
 import { parseFilterItem } from "./Filtering";
@@ -146,7 +149,7 @@ export type LocalParams = {
     dbTX?: TxHandler;
 
     // localTX?: pgPromise.ITask<{}>;
-    localDBTX?: DbHandler;
+    localDBTX?: DBHandlerServer;
 
     returnQuery?: boolean;
 
@@ -165,27 +168,35 @@ function capitalizeFirstLetter(string: string, nonalpha_replacement?: string) :
 
 function snakify(str: string, capitalize = false) : string {
 
-    return str.split("").map((c, i)=> {
+  return str.split("").map((c, i)=> {
 
-        if(!i) {
-            if(capitalize) c = c.toUpperCase();
-            if(c.match(/[^a-z_A-Z]/)){
-                return ((capitalize)? "D_" : "_") + c.charCodeAt(0);
-            }
-        } else {
-            if(c.match(/[^a-zA-Z_0-9]/)){
-                return "_" + c.charCodeAt(0);
-            }
-        }
-        
-        return c;
+    if(!i) {
+      if(capitalize) c = c.toUpperCase();
+      if(c.match(/[^a-z_A-Z]/)){
+          return ((capitalize)? "D_" : "_") + c.charCodeAt(0);
+      }
+    } else {
+      if(c.match(/[^a-zA-Z_0-9]/)){
+        return "_" + c.charCodeAt(0);
+      }
+    }
+    
+    return c;
+
+  }).join("");
+}
 
-    }).join("");
+function canBeUsedAsIsInTypescript(str: string): boolean {
+    if(!str) return false;
+    const isAlphaNumericOrUnderline = str.match(/^[a-z0-9_]+$/i);
+    const startsWithCharOrUnderscore = str[0].match(/^[a-z_]+$/i);
+    return Boolean(isAlphaNumericOrUnderline && startsWithCharOrUnderscore);
 }
 
-function escapeTSNames(str: string, capitalize = true): string {
+export function escapeTSNames(str: string, capitalize = false): string {
     let res = str;
     res = (capitalize? str[0].toUpperCase() : str[0]) + str.slice(1);
+    if(canBeUsedAsIsInTypescript(res)) return res;
     return JSON.stringify(res);
 }
 
@@ -259,12 +270,12 @@ 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?: boolean;
+     getColumns?: PublishAllOrNothing;
     
     /**
      * True by default. Allows clients to get table information (oid, comment, label, has_media). 
      */
-    getInfo?: boolean | null;
+    getInfo?: PublishAllOrNothing
 }
 
 export type ValidatedTableRules = CommonTableRules & {
@@ -509,7 +520,7 @@ export class ViewHandler {
         // if(this.tsDataName === "T") this.tsDataName = this.tsDataName + "_";
         // this.tsDataDef = `export type ${this.tsDataName} = {\n`;
         this.columnsForTypes.map(({ name, udt_name, is_nullable }) => {
-            this.tsColumnDefs.push(`${escapeTSNames(name, false)}?: ${postgresToTsType(udt_name) as string} ${is_nullable? " | null " : ""};`);
+            this.tsColumnDefs.push(`${escapeTSNames(name)}?: ${postgresToTsType(udt_name) as string} ${is_nullable? " | null " : ""};`);
         });
         // this.tsDataDef += "};";
         // this.tsDataDef += "\n";
@@ -760,7 +771,13 @@ export class ViewHandler {
 
     // TODO: fix renamed table trigger problem
     
-    async getColumns(lang?: string, params?: { rule: "update", filter: AnyObject, data: AnyObject }, param3?: never, tableRules?: TableRule, localParams?: LocalParams): Promise<ValidatedColumnInfo[]> {
+    async getColumns(
+        lang?: string, 
+        params?: { rule: "update", filter: AnyObject, data: AnyObject }, 
+        _param3?: never, 
+        tableRules?: TableRule, 
+        localParams?: LocalParams
+    ): Promise<ValidatedColumnInfo[]> {
 
         try {
             const p = this.getValidatedRules(tableRules, localParams);
@@ -795,21 +812,6 @@ export class ViewHandler {
                 
                 let label = c.comment || capitalizeFirstLetter(c.name, " ");
 
-                /**
-                 * Get labels from TableConfig if specified
-                 */
-                const tblConfig = this.dboBuilder.prostgles?.opts?.tableConfig?.[this.name];
-                if(tblConfig && "columns" in tblConfig){
-                    const lbl = tblConfig?.columns[c.name]?.label;
-                    if(["string", "object"].includes(typeof lbl)){
-                        if(typeof lbl === "string") {
-                            label = lbl
-                        } else if(lang) {
-                            label = (lbl?.[lang as "en"]) || lbl?.en || label;
-                        }
-                    }
-                }
-
                 const select = c.privileges.some(p => p.privilege_type === "SELECT"),
                     insert = c.privileges.some(p => p.privilege_type === "INSERT"),
                     update = c.privileges.some(p => p.privilege_type === "UPDATE"),
@@ -825,7 +827,7 @@ export class ViewHandler {
                     filter: Boolean(p.select && p.select.filterFields && p.select.filterFields.includes(c.name)),
                     update: update && Boolean(p.update && p.update.fields && p.update.fields.includes(c.name)),
                     delete: _delete && Boolean(p.delete && p.delete.filterFields && p.delete.filterFields.includes(c.name)),
-                    ...(this.dboBuilder?.prostgles?.tableConfigurator?.getColInfo({ table: this.name, col: c.name}) || {})
+                    ...(this.dboBuilder?.prostgles?.tableConfigurator?.getColInfo({ table: this.name, col: c.name, lang }) || {})
                 }
 
                 if(dynamicUpdateFields){
@@ -2677,7 +2679,7 @@ export class TableHandler extends ViewHandler {
         } 
     };
 
-    prepareReturning = async (returning: Select<AnyObject>, allowedFields: string[]): Promise<SelectItem[]> => {
+    prepareReturning = async (returning: Select | undefined, allowedFields: string[]): Promise<SelectItem[]> => {
         let result: SelectItem[] = [];
         if(returning){
             let sBuilder = new SelectItemBuilder({
@@ -2899,6 +2901,7 @@ export class TableHandler extends ViewHandler {
 
 import { JOIN_TYPES } from "./Prostgles";
 import { BasicSession } from "./AuthHandler";
+import { getDBSchema } from "./DBSchemaBuilder";
 
 export class DboBuilder {
     tablesOrViews?: TableSchema[];   //TableSchema           TableOrViewInfo
@@ -2910,8 +2913,8 @@ export class DboBuilder {
     db: DB;
     schema: string = "public";
 
-    // dbo: DbHandler | DbHandlerTX;
-    dbo: DbHandler;
+    // dbo: DBHandlerServer | DBHandlerServerTX;
+    dbo: DBHandlerServer;
     _pubSubManager?: PubSubManager;
 
     getPubSubManager = async () : Promise<PubSubManager> => {
@@ -2932,7 +2935,7 @@ export class DboBuilder {
                 this._pubSubManager = await PubSubManager.create({
                     dboBuilder: this,
                     db: this.db, 
-                    dbo: this.dbo as unknown as DbHandler,
+                    dbo: this.dbo as unknown as DBHandlerServer,
                     onSchemaChange
                 });
             } else {
@@ -2962,7 +2965,7 @@ export class DboBuilder {
         if(!this.prostgles.db) throw "db missing"
         this.db = this.prostgles.db;
         this.schema = this.prostgles.opts.schema || "public";
-        this.dbo = { } as unknown as DbHandler;
+        this.dbo = { } as unknown as DBHandlerServer;
         // this.joins = this.prostgles.joins;
         
     }
@@ -3100,7 +3103,7 @@ export class DboBuilder {
         
     }
 
-    async build(): Promise<DbHandler>{
+    async build(): Promise<DBHandlerServer>{
 
         // await this.pubSubManager.init()
 
@@ -3108,37 +3111,30 @@ export class DboBuilder {
         // console.log(this.tablesOrViews.map(t => `${t.name} (${t.columns.map(c => c.name).join(", ")})`))
 
         this.constraints = await getConstraints(this.db);
+        await this.parseJoins();
 
-        const common_types = 
-`
+//         const common_types = 
+// `
 
-import { ViewHandler, TableHandler, JoinMaker } from "prostgles-types";
+// import { ViewHandler, TableHandler, JoinMaker } from "prostgles-types";
 
-export type TxCB = {
-    (t: DBObj): (any | void | Promise<(any | void)>)
-};
+// export type TxCB = {
+//     (t: DBObj): (any | void | Promise<(any | void)>)
+// };
 
-`
-        this.dboDefinition = `export type DBObj = {\n`;
+// `
+        // this.dboDefinition = `export type DBObj = {\n`;
 
-        await this.parseJoins();
 
-        let joinTableNames: string[] = [];
+        // let joinTableNames: string[] = [];
 
-        let allDataDefs = "";
-        let i18nDef = "type DeepPartial<T> = { [P in keyof T]?: DeepPartial<T[P]>; }; \n"
-        i18nDef += "export type I18N_DBO_CONFIG<LANG_IDS = { en: 1, fr: 1 }> = { \n";
-        i18nDef += "  fallbackLang: keyof LANG_IDS; \n";
-        i18nDef += "  column_labels?: DeepPartial<{ \n";
+        // let allDataDefs = "";
             
             
 
         this.tablesOrViews.map(tov => {
             const columnsForTypes = tov.columns.slice(0).sort((a, b) => a.name.localeCompare(b.name));
             
-            i18nDef += `    ${JSON.stringify(tov.name)}: { \n`;
-            i18nDef += `      [key in ${columnsForTypes.map(c => JSON.stringify(c.name)).join(" | ")}]: { [lang_id in keyof LANG_IDS]: string }; \n`;
-            i18nDef += `    }; \n`;
 
             const filterKeywords = Object.values(this.prostgles.keywords);
             const $filterCol = columnsForTypes.find(c => filterKeywords.includes(c.name));
@@ -3149,24 +3145,24 @@ export type TxCB = {
             }
 
             const TSTableDataName = snakify(tov.name, true);
-            const TSTableHandlerName = JSON.stringify(tov.name)
+            const TSTableHandlerName = escapeTSNames(tov.name)
             if(tov.is_view){
                 this.dbo[tov.name] = new ViewHandler(this.db, tov, this, undefined, undefined, this.joinPaths);
-                this.dboDefinition  += `  ${TSTableHandlerName}: ViewHandler<${TSTableDataName}> \n`;
+                // this.dboDefinition  += `  ${TSTableHandlerName}: ViewHandler<${TSTableDataName}> \n`;
             } else {
                 this.dbo[tov.name] = new TableHandler(this.db, tov, this, undefined, undefined, this.joinPaths);
-                this.dboDefinition  += `  ${TSTableHandlerName}: TableHandler<${TSTableDataName}> \n`;
+                // this.dboDefinition  += `  ${TSTableHandlerName}: TableHandler<${TSTableDataName}> \n`;
             }
-            allDataDefs += `export type ${TSTableDataName} = { \n` + 
-                (this.dbo[tov.name] as ViewHandler).tsColumnDefs.map(str => `  ` + str).join("\n") +
-                `\n}\n`;
+            // allDataDefs += `export type ${TSTableDataName} = { \n` + 
+            //     (this.dbo[tov.name] as ViewHandler).tsColumnDefs.map(str => `  ` + str).join("\n") +
+            //     `\n}\n`;
 
             // this.dboDefinition += ` ${escapeTSNames(tov.name, false)}: ${(this.dbo[tov.name] as TableHandler).tsDboName};\n`;
 
             if(this.joinPaths && this.joinPaths.find(jp => [jp.t1, jp.t2].includes(tov.name))){
 
                 let table = tov.name;
-                joinTableNames.push(table);
+                // joinTableNames.push(table);
 
                 const makeJoin = (
                     isLeft = true, 
@@ -3199,20 +3195,18 @@ export type TxCB = {
                 }
             }
         });
-        i18nDef += "  }> \n";
-        i18nDef += "} \n";
-
-        let joinBuilderDef = "";
-        if(joinTableNames.length){
-            joinBuilderDef += "export type JoinMakerTables = {\n";
-            joinTableNames.map(tname => {
-                joinBuilderDef += ` ${JSON.stringify(tname)}: JoinMaker<${snakify(tname, true)}>;\n`
-            })
-            joinBuilderDef += "};\n";
-            ["leftJoin", "innerJoin", "leftJoinOne", "innerJoinOne"].map(joinType => {
-                this.dboDefinition += `  ${joinType}: JoinMakerTables;\n`;
-            });
-        }
+
+        // let joinBuilderDef = "";
+        // if(joinTableNames.length){
+        //     joinBuilderDef += "export type JoinMakerTables = {\n";
+        //     joinTableNames.map(tname => {
+        //         joinBuilderDef += ` ${escapeTSNames(tname)}: JoinMaker<${snakify(tname, true)}>;\n`
+        //     })
+        //     joinBuilderDef += "};\n";
+        //     ["leftJoin", "innerJoin", "leftJoinOne", "innerJoinOne"].map(joinType => {
+        //         this.dboDefinition += `  ${joinType}: JoinMakerTables;\n`;
+        //     });
+        // }
 
 
         if(this.prostgles.opts.transactions){
@@ -3330,14 +3324,14 @@ export type TxCB = {
         this.dboDefinition += "};\n";
         
         this.tsTypesDefinition = [
-            common_types, 
+            // common_types, 
             `/* SCHEMA DEFINITON. Table names have been altered to work with Typescript */`,
-            allDataDefs, 
-            joinBuilderDef,
+            // allDataDefs, 
+            // joinBuilderDef,
             
             `/* DBO Definition. Isomorphic */`,
             this.dboDefinition,
-            i18nDef,
+            getDBSchema(this)
         ].join("\n");
 
         return this.dbo;
@@ -3372,7 +3366,7 @@ export type TxCB = {
 
 
 
-// export async function makeDBO(db: DB): Promise<DbHandler> {
+// export async function makeDBO(db: DB): Promise<DBHandlerServer> {
 //     return await DBO.build(db, "public");
 // }
 
@@ -3576,6 +3570,7 @@ async function getTablesForSchemaPostgresSQL(db: DB, schema: string = "public"):
             if(col.has_default){
                 col.column_default = (col.udt_name !== "uuid" && !col.is_pkey && !col.column_default.startsWith("nextval("))? col.column_default : null;
             }
+            
             return col;
 
         })//.slice(0).sort((a, b) => a.name.localeCompare(b.name))

package/lib/FileManager.ts

@@ -6,7 +6,7 @@ import * as fs from 'fs';
 import * as FileType from "file-type";
 import * as sharp from "sharp";
 
-import { DB, DbHandler, Prostgles } from './Prostgles';
+import { DB, DBHandlerServer, Prostgles } from './Prostgles';
 import { asName, getKeys } from 'prostgles-types';
 import { TableHandler } from './DboBuilder';
 
@@ -71,7 +71,7 @@ export default class FileManager {
   imageOptions?: ImageOptions;
 
   prostgles?: Prostgles;
-  get dbo(): DbHandler { 
+  get dbo(): DBHandlerServer { 
     if(!this.prostgles?.dbo) throw "this.prostgles.dbo missing"
     return this.prostgles.dbo 
   };

package/lib/Filtering.ts

@@ -1,7 +1,7 @@
 
 
 import { SelectItem } from "./QueryBuilder";
-import { isEmpty, getKeys, FullFilter, EXISTS_KEYS, FilterDataType, GeomFilterKeys, GeomFilter_Funcs, TextFilter_FullTextSearchFilterKeys, ColumnInfo } from "prostgles-types";
+import { isEmpty, getKeys, FullFilter, EXISTS_KEYS, FilterDataType, GeomFilterKeys, GeomFilter_Funcs, TextFilter_FullTextSearchFilterKeys } from "prostgles-types";
 import { isPlainObject } from "./DboBuilder";
 
 /**
@@ -200,7 +200,7 @@ export const parseFilterItem = (args: ParseFilterItemArgs): string => {
     }
 
     /** st_makeenvelope */
-    if(GeomFilterKeys.includes(fOpType) && sOpType && GeomFilter_Funcs.includes(sOpType)){
+    if(GeomFilterKeys.includes(fOpType as any) && sOpType && GeomFilter_Funcs.includes(sOpType)){
       /** If leftQ is geography then this err can happen: 'Antipodal (180 degrees long) edge detected!' */
       if(sOpType.toLowerCase() === "st_makeenvelope") leftQ += "::geometry"
       return leftQ + ` ${fOpType} ` + `${sOpType}${parseRightVal(sVal, "csv")}`;
@@ -277,7 +277,7 @@ export const parseFilterItem = (args: ParseFilterItemArgs): string => {
         return leftQ + operand + parseRightVal(fVal, "array");
           
       /* FTSQuery */
-      } else if(["@@"].includes(fOpType) && TextFilter_FullTextSearchFilterKeys.includes(sOpType!)) {
+      } else if(["@@"].includes(fOpType) && TextFilter_FullTextSearchFilterKeys.includes(sOpType! as any)) {
         let lq = `to_tsvector(${leftQ}::text)`;
         if(selItem && selItem.columnPGDataType === "tsvector") lq = leftQ!;