prostgles-server 4.2.343 → 4.2.345

package/lib/DboBuilder/QueryBuilder/Functions/parseFunction.ts

@@ -0,0 +1,65 @@
+import { COMPUTED_FIELDS } from "./COMPUTED_FIELDS";
+import type { FunctionSpec } from "./Functions";
+
+export const parseFunction = (funcData: {
+  func: string | FunctionSpec;
+  args: any[];
+  functions: FunctionSpec[];
+  allowedFields: string[];
+}): FunctionSpec => {
+  const { func, args, functions, allowedFields } = funcData;
+
+  /* Function is computed column. No checks needed */
+  if (typeof func !== "string") {
+    const computedCol = COMPUTED_FIELDS.find((c) => c.name === func.name);
+    if (!computedCol)
+      throw `Unexpected function: computed column spec not found for ${JSON.stringify(func.name)}`;
+    return func;
+  }
+
+  const funcName = func;
+  const makeErr = (msg: string): string => {
+    return `Issue with function ${JSON.stringify({ [funcName]: args })}: \n${msg}`;
+  };
+
+  /* Find function */
+  const funcDef = functions.find((f) => f.name === funcName);
+
+  if (!funcDef) {
+    const sf = functions
+      .filter((f) => f.name.toLowerCase().slice(1).startsWith(funcName.toLowerCase()))
+      .sort((a, b) => a.name.length - b.name.length);
+    const hint =
+      sf.length ?
+        `. \n Maybe you meant: \n | ${sf.map((s) => s.name + " " + (s.description || "")).join("    \n | ")}  ?`
+      : "";
+    throw "\n Function " + funcName + " does not exist or is not allowed " + hint;
+  }
+
+  /* Validate fields */
+  const fields = funcDef.getFields(args);
+  if (fields !== "*") {
+    fields.forEach((fieldKey) => {
+      if (typeof fieldKey !== "string" || !allowedFields.includes(fieldKey)) {
+        throw makeErr(
+          `getFields() => field name ${JSON.stringify(fieldKey)} is invalid or disallowed`
+        );
+      }
+    });
+    if ((funcDef.minCols ?? 0) > fields.length) {
+      throw makeErr(`Less columns provided than necessary (minCols=${funcDef.minCols})`);
+    }
+  }
+
+  if (
+    funcDef.numArgs &&
+    funcDef.minCols !== 0 &&
+    fields !== "*" &&
+    Array.isArray(fields) &&
+    !fields.length
+  ) {
+    throw `\n Function "${funcDef.name}" expects at least a field name but has not been provided with one`;
+  }
+
+  return funcDef;
+};

package/lib/DboBuilder/QueryBuilder/QueryBuilder.ts

@@ -3,22 +3,22 @@
  *  Licensed under the MIT License. See LICENSE in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import {
-  asName,
+import type {
   ColumnInfo,
-  getKeys,
-  isEmpty,
-  isObject,
   JoinSelect,
   PG_COLUMN_UDT_DATA_TYPE,
   Select,
   ValidatedColumnInfo,
 } from "prostgles-types";
-import { postgresToTsType, SortItem } from "../DboBuilder";
+import { getKeys, isEmpty, isObject, postgresToTsType } from "prostgles-types";
+import type { SortItem } from "../DboBuilder";
 
-import { ParsedJoinPath } from "../ViewHandler/parseJoinPath";
-import { ViewHandler } from "../ViewHandler/ViewHandler";
-import { COMPUTED_FIELDS, FieldSpec, FunctionSpec, parseFunction } from "./Functions";
+import type { ParsedJoinPath } from "../ViewHandler/parseJoinPath";
+import type { ViewHandler } from "../ViewHandler/ViewHandler";
+import type { FieldSpec, FunctionSpec } from "./Functions/Functions";
+import { COMPUTED_FIELDS } from "./Functions/COMPUTED_FIELDS";
+import { parseFunction } from "./Functions/parseFunction";
+import { asNameAlias } from "../../utils/asNameAlias";
 
 export type SelectItem = {
   getFields: (args: any[]) => string[] | "*";
@@ -73,12 +73,6 @@ export type NewQuery = NewQueryRoot & {
   joins?: NewQueryJoin[];
 };
 
-export const asNameAlias = (field: string, tableAlias?: string) => {
-  const result = asName(field);
-  if (tableAlias) return asName(tableAlias) + "." + result;
-  return result;
-};
-
 export const parseFunctionObject = (funcData: unknown): { funcName: string; args: any[] } => {
   const makeErr = (msg: string) =>
     `Function not specified correctly. Expecting { $funcName: ["columnName" | <value>, ...args] } object but got: ${JSON.stringify(funcData)} \n ${msg}`;

package/lib/DboBuilder/QueryBuilder/getJoinQuery.ts

@@ -1,16 +1,13 @@
 import { isDefined, asName } from "prostgles-types";
-import { ParsedJoinPath, parseJoinPath } from "../ViewHandler/parseJoinPath";
-import {
-  NewQuery,
-  NewQueryJoin,
-  SelectItem,
-  asNameAlias,
-  type SelectItemValidated,
-} from "./QueryBuilder";
+import type { ParsedJoinPath } from "../ViewHandler/parseJoinPath";
+import { parseJoinPath } from "../ViewHandler/parseJoinPath";
+import type { NewQuery, NewQueryJoin } from "./QueryBuilder";
+import { type SelectItemValidated } from "./QueryBuilder";
 import { ROOT_TABLE_ALIAS, ROOT_TABLE_ROW_NUM_ID, indentLines } from "./getSelectQuery";
-import { ViewHandler } from "../ViewHandler/ViewHandler";
+import type { ViewHandler } from "../ViewHandler/ViewHandler";
 import { getJoinOnCondition } from "../ViewHandler/getTableJoinQuery";
 import { prepareOrderByQuery } from "../DboBuilder";
+import { asNameAlias } from "../../utils/asNameAlias";
 
 type Args = {
   q1: NewQuery;

package/lib/DboBuilder/QueryBuilder/getNewQuery.ts

@@ -1,22 +1,22 @@
-import {
+import type {
   DetailedJoinSelect,
   JoinPath,
   JoinSelect,
   RawJoinPath,
   SelectParams,
   SimpleJoinSelect,
-  getKeys,
-  isEmpty,
-  omitKeys,
 } from "prostgles-types";
-import { ParsedTableRule } from "../../PublishParser/PublishParser";
-import { Filter, LocalParams, ValidatedTableRules } from "../DboBuilder";
-import { ViewHandler } from "../ViewHandler/ViewHandler";
+import { getKeys, isEmpty, omitKeys } from "prostgles-types";
+import type { ParsedTableRule } from "../../PublishParser/PublishParser";
+import type { Filter, LocalParams, ValidatedTableRules } from "../DboBuilder";
+import type { ViewHandler } from "../ViewHandler/ViewHandler";
 import { parseJoinPath } from "../ViewHandler/parseJoinPath";
 import { prepareSortItems } from "../ViewHandler/prepareSortItems";
-import { PrepareWhereParams } from "../ViewHandler/prepareWhere";
-import { COMPUTED_FIELDS, FUNCTIONS } from "./Functions";
-import { NewQuery, NewQueryJoin, SelectItemBuilder } from "./QueryBuilder";
+import type { PrepareWhereParams } from "../ViewHandler/prepareWhere";
+import { FUNCTIONS } from "./Functions/Functions";
+import type { NewQuery, NewQueryJoin } from "./QueryBuilder";
+import { SelectItemBuilder } from "./QueryBuilder";
+import { COMPUTED_FIELDS } from "./Functions/COMPUTED_FIELDS";
 
 const JOIN_KEYS = ["$innerJoin", "$leftJoin"] as const;
 const JOIN_PARAM_KEYS = getKeys({

package/lib/DboBuilder/QueryBuilder/getSelectQuery.ts

@@ -1,7 +1,7 @@
 import { prepareOrderByQuery } from "../DboBuilder";
 import { isDefined, asName } from "prostgles-types";
-import { NewQuery } from "./QueryBuilder";
-import { ViewHandler } from "../ViewHandler/ViewHandler";
+import type { NewQuery } from "./QueryBuilder";
+import type { ViewHandler } from "../ViewHandler/ViewHandler";
 import { getJoinQuery } from "./getJoinQuery";
 
 /**

package/lib/DboBuilder/QueryStreamer.ts

@@ -1,18 +1,19 @@
 import * as pg from "pg";
-import CursorType from "pg-cursor";
-import {
-  CHANNELS,
+import type CursorType from "pg-cursor";
+import type {
   SQLOptions,
   SocketSQLStreamPacket,
-  SocketSQLStreamServer,
+  SocketSQLStreamServer} from "prostgles-types";
+import {
+  CHANNELS,
   omitKeys,
   pickKeys,
 } from "prostgles-types";
-import { BasicCallback } from "../PubSubManager/PubSubManager";
-import { VoidFunction } from "../SchemaWatch/SchemaWatch";
-import { DB } from "../initProstgles";
-import { DboBuilder } from "./DboBuilder";
-import { PRGLIOSocket } from "./DboBuilderTypes";
+import type { BasicCallback } from "../PubSubManager/PubSubManager";
+import type { VoidFunction } from "../SchemaWatch/SchemaWatch";
+import type { DB } from "../initProstgles";
+import type { DboBuilder } from "./DboBuilder";
+import type { PRGLIOSocket } from "./DboBuilderTypes";
 import { getErrorAsObject, getSerializedClientErrorFromPGError } from "./dboBuilderUtils";
 import { getDetailedFieldInfo } from "./runSQL";
 const Cursor: typeof CursorType = require("pg-cursor");

package/lib/DboBuilder/TableHandler/DataValidator.ts

@@ -1,19 +1,21 @@
-import {
+import type {
   AnyObject,
-  FieldFilter,
+  FieldFilter} from "prostgles-types/dist";
+import {
   asName,
   getKeys,
   isEmpty,
   isObject,
   pickKeys,
 } from "prostgles-types/dist";
-import { DBHandlerServer } from "../../Prostgles";
-import { ValidateRowBasic } from "../../PublishParser/PublishParser";
+import type { DBHandlerServer } from "../../Prostgles";
+import type { ValidateRowBasic } from "../../PublishParser/PublishParser";
 import { asValue } from "../../PubSubManager/PubSubManagerUtils";
-import { LocalParams, TableSchemaColumn, pgp } from "../DboBuilder";
+import type { LocalParams, TableSchemaColumn} from "../DboBuilder";
+import { pgp } from "../DboBuilder";
 import { parseFunctionObject } from "../QueryBuilder/QueryBuilder";
 import { validateObj } from "../ViewHandler/ViewHandler";
-import { TableHandler, ValidatedParams } from "./TableHandler";
+import type { TableHandler, ValidatedParams } from "./TableHandler";
 
 type RowFieldDataPlain = {
   type: "plain";

package/lib/DboBuilder/TableHandler/TableHandler.ts

@@ -1,35 +1,31 @@
-import pgPromise from "pg-promise";
-import {
+import type pgPromise from "pg-promise";
+import type {
   AnyObject,
-  asName,
   DeleteParams,
   FieldFilter,
   InsertParams,
   Select,
   UpdateParams,
 } from "prostgles-types";
-import { DB } from "../../Prostgles";
-import { SyncRule, ParsedTableRule } from "../../PublishParser/PublishParser";
-import TableConfigurator from "../../TableConfig/TableConfig";
-import {
-  DboBuilder,
-  Filter,
-  getErrorAsObject,
-  getSerializedClientErrorFromPGError,
-  LocalParams,
-  TableHandlers,
-} from "../DboBuilder";
+import { asName } from "prostgles-types";
+import type { DB } from "../../Prostgles";
+import type { SyncRule, ParsedTableRule } from "../../PublishParser/PublishParser";
+import type TableConfigurator from "../../TableConfig/TableConfig";
+import type { DboBuilder, Filter, LocalParams, TableHandlers } from "../DboBuilder";
+import { getErrorAsObject, getSerializedClientErrorFromPGError } from "../DboBuilder";
 import type { TableSchema } from "../DboBuilderTypes";
 import { parseUpdateRules } from "../parseUpdateRules";
-import { COMPUTED_FIELDS, FUNCTIONS } from "../QueryBuilder/Functions";
+import { FUNCTIONS } from "../QueryBuilder/Functions/Functions";
 import { SelectItemBuilder, type SelectItemValidated } from "../QueryBuilder/QueryBuilder";
-import { JoinPaths, ViewHandler } from "../ViewHandler/ViewHandler";
+import type { JoinPaths } from "../ViewHandler/ViewHandler";
+import { ViewHandler } from "../ViewHandler/ViewHandler";
 import { DataValidator } from "./DataValidator";
 import { _delete } from "./delete";
 import { insert } from "./insert/insert";
 import { update } from "./update";
 import { updateBatch } from "./updateBatch";
 import { upsert } from "./upsert";
+import { COMPUTED_FIELDS } from "../QueryBuilder/Functions/COMPUTED_FIELDS";
 
 export type ValidatedParams = {
   row: AnyObject;

package/lib/DboBuilder/TableHandler/delete.ts

@@ -1,15 +1,16 @@
-import pgPromise from "pg-promise";
-import { AnyObject, DeleteParams, FieldFilter } from "prostgles-types";
-import { DeleteRule, ParsedTableRule } from "../../PublishParser/PublishParser";
-import {
+import type pgPromise from "pg-promise";
+import type { AnyObject, DeleteParams, FieldFilter } from "prostgles-types";
+import type { DeleteRule, ParsedTableRule } from "../../PublishParser/PublishParser";
+import type {
   Filter,
-  LocalParams,
+  LocalParams} from "../DboBuilder";
+import {
   getErrorAsObject,
   getSerializedClientErrorFromPGError,
   withUserRLS,
 } from "../DboBuilder";
 import { runQueryReturnType } from "../ViewHandler/find";
-import { TableHandler } from "./TableHandler";
+import type { TableHandler } from "./TableHandler";
 import { onDeleteFromFileTable } from "./onDeleteFromFileTable";
 
 export async function _delete(

package/lib/DboBuilder/TableHandler/insert/insert.ts

@@ -1,8 +1,10 @@
-import { AnyObject, InsertParams, asName, getSerialisableError, isObject } from "prostgles-types";
-import { ParsedTableRule, ValidateRowBasic } from "../../../PublishParser/PublishParser";
-import { LocalParams, getSerializedClientErrorFromPGError, withUserRLS } from "../../DboBuilder";
+import type { AnyObject, InsertParams } from "prostgles-types";
+import { asName, getSerialisableError, isObject } from "prostgles-types";
+import type { ParsedTableRule, ValidateRowBasic } from "../../../PublishParser/PublishParser";
+import type { LocalParams } from "../../DboBuilder";
+import { getSerializedClientErrorFromPGError, withUserRLS } from "../../DboBuilder";
 import { prepareNewData } from "../DataValidator";
-import { TableHandler } from "../TableHandler";
+import type { TableHandler } from "../TableHandler";
 import { insertTest } from "../insertTest";
 import { runInsertUpdateQuery } from "../runInsertUpdateQuery";
 import { insertNestedRecords } from "./insertNestedRecords";
@@ -272,13 +274,3 @@ const validateInsertParams = (params: InsertParams | undefined) => {
       throw "Invalid params: " + bad_params.join(", ") + " \n Expecting: " + good_params.join(", ");
   }
 };
-
-// const removeBuffers = (o: any) => {
-//   if(isPlainObject(o)){
-//     return JSON.stringify(getKeys(o).reduce((a, k) => {
-//       const value = o[k]
-//       return { ...a, [k]: Buffer.isBuffer(value)? `Buffer[${value.byteLength}][...REMOVED]` : value
-//     }
-//   }, {}));
-//   }
-// }

package/lib/DboBuilder/TableHandler/insert/insertNestedRecords.ts

@@ -1,17 +1,18 @@
-import {
+import type {
   AnyObject,
+  InsertParams} from "prostgles-types";
+import {
   getKeys,
   getPossibleNestedInsert,
-  InsertParams,
   isDefined,
   isObject,
   omitKeys,
   type ColumnInfo,
 } from "prostgles-types";
-import { LocalParams, TableHandlers } from "../../DboBuilder";
-import { ParsedTableRule } from "../../../PublishParser/PublishParser";
-import { TableHandler } from "../TableHandler";
-import { AuthClientRequest } from "../../../Auth/AuthTypes";
+import type { LocalParams, TableHandlers } from "../../DboBuilder";
+import type { ParsedTableRule } from "../../../PublishParser/PublishParser";
+import type { TableHandler } from "../TableHandler";
+import type { AuthClientRequest } from "../../../Auth/AuthTypes";
 
 type InsertNestedRecordsArgs = {
   data: AnyObject | AnyObject[];

package/lib/DboBuilder/TableHandler/insertTest.ts

@@ -1,8 +1,10 @@
-import { AnyObject, asName, FieldFilter, FullFilter } from "prostgles-types";
-import { LocalParams, pgp } from "../DboBuilder";
-import { ParsedTableRule } from "../../PublishParser/PublishParser";
+import type { AnyObject, FieldFilter, FullFilter } from "prostgles-types";
+import { asName } from "prostgles-types";
+import type { LocalParams} from "../DboBuilder";
+import { pgp } from "../DboBuilder";
+import type { ParsedTableRule } from "../../PublishParser/PublishParser";
 import { asValue } from "../../PubSubManager/PubSubManagerUtils";
-import { TableHandler } from "./TableHandler";
+import type { TableHandler } from "./TableHandler";
 
 type InsertTestArgs = {
   tableRules: ParsedTableRule | undefined;

package/lib/DboBuilder/TableHandler/onDeleteFromFileTable.ts

@@ -1,6 +1,8 @@
-import { AnyObject, asName, pickKeys } from "prostgles-types";
-import { LocalParams, type Media } from "../DboBuilder";
-import { TableHandler } from "./TableHandler";
+import type { AnyObject} from "prostgles-types";
+import { asName, pickKeys } from "prostgles-types";
+import type { LocalParams} from "../DboBuilder";
+import { type Media } from "../DboBuilder";
+import type { TableHandler } from "./TableHandler";
 
 type OnDeleteFromFileTableArgs = {
   localParams: LocalParams | undefined;

package/lib/DboBuilder/TableHandler/runInsertUpdateQuery.ts

@@ -1,7 +1,10 @@
-import { AnyObject, asName, FieldFilter, InsertParams, UpdateParams } from "prostgles-types";
-import { InsertRule, UpdateRule } from "../../PublishParser/PublishParser";
-import { getClientErrorFromPGError, LocalParams, withUserRLS } from "../DboBuilder";
-import { getSelectItemQuery, TableHandler } from "./TableHandler";
+import type { AnyObject, FieldFilter, InsertParams, UpdateParams } from "prostgles-types";
+import { asName } from "prostgles-types";
+import type { InsertRule, UpdateRule } from "../../PublishParser/PublishParser";
+import type { LocalParams} from "../DboBuilder";
+import { getClientErrorFromPGError, withUserRLS } from "../DboBuilder";
+import type { TableHandler } from "./TableHandler";
+import { getSelectItemQuery } from "./TableHandler";
 
 type RunInsertUpdateQueryArgs = {
   tableHandler: TableHandler;

package/lib/DboBuilder/TableHandler/update.ts

@@ -1,8 +1,9 @@
-import { AnyObject, UpdateParams } from "prostgles-types";
-import { ParsedTableRule } from "../../PublishParser/PublishParser";
-import {
+import type { AnyObject, UpdateParams } from "prostgles-types";
+import type { ParsedTableRule } from "../../PublishParser/PublishParser";
+import type {
   Filter,
-  LocalParams,
+  LocalParams} from "../DboBuilder";
+import {
   getErrorAsObject,
   getSerializedClientErrorFromPGError,
   withUserRLS,
@@ -10,7 +11,7 @@ import {
 import { prepareNewData } from "./DataValidator";
 import { getInsertTableRules, getReferenceColumnInserts } from "./insert/insertNestedRecords";
 import { runInsertUpdateQuery } from "./runInsertUpdateQuery";
-import { TableHandler } from "./TableHandler";
+import type { TableHandler } from "./TableHandler";
 import { updateFile } from "./updateFile";
 
 export async function update(

package/lib/DboBuilder/TableHandler/updateBatch.ts

@@ -1,14 +1,15 @@
-import { AnyObject, UpdateParams } from "prostgles-types";
-import { ParsedTableRule } from "../../PublishParser/PublishParser";
-import {
+import type { AnyObject, UpdateParams } from "prostgles-types";
+import type { ParsedTableRule } from "../../PublishParser/PublishParser";
+import type {
   Filter,
-  LocalParams,
+  LocalParams} from "../DboBuilder";
+import {
   getClientErrorFromPGError,
   getErrorAsObject,
   getSerializedClientErrorFromPGError,
   withUserRLS,
 } from "../DboBuilder";
-import { TableHandler } from "./TableHandler";
+import type { TableHandler } from "./TableHandler";
 
 export async function updateBatch(
   this: TableHandler,

package/lib/DboBuilder/TableHandler/updateFile.ts

@@ -1,8 +1,9 @@
-import { AnyObject, getJSONBObjectSchemaValidationError, omitKeys } from "prostgles-types";
-import { ParsedTableRule, ValidateRowBasic } from "../../PublishParser/PublishParser";
-import { LocalParams, Media } from "../DboBuilder";
+import type { AnyObject} from "prostgles-types";
+import { getJSONBObjectSchemaValidationError, omitKeys } from "prostgles-types";
+import type { ParsedTableRule, ValidateRowBasic } from "../../PublishParser/PublishParser";
+import type { LocalParams, Media } from "../DboBuilder";
 import { isFile, uploadFile } from "../uploadFile";
-import { TableHandler } from "./TableHandler";
+import type { TableHandler } from "./TableHandler";
 
 type Args = {
   newData: AnyObject;

package/lib/DboBuilder/TableHandler/upsert.ts

@@ -1,8 +1,8 @@
-import { AnyObject, UpdateParams } from "prostgles-types";
-import { ParsedTableRule } from "../../PublishParser/publishTypesAndUtils";
-import { Filter, LocalParams } from "../DboBuilderTypes";
+import type { AnyObject, UpdateParams } from "prostgles-types";
+import type { ParsedTableRule } from "../../PublishParser/publishTypesAndUtils";
+import type { Filter, LocalParams } from "../DboBuilderTypes";
 import { getErrorAsObject, getSerializedClientErrorFromPGError } from "../dboBuilderUtils";
-import { TableHandler } from "./TableHandler";
+import type { TableHandler } from "./TableHandler";
 
 export const upsert = async function (
   this: TableHandler,

package/lib/DboBuilder/TableRules/getValidatedRules.ts

@@ -1,9 +1,10 @@
 import { isEmpty, type FieldFilter } from "prostgles-types";
-import type { ParsedTableRule, TableRule } from "../../PublishParser/publishTypesAndUtils";
+import type { ParsedTableRule } from "../../PublishParser/publishTypesAndUtils";
 import type { LocalParams, ValidatedTableRules } from "../DboBuilderTypes";
-import { COMPUTED_FIELDS, type FieldSpec } from "../QueryBuilder/Functions";
-import { asNameAlias } from "../QueryBuilder/QueryBuilder";
+import type { FieldSpec } from "../QueryBuilder/Functions/Functions";
 import type { ViewHandler } from "../ViewHandler/ViewHandler";
+import { COMPUTED_FIELDS } from "../QueryBuilder/Functions/COMPUTED_FIELDS";
+import { asNameAlias } from "../../utils/asNameAlias";
 
 export function getValidatedRules(
   this: ViewHandler,

package/lib/DboBuilder/ViewHandler/ViewHandler.ts

@@ -1,28 +1,20 @@
-import * as pgPromise from "pg-promise";
-import {
+import type * as pgPromise from "pg-promise";
+import type {
   AnyObject,
   ColumnInfo,
   FieldFilter,
   SelectParams,
   SubscribeParams,
-  asName,
-  isObject,
 } from "prostgles-types";
-import { TableEvent } from "../../Logging";
-import { DB } from "../../Prostgles";
-import { Join } from "../../ProstglesTypes";
-import { ParsedTableRule } from "../../PublishParser/PublishParser";
-import { Graph } from "../../shortestPath";
-import {
-  DboBuilder,
-  Filter,
-  LocalParams,
-  TableHandlers,
-  escapeTSNames,
-  getSerializedClientErrorFromPGError,
-  postgresToTsType,
-} from "../DboBuilder";
-import { TableSchema } from "../DboBuilderTypes";
+import { asName, isObject, postgresToTsType } from "prostgles-types";
+import type { TableEvent } from "../../Logging";
+import type { DB } from "../../Prostgles";
+import type { Join } from "../../ProstglesTypes";
+import type { ParsedTableRule } from "../../PublishParser/PublishParser";
+import type { Graph } from "../../shortestPath";
+import type { DboBuilder, Filter, LocalParams, TableHandlers } from "../DboBuilder";
+import { getSerializedClientErrorFromPGError } from "../DboBuilder";
+import type { TableSchema } from "../DboBuilderTypes";
 import { getValidatedRules } from "../TableRules/getValidatedRules";
 import { getColumns } from "../getColumns";
 import { count } from "./count";
@@ -31,8 +23,10 @@ import { getInfo } from "./getInfo";
 import { parseFieldFilter } from "./parseFieldFilter";
 import { prepareWhere } from "./prepareWhere";
 import { size } from "./size";
-import { LocalFuncs, subscribe } from "./subscribe";
+import type { LocalFuncs } from "./subscribe";
+import { subscribe } from "./subscribe";
 import { validateViewRules } from "./validateViewRules";
+import { escapeTSNames } from "../../utils/utils";
 
 export type JoinPaths = {
   t1: string;

package/lib/DboBuilder/ViewHandler/count.ts

@@ -1,12 +1,12 @@
-import { SelectParams } from "prostgles-types";
-import { ParsedTableRule } from "../../PublishParser/publishTypesAndUtils";
-import { Filter, LocalParams } from "../DboBuilder";
+import type { SelectParams } from "prostgles-types";
+import type { ParsedTableRule } from "../../PublishParser/publishTypesAndUtils";
+import type { Filter, LocalParams } from "../DboBuilder";
 import {
   getErrorAsObject,
   getSerializedClientErrorFromPGError,
   withUserRLS,
 } from "../dboBuilderUtils";
-import { ViewHandler } from "./ViewHandler";
+import type { ViewHandler } from "./ViewHandler";
 
 export async function count(
   this: ViewHandler,

package/lib/DboBuilder/ViewHandler/find.ts

@@ -1,8 +1,10 @@
-import { SelectParams, isObject } from "prostgles-types";
-import { ParsedTableRule } from "../../PublishParser/PublishParser";
-import {
+import type { SelectParams} from "prostgles-types";
+import { isObject } from "prostgles-types";
+import type { ParsedTableRule } from "../../PublishParser/PublishParser";
+import type {
   Filter,
-  LocalParams,
+  LocalParams} from "../DboBuilder";
+import {
   getClientErrorFromPGError,
   getErrorAsObject,
   getSerializedClientErrorFromPGError,
@@ -10,10 +12,10 @@ import {
 } from "../DboBuilder";
 import { getNewQuery } from "../QueryBuilder/getNewQuery";
 import { getSelectQuery } from "../QueryBuilder/getSelectQuery";
-import { NewQuery } from "../QueryBuilder/QueryBuilder";
+import type { NewQuery } from "../QueryBuilder/QueryBuilder";
 import { canRunSQL } from "../runSQL";
-import { TableHandler } from "../TableHandler/TableHandler";
-import { ViewHandler } from "./ViewHandler";
+import type { TableHandler } from "../TableHandler/TableHandler";
+import type { ViewHandler } from "./ViewHandler";
 
 export const find = async function (
   this: ViewHandler,

package/lib/DboBuilder/ViewHandler/getExistsCondition.ts

@@ -1,8 +1,9 @@
-import { AnyObject, EXISTS_KEY, EXISTS_KEYS, FieldFilter, asName } from "prostgles-types";
-import { LocalParams, ExistsFilterConfig } from "../DboBuilder";
-import { ViewHandler } from "./ViewHandler";
-import { ParsedTableRule } from "../../PublishParser/PublishParser";
-import { TableHandler } from "../TableHandler/TableHandler";
+import type { AnyObject, EXISTS_KEY, FieldFilter} from "prostgles-types";
+import { EXISTS_KEYS, asName } from "prostgles-types";
+import type { LocalParams, ExistsFilterConfig } from "../DboBuilder";
+import type { ViewHandler } from "./ViewHandler";
+import type { ParsedTableRule } from "../../PublishParser/PublishParser";
+import type { TableHandler } from "../TableHandler/TableHandler";
 import { getTableJoinQuery } from "./getTableJoinQuery";
 
 export async function getExistsCondition(

package/lib/DboBuilder/ViewHandler/getExistsFilters.ts

@@ -1,6 +1,7 @@
-import { EXISTS_KEY, EXISTS_KEYS, getKeys } from "prostgles-types";
-import { ExistsFilterConfig } from "../DboBuilder";
-import { ViewHandler } from "./ViewHandler";
+import type { EXISTS_KEY} from "prostgles-types";
+import { EXISTS_KEYS, getKeys } from "prostgles-types";
+import type { ExistsFilterConfig } from "../DboBuilder";
+import type { ViewHandler } from "./ViewHandler";
 import { parseJoinPath } from "./parseJoinPath";
 
 export const getExistsFilters = (