prostgles-server 4.2.158 → 4.2.160

package/lib/DboBuilder/ViewHandler/count.ts

@@ -1,38 +0,0 @@
-import { SelectParams } from "prostgles-types";
-import { TableRule } from "../../PublishParser/publishTypesAndUtils";
-import { Filter, LocalParams } from "../DboBuilder";
-import { getErrorAsObject, getSerializedClientErrorFromPGError, withUserRLS } from "../dboBuilderUtils";
-import { ViewHandler } from "./ViewHandler";
-
-export async function count(this: ViewHandler, _filter?: Filter, selectParams?: SelectParams, _param3_unused?: undefined, table_rules?: TableRule, localParams?: LocalParams): Promise<number> {
-  const filter = _filter || {};
-  const { limit: _limit, ...selectParamsWithoutLimit } = selectParams ?? {};
-  const start = Date.now();
-  try {
-    const result = await this.find(filter, { select: selectParamsWithoutLimit?.select ?? "", limit: 0 }, undefined, table_rules, localParams)
-      .then(async _allowed => {
-        const findQuery = await this.find(
-          filter, 
-          selectParamsWithoutLimit,
-          undefined,
-          table_rules,
-          { ...localParams, returnQuery: "noRLS", bypassLimit: true }
-        ) as unknown as string;
-        const query = [
-          withUserRLS(localParams, ""),
-          "SELECT COUNT(*)",
-          "FROM (",
-          findQuery,
-          ") t"
-        ].join("\n");
-        const handler = this.tx?.t ?? this.db;
-        return handler.one(query).then(({ count }) => +count);
-      });
-
-    await this._log({ command: "count", localParams, data: { filter }, duration: Date.now() - start });
-    return result;
-  } catch (e) {
-    await this._log({ command: "count", localParams, data: { filter }, duration: Date.now() - start, error: getErrorAsObject(e) });
-    throw getSerializedClientErrorFromPGError(e, { type: "tableMethod", localParams, view: this });
-  }
-}

package/lib/DboBuilder/ViewHandler/find.ts

@@ -1,153 +0,0 @@
-
-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

@@ -1,73 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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(", ");
-    }
-  }
-}