prostgles-server 4.2.159 → 4.2.161

package/lib/DboBuilder/ViewHandler/find.ts

@@ -0,0 +1,153 @@
+
+import { SelectParams, isObject } from "prostgles-types";
+import { TableRule } from "../../PublishParser/PublishParser";
+import { Filter, LocalParams, getClientErrorFromPGError, getErrorAsObject, getSerializedClientErrorFromPGError, withUserRLS } from "../DboBuilder";
+import { getNewQuery } from "../QueryBuilder/getNewQuery";
+import { getSelectQuery } from "../QueryBuilder/getSelectQuery";
+import { NewQuery } from "../QueryBuilder/QueryBuilder";
+import { canRunSQL } from "../runSQL";
+import { TableHandler } from "../TableHandler/TableHandler";
+import { ViewHandler } from "./ViewHandler";
+
+export const find = async function(this: ViewHandler, filter?: Filter, selectParams?: SelectParams, _?: undefined, tableRules?: TableRule, localParams?: LocalParams): Promise<any[]> {
+  const start = Date.now();
+  const command = selectParams?.limit === 1 && selectParams?.returnType === "row"? "findOne" : "find";
+  try {
+    filter = filter || {};
+    const allowedReturnTypes = Object.keys({ 
+      row: 1, statement: 1, value: 1, values: 1, 
+      "statement-no-rls": 1, "statement-where": 1,
+    } satisfies Record<Required<SelectParams>["returnType"], 1>);
+
+    const { returnType } = selectParams || {};
+    if (returnType && !allowedReturnTypes.includes(returnType)) {
+      throw `returnType (${returnType}) can only be ${allowedReturnTypes.join(" OR ")}`
+    }
+
+    const { testRule = false } = localParams || {};
+
+    if (testRule) return [];
+    if (selectParams) {
+      const validParamNames = Object.keys({ 
+        "select": 1, "orderBy": 1, "offset": 1, "limit": 1, 
+        "returnType": 1, "groupBy": 1, "having": 1
+      } satisfies Record<keyof SelectParams, 1>);
+      
+      const invalidParams = Object.keys(selectParams).filter(k => !validParamNames.includes(k as any));
+      if (invalidParams && invalidParams.length) throw "Invalid params: " + invalidParams.join(", ") + " \n Expecting: " + validParamNames.join(", ");
+    }
+
+    /* Validate publish */
+    if (tableRules) { 
+
+      if (!tableRules.select) throw "select rules missing for " + this.name;
+      const fields = tableRules.select.fields; 
+      const maxLimit = tableRules.select.maxLimit;
+
+      if (<any>tableRules.select !== "*" && typeof tableRules.select !== "boolean" && !isObject(tableRules.select)) {
+        throw `\nInvalid publish.${this.name}.select\nExpecting any of: "*" | { fields: "*" } | true | false`;
+      }
+      if (!fields) {
+        throw ` invalid ${this.name}.select rule -> fields (required) setting missing.\nExpecting any of: "*" | { col_name: false } | { col1: true, col2: true }`;
+      }
+      if (maxLimit && !Number.isInteger(maxLimit)) {
+        throw ` invalid publish.${this.name}.select.maxLimit -> expecting integer but got ` + maxLimit;
+      }
+    }
+
+    const _selectParams = selectParams ?? {}
+    const selectParamsLimitCheck = localParams?.bypassLimit && !Number.isFinite(_selectParams.limit)? { ..._selectParams, limit: null } : { limit: 1000, ..._selectParams }
+    const newQuery = await getNewQuery(
+      this, 
+      filter, 
+      selectParamsLimitCheck, 
+      _, 
+      tableRules, 
+      localParams, 
+    );
+
+    const queryWithoutRLS = getSelectQuery(
+      this, 
+      newQuery, 
+      undefined, 
+      !!selectParamsLimitCheck?.groupBy
+    );
+
+    const queryWithRLS = withUserRLS(localParams, queryWithoutRLS);
+    if (testRule) {
+      try {
+        await this.db.any(withUserRLS(localParams, "EXPLAIN " + queryWithRLS));
+        return [];
+      } catch (e) {
+        console.error(e);
+        throw `Internal error: publish config is not valid for publish.${this.name}.select `
+      }
+    }
+
+    /** Used for subscribe  */
+    if(localParams?.returnNewQuery) return (newQuery as unknown as any);
+    if (localParams?.returnQuery) {
+      if(localParams?.returnQuery === "where-condition"){
+        return newQuery.whereOpts.condition as any;
+      }
+      return ((localParams?.returnQuery === "noRLS"? queryWithoutRLS : queryWithRLS) as unknown as any[]);
+    }
+
+    const result = await runQueryReturnType({ 
+      queryWithoutRLS, 
+      queryWithRLS, 
+      returnType, 
+      handler: this, 
+      localParams,
+      newQuery,
+    });
+
+    await this._log({ command, localParams, data: { filter, selectParams }, duration: Date.now() - start });
+    return result;
+  } catch (e) {
+    this._log({ command, localParams, data: { filter, selectParams }, duration: Date.now() - start, error: getErrorAsObject(e) });
+    throw getSerializedClientErrorFromPGError(e, { type: "tableMethod", localParams, view: this });
+  }
+}
+
+type RunQueryReturnTypeArgs = {
+  queryWithRLS: string;
+  queryWithoutRLS: string;
+  returnType: SelectParams["returnType"]; 
+  handler: ViewHandler | TableHandler; 
+  localParams: LocalParams | undefined;
+  newQuery: NewQuery | undefined;
+};
+
+export const runQueryReturnType = async ({ newQuery, handler, localParams, queryWithRLS, queryWithoutRLS, returnType,}: RunQueryReturnTypeArgs) => {
+
+  const query = queryWithRLS;
+  const sqlTypes = ["statement", "statement-no-rls", "statement-where"];
+  if(!returnType || returnType === "values"){
+
+    return handler.dbHandler.any(query).then(data => {
+      if (returnType === "values") {
+        return data.map(d => Object.values(d)[0]);
+      }
+      return data;
+    }).catch(err => getClientErrorFromPGError(err, { type: "tableMethod", localParams, view: handler, }));
+
+  } else if (sqlTypes.some(v => v === returnType)) {
+    if (!(await canRunSQL(handler.dboBuilder.prostgles, localParams))) {
+      throw `Not allowed:  {returnType: ${JSON.stringify(returnType)}} requires execute sql privileges `
+    }
+    if(returnType === "statement-no-rls"){
+      return queryWithoutRLS as any;
+    }
+    if(returnType === "statement-where"){
+      if(!newQuery) throw `returnType ${returnType} not possible for this command type`;
+      return newQuery.whereOpts.condition as any;
+    }
+    return query as unknown as any[];
+
+  } else if (["row", "value"].includes(returnType)) {
+    return handler.dbHandler.oneOrNone(query).then(data => {
+      return (data && returnType === "value") ? Object.values(data)[0] : data;
+    }).catch(err => getClientErrorFromPGError(err,  { type: "tableMethod", localParams, view: handler, }));
+  }
+}

package/lib/DboBuilder/ViewHandler/getExistsCondition.ts

@@ -0,0 +1,73 @@
+import { AnyObject, EXISTS_KEY, EXISTS_KEYS, FieldFilter, asName } from "prostgles-types";
+import { LocalParams, ExistsFilterConfig } from "../DboBuilder";
+import { ViewHandler } from "./ViewHandler";
+import { TableRule } from "../../PublishParser/PublishParser";
+import { TableHandler } from "../TableHandler/TableHandler";
+import { getTableJoinQuery } from "./getTableJoinQuery";
+
+
+export async function getExistsCondition(this: ViewHandler, eConfig: ExistsFilterConfig, localParams: LocalParams | undefined): Promise<string> {
+
+  const thisTable = this.name;
+  const isNotExists = ["$notExists", "$notExistsJoined"].includes(eConfig.existType);
+
+  const { targetTableFilter } = eConfig;
+
+  /* Nested $exists is not allowed */
+  if (targetTableFilter && Object.keys(targetTableFilter).find(fk => EXISTS_KEYS.includes(fk as EXISTS_KEY))) {
+    throw { stack: ["prepareExistCondition()"], message: "Nested exists dissallowed" };
+  } 
+
+  let t2Rules: TableRule | undefined = undefined,
+    forcedFilter: AnyObject | undefined,
+    filterFields: FieldFilter | undefined,
+    tableAlias;
+
+  /* Check if allowed to view data - forcedFilters will bypass this check through isForcedFilterBypass */
+  if (localParams?.isRemoteRequest && !localParams?.socket && !localParams?.httpReq) {
+    throw "Unexpected: localParams isRemoteRequest and missing socket/httpReq: ";
+  }
+  const targetTable = eConfig.isJoined?  eConfig.parsedPath.at(-1)!.table : eConfig.targetTable;
+  if ((localParams?.socket || localParams?.httpReq) && this.dboBuilder.publishParser) {
+
+    t2Rules = await this.dboBuilder.publishParser.getValidatedRequestRuleWusr({ 
+      tableName: targetTable, 
+      command: "find", 
+      localParams 
+    }) as TableRule;
+
+    if (!t2Rules || !t2Rules.select) throw "Dissallowed";
+    ({ forcedFilter, filterFields } = t2Rules.select);
+  }
+
+  const tableHandler = this.dboBuilder.dbo[targetTable] as TableHandler
+  const finalWhere = (await tableHandler.prepareWhere({
+    select: undefined,
+    filter: targetTableFilter,
+    forcedFilter,
+    filterFields,
+    addWhere: false,
+    tableAlias,
+    localParams,
+    tableRule: t2Rules
+  })).where
+
+  let innerQuery = [
+    `SELECT 1`,
+    `FROM ${asName(targetTable)}`,
+    `${finalWhere ? `WHERE ${finalWhere}` : ""}`
+  ].join("\n");
+
+  if(eConfig.isJoined){
+    const { query } = getTableJoinQuery({
+      path: eConfig.parsedPath,
+      rootTableAlias: thisTable,
+      type: "EXISTS",
+      finalWhere,
+    });
+    innerQuery = query;
+  }
+
+  return `${isNotExists ? " NOT " : " "} EXISTS ( \n${innerQuery} \n) `;
+
+}

package/lib/DboBuilder/ViewHandler/getExistsFilters.ts

@@ -0,0 +1,74 @@
+import { EXISTS_KEY, EXISTS_KEYS, getKeys } from "prostgles-types";
+import { ExistsFilterConfig } from "../DboBuilder";
+import { ViewHandler } from "./ViewHandler";
+import { parseJoinPath } from "./parseJoinPath";
+
+export const getExistsFilters = (filter: any, viewHandler: ViewHandler): ExistsFilterConfig[] => {
+
+  /* Exists join filter */
+  const ERR = "Invalid exists filter. \nExpecting something like: \n | { $exists: { tableName.tableName2: Filter } } \n  | { $exists: { \"**.tableName3\": Filter } }\n | { path: string[]; filter: AnyObject }"
+  const existsConfigs: ExistsFilterConfig[] = getKeys(filter)
+    .filter((k ): k is typeof EXISTS_KEYS[number] => EXISTS_KEYS.includes(k as EXISTS_KEY) && !!Object.keys(filter[k] ?? {}).length)
+    .map(key => {
+
+      const isJoined = key.toLowerCase().includes("join");
+      const filterValue = filter[key];
+
+
+      /**
+       * type ExistsJoined = 
+       *   | { "table1.table2": { column: filterValue }  }
+       *   | { path: string[]; filter: AnyObject }
+       */
+      const dataKeys = Object.keys(filterValue);
+      const isDetailed = dataKeys.length === 2 && dataKeys.every(key => ["path", "filter"].includes(key));
+
+      const firstKey = dataKeys[0]!;
+
+      /**
+       * Non joined exists are never detailed
+       */
+      if(!isJoined){
+        const format = `Expecting single table in exists filter. Example: { $exists: { tableName: Filter } }`
+        if(isDetailed){
+          throw `Exists filters cannot be detailed. ${format}`
+        }
+        const targetTable = firstKey;
+        if (!viewHandler.dboBuilder.dbo[targetTable]) {
+          throw `Table ${JSON.stringify(targetTable)} not found. ${format}`
+        }
+        const res: ExistsFilterConfig = {
+          isJoined: false,
+          existType: key as EXISTS_KEY,
+          targetTableFilter: filterValue[firstKey],
+          targetTable: firstKey,
+        }
+        return res;
+      }
+
+      /**
+       * Prevent some errors with table names that contain "."
+       */
+      const firstKeyIsATable = !!viewHandler.dboBuilder.dbo[firstKey];
+      const [path, targetTableFilter] = isDetailed? [filterValue.path, filterValue.filter] : [(firstKeyIsATable? [firstKey] : firstKey.split(".")), filterValue[firstKey]];
+
+      if (!path.length) {
+        throw ERR + "\nBut got: " + JSON.stringify(filterValue);
+      }
+      
+      return {
+        isJoined: true,
+        existType: key as EXISTS_KEY,
+        path,
+        parsedPath: parseJoinPath({
+          rawPath: path,
+          rootTable: viewHandler.name,
+          viewHandler,
+          allowMultiOrJoin: true,
+        }),
+        targetTableFilter,
+      }
+    });
+
+  return existsConfigs;
+}

package/lib/DboBuilder/ViewHandler/getInfo.ts

@@ -0,0 +1,32 @@
+import {
+  TableInfo as TInfo
+} from "prostgles-types/dist";
+import { TableRule } from "../../PublishParser/PublishParser";
+import { LocalParams } from "../DboBuilder";
+import { ViewHandler } from "./ViewHandler";
+
+export async function getInfo(this: ViewHandler, lang?: string, param2?: any, param3?: any, tableRules?: TableRule, localParams?: LocalParams): Promise<TInfo> {
+  const p = this.getValidatedRules(tableRules, localParams);
+  if (!p.getInfo) {
+    await this._log({ command: "getInfo", localParams, data: { lang }, duration: 0, error: "Not allowed" });
+    throw "Not allowed";
+  }
+
+  const fileTableName = this.dboBuilder.prostgles?.opts?.fileTable?.tableName;
+
+  await this._log({ command: "getInfo", localParams, data: { lang }, duration: 0 });
+  return {
+    oid: this.tableOrViewInfo.oid,
+    comment: this.tableOrViewInfo.comment,
+    info: this.dboBuilder.prostgles?.tableConfigurator?.getTableInfo({ tableName: this.name, lang }),
+    isFileTable: !this.is_media? undefined : {
+      allowedNestedInserts: tableRules?.insert?.allowedNestedInserts
+    },
+    isView: this.is_view,
+    hasFiles: Boolean(!this.is_media && fileTableName && this.columns.some(c => c.references?.some(r => r.ftable === fileTableName))),
+    fileTableName,
+    dynamicRules: {
+      update: Boolean(tableRules?.update?.dynamicFields?.length)
+    }
+  }
+}

package/lib/DboBuilder/ViewHandler/getTableJoinQuery.ts

@@ -0,0 +1,84 @@
+import { asName } from "prostgles-types";
+import { ParsedJoinPath } from "./parseJoinPath";
+
+type getTableJoinsArgs = {
+  rootTableAlias: string;
+  type: "INNER" | "LEFT" | "EXISTS";
+  finalWhere?: string;
+  path: ParsedJoinPath[];
+}
+export const getTableJoinQuery = ({ path, type, rootTableAlias, finalWhere }: getTableJoinsArgs): { targetAlias: string; query: string } => {
+
+  const [firstPath] = path;
+  if(!firstPath){
+    throw `Cannot create join query for empty path`;
+  }
+  const aliasSufix = "jd";
+  const getTableAlias = (table: string, pathIndex: number) => asName(`${aliasSufix}_${pathIndex}_${table}`);
+
+  const query = path.map(({ table, on }, i) => {
+    if(!on) throw "on missing";
+    const tableName = table;
+    const tableAlias = getTableAlias(table, i);
+    const prevTableAlias = i === 0? rootTableAlias : getTableAlias(path[i-1]!.table, i-1);
+
+    const onCondition = getJoinOnCondition({ on, leftAlias: prevTableAlias, rightAlias: tableAlias });
+
+    const isExists = type === "EXISTS"
+    const joinType = isExists? "INNER" : type;
+    const keyword = `${joinType} JOIN`;
+    const isLast = i === path.length - 1;
+    const isFirst = !i;
+
+    /**
+     * rootTable joins to first path
+     * first path joins to target table through inner joins
+     */
+    const whereJoinCondition = (isLast && isExists) ? 
+      `WHERE (${getJoinOnCondition({
+      on: firstPath.on, 
+      leftAlias: rootTableAlias, 
+      rightAlias: getTableAlias(firstPath.table, 0)
+    })})` : "";
+
+    const tableSelect = (isExists && isLast)? [
+      `(`, 
+      ` SELECT *`,
+      ` FROM ${tableName}`,
+      (finalWhere? `  WHERE ${finalWhere}` : ""),
+      `)`
+    ].filter(v=>v).join("\n") : tableName;
+    if(isExists && isFirst){
+      return [
+        `SELECT 1`,
+        `FROM ${tableSelect} ${tableAlias}`,
+        whereJoinCondition
+      ].filter(v=>v).join("\n");
+    }
+
+    return [
+      `${keyword} ${tableSelect} ${tableAlias}`,
+      ` ON ${onCondition}`,
+      whereJoinCondition
+    ].filter(v=>v).join("\n");
+
+  }).join("\n");
+
+  return {
+    query,
+    targetAlias: getTableAlias(path.at(-1)!.table, path.length - 1)
+  }
+}
+
+type GetJoinOnConditionArgs = {
+  on: Record<string, string>[];
+  leftAlias: string; 
+  rightAlias: string;
+  getLeftColName?: (col: string) => string;
+  getRightColName?: (col: string) => string;
+}
+export const getJoinOnCondition = ({ on, leftAlias, rightAlias, getLeftColName = asName, getRightColName = asName }: GetJoinOnConditionArgs ) => {
+  return on.map(constraint => Object.entries(constraint).map(([leftCol, rightCol]) => {
+    return `${leftAlias}.${getLeftColName(leftCol)} = ${rightAlias}.${getRightColName(rightCol)}`;
+  }).join(" AND ")).join(" OR ")
+}

package/lib/DboBuilder/ViewHandler/parseComplexFilter.ts

@@ -0,0 +1,96 @@
+import { AnyObject, isObject } from "prostgles-types";
+import { FILTER_OPERANDS, FILTER_OPERAND_TO_SQL_OPERAND, parseFilterRightValue } from "../../Filtering";
+import { FUNCTIONS, parseFunction } from "../QueryBuilder/Functions";
+import { asNameAlias, parseFunctionObject } from "../QueryBuilder/QueryBuilder";
+import { TableSchemaColumn } from "../DboBuilderTypes";
+import { asValue } from "../../PubSubManager/PubSubManager";
+
+const allowedComparators = FILTER_OPERANDS; //[">", "<", "=", "<=", ">=", "<>", "!="]
+type Args = {
+  filter: AnyObject;
+  complexFilterKey: string;
+  tableAlias: string | undefined;
+  allowed_colnames: string[];
+  columns: TableSchemaColumn[];
+}
+
+/* Parse complex filters
+  { 
+    $filter: [
+      { $func: [...] }, 
+      "=", 
+      value | { $func: [..] }
+    ] 
+  } 
+*/
+export const parseComplexFilter = ({
+  filter,
+  complexFilterKey,
+  tableAlias,
+  allowed_colnames,
+  columns,
+}: Args) => {
+
+  /**
+   * { $funcName: [arg1, arg2] }
+   * { $column: "column_name" }
+   */
+  const getFuncQuery = (funcData: AnyObject): string => {
+    if(isObject(funcData) && "$column" in funcData){
+      const column = funcData["$column"]
+      if(typeof column !== "string"){
+        throw `expecting: \n  { $column: "column_name" } received:\n ${JSON.stringify(funcData)}`;
+      }
+      if(!allowed_colnames.includes(column)){
+        throw `Dissallowed or Invalid column ${column}. Allowed columns: ${allowed_colnames}`;
+      }
+      return asNameAlias(column, tableAlias)
+    }
+    const { funcName, args } = parseFunctionObject(funcData);
+    const funcDef = parseFunction({ func: funcName, args, functions: FUNCTIONS, allowedFields: allowed_colnames });
+    return funcDef.getQuery({ args, tableAlias, allColumns: columns, allowedFields: allowed_colnames });
+  }
+
+  const complexFilter = filter[complexFilterKey];
+  if (!Array.isArray(complexFilter)) {
+    throw `Invalid $filter. Must contain an array of at least element but got: ${JSON.stringify(complexFilter)} `
+  } 
+  const [leftFilter, comparator, rightFilterOrValue] = complexFilter;
+
+  const leftVal = getFuncQuery(leftFilter);
+  let result = leftVal;
+  if (comparator) {
+    if (typeof comparator !== "string" || !allowedComparators.includes(comparator as any)) {
+      throw `Invalid $filter. comparator ${JSON.stringify(comparator)} is not valid. Expecting one of: ${allowedComparators}`;
+    }
+    if (!rightFilterOrValue) {
+      throw "Invalid $filter. Expecting a value or function after the comparator";
+    }
+    const maybeValidComparator = comparator as keyof typeof FILTER_OPERAND_TO_SQL_OPERAND;
+    const sqlOperand = FILTER_OPERAND_TO_SQL_OPERAND[maybeValidComparator];
+    if(!sqlOperand){
+      throw `Invalid $filter. comparator ${comparator} is not valid. Expecting one of: ${allowedComparators}`;
+    }
+
+    let rightVal = isObject(rightFilterOrValue) ? 
+      getFuncQuery(rightFilterOrValue) : 
+      parseFilterRightValue(rightFilterOrValue, {
+        selectItem: undefined, 
+        expect: ["$in", "$nin"].includes(comparator)? "csv" : undefined 
+      });
+    if(maybeValidComparator === "$between" || maybeValidComparator === "$notBetween"){
+      
+      if(!Array.isArray(rightVal) || rightVal.length !== 2){
+        throw "Between filter expects an array of two values";
+      }
+      rightVal = asValue(rightVal[0]) + " AND " + asValue(rightVal[1]);
+    }
+    if (leftVal === rightVal){ 
+      throw "Invalid $filter. Cannot compare two identical function signatures: " + JSON.stringify(leftFilter);
+    }
+      
+    result += ` ${sqlOperand} ${rightVal}`;
+  }
+
+  return result;
+}

package/lib/DboBuilder/ViewHandler/parseFieldFilter.ts

@@ -0,0 +1,105 @@
+import { FieldFilter, getKeys } from "prostgles-types";
+import { isPlainObject } from "../DboBuilder";
+
+/** 
+* Filter string array
+* @param {FieldFilter} fieldParams - { col1: 0, col2: 0 } | { col1: true, col2: true } | "*" | ["key1", "key2"] | []
+* @param {boolean} allow_empty - allow empty select. defaults to true
+*/
+export const parseFieldFilter = <AllowedKeys extends string[]>(
+  fieldParams: FieldFilter<Record<AllowedKeys[number], any>> = "*", 
+  allow_empty = true, 
+  all_cols: AllowedKeys
+): AllowedKeys | [""] => {
+  
+  if (!all_cols) throw "all_cols missing"
+  const all_fields = all_cols;// || this.column_names.slice(0);
+  let colNames: AllowedKeys = [] as any;
+  const initialParams = JSON.stringify(fieldParams);
+
+  if (fieldParams) {
+
+    /* 
+        "field1, field2, field4" | "*"
+    */
+    if (typeof fieldParams === "string") {
+      fieldParams = fieldParams.split(",").map(k => k.trim());
+    }
+
+    /* string[] */
+    if (Array.isArray(fieldParams) && !fieldParams.find(f => typeof f !== "string")) {
+      /* 
+          ["*"] 
+      */
+      if (fieldParams[0] === "*") {
+        return all_fields.slice(0) as typeof all_fields;
+
+        /* 
+            [""] 
+        */
+      } else if (fieldParams[0] === "") {
+        if (allow_empty) {
+          return [""];
+        } else {
+          throw "Empty value not allowed";
+        }
+        /* 
+            ["field1", "field2", "field3"] 
+        */
+      } else {
+        colNames = fieldParams.slice(0) as AllowedKeys;
+      }
+
+      /*
+          { field1: true, field2: true } = only field1 and field2
+          { field1: false, field2: false } = all fields except field1 and field2
+      */
+    } else if (isPlainObject(fieldParams)) {
+
+      if (!getKeys(fieldParams).length) {
+        return [] as unknown as typeof all_fields; //all_fields.slice(0) as typeof all_fields;
+      }
+
+      const keys = getKeys(fieldParams as {
+        [key: string]: boolean | 0 | 1;
+      }) as AllowedKeys;
+      if (keys[0] === "") {
+        if (allow_empty) {
+          return [""];
+        } else {
+          throw "Empty value not allowed";
+        }
+      }
+
+      validate(keys);
+
+      keys.forEach(key => {
+        const allowedVals = [true, false, 0, 1];
+        if (!allowedVals.includes((fieldParams as any)[key])) throw `Invalid field selection value for: { ${key}: ${(fieldParams as any)[key]} }. \n Allowed values: ${allowedVals.join(" OR ")}`
+      })
+
+      const allowed = keys.filter(key => (fieldParams as any)[key]),
+        disallowed = keys.filter(key => !(fieldParams as any)[key]);
+
+
+      if (disallowed && disallowed.length) {
+        return all_fields.filter(col => !disallowed.includes(col)) as typeof all_fields;
+      } else {
+        return [...allowed] as any;
+      }
+
+    } else {
+      throw " Unrecognised field filter.\nExpecting any of:   string | string[] | { [field]: boolean } \n Received ->  " + initialParams;
+    }
+
+    validate(colNames);
+  }
+  return colNames as any;
+
+  function validate(cols: AllowedKeys) {
+    const bad_keys = cols.filter(col => !all_fields.includes(col));
+    if (bad_keys && bad_keys.length) {
+      throw "\nUnrecognised or illegal fields: " + bad_keys.join(", ");
+    }
+  }
+}