prostgles-server 4.2.344 → 4.2.346

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 = (

package/lib/DboBuilder/ViewHandler/getInfo.ts

@@ -1,7 +1,7 @@
-import { TableInfo as TInfo } from "prostgles-types/dist";
-import { ParsedTableRule } from "../../PublishParser/PublishParser";
-import { LocalParams } from "../DboBuilder";
-import { ViewHandler } from "./ViewHandler";
+import type { TableInfo as TInfo } from "prostgles-types/dist";
+import type { ParsedTableRule } from "../../PublishParser/PublishParser";
+import type { LocalParams } from "../DboBuilder";
+import type { ViewHandler } from "./ViewHandler";
 
 export async function getInfo(
   this: ViewHandler,

package/lib/DboBuilder/ViewHandler/getTableJoinQuery.ts

@@ -1,5 +1,5 @@
 import { asName } from "prostgles-types";
-import { ParsedJoinPath } from "./parseJoinPath";
+import type { ParsedJoinPath } from "./parseJoinPath";
 
 type getTableJoinsArgs = {
   rootTableAlias: string;

package/lib/DboBuilder/ViewHandler/parseComplexFilter.ts

@@ -1,13 +1,16 @@
-import { AnyObject, isObject } from "prostgles-types";
+import type { AnyObject } from "prostgles-types";
+import { 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 { FUNCTIONS } from "../QueryBuilder/Functions/Functions";
+import { parseFunctionObject } from "../QueryBuilder/QueryBuilder";
+import type { TableSchemaColumn } from "../DboBuilderTypes";
 import { asValue } from "../../PubSubManager/PubSubManagerUtils";
+import { parseFunction } from "../QueryBuilder/Functions/parseFunction";
+import { asNameAlias } from "../../utils/asNameAlias";
 
 const allowedComparators = FILTER_OPERANDS; //[">", "<", "=", "<=", ">=", "<>", "!="]
 type Args = {

package/lib/DboBuilder/ViewHandler/parseFieldFilter.ts

@@ -1,5 +1,5 @@
-import { FieldFilter, getKeys } from "prostgles-types";
-import { isPlainObject } from "../DboBuilder";
+import type { FieldFilter } from "prostgles-types";
+import { getKeys, includes, isObject } from "prostgles-types";
 
 /**
  * Filter string array
@@ -23,7 +23,14 @@ export const parseFieldFilter = <AllowedKeys extends string[]>(
     }
 
     /* string[] */
-    if (Array.isArray(fieldParams) && !fieldParams.find((f) => typeof f !== "string")) {
+    if (Array.isArray(fieldParams)) {
+      if (fieldParams.find((f) => typeof f !== "string")) {
+        throw (
+          " Invalid field filter array.\nExpecting array of strings. \n Received ->  " +
+          initialParams
+        );
+      }
+
       /* 
         ["*"] 
       */
@@ -50,9 +57,9 @@ export const parseFieldFilter = <AllowedKeys extends string[]>(
           { field1: true, field2: true } = only field1 and field2
           { field1: false, field2: false } = all fields except field1 and field2
       */
-    } else if (isPlainObject(fieldParams)) {
+    } else if (isObject(fieldParams)) {
       if (!getKeys(fieldParams as Record<string, any>).length) {
-        return [] as unknown as typeof all_cols; //all_fields.slice(0) as typeof all_fields;
+        return [] as unknown as typeof all_cols;
       }
 
       const keys = getKeys(
@@ -72,7 +79,13 @@ export const parseFieldFilter = <AllowedKeys extends string[]>(
 
       keys.forEach((key) => {
         const allowedVals = [true, false, 0, 1];
-        if (!allowedVals.includes((fieldParams as any)[key]))
+        if (
+          !includes(
+            allowedVals,
+            //@ts-ignore
+            fieldParams[key]
+          )
+        )
           throw `Invalid field selection value for: { ${key}: ${(fieldParams as any)[key]} }. \n Allowed values: ${allowedVals.join(" OR ")}`;
       });
 

package/lib/DboBuilder/ViewHandler/parseJoinPath.ts

@@ -1,5 +1,6 @@
-import { JoinPath, RawJoinPath, reverseJoinOn } from "prostgles-types";
-import { ViewHandler } from "./ViewHandler";
+import type { JoinPath, RawJoinPath} from "prostgles-types";
+import { reverseJoinOn } from "prostgles-types";
+import type { ViewHandler } from "./ViewHandler";
 
 type parseJoinPathArgs = {
   rawPath: RawJoinPath;
@@ -69,7 +70,7 @@ export const parseJoinPath = ({
   return result;
 };
 
-import { JoinInfo } from "../DboBuilder";
+import type { JoinInfo } from "../DboBuilder";
 
 type Opts = {
   allowMultiOrJoin?: boolean;

package/lib/DboBuilder/ViewHandler/prepareSortItems.ts

@@ -1,13 +1,14 @@
+import type { OrderBy } from "prostgles-types/dist";
 import {
-  OrderBy,
   asName,
   getJSONBObjectSchemaValidationError,
   isDefined,
   isEmpty,
   isObject,
 } from "prostgles-types/dist";
-import { SortItem } from "../DboBuilder";
-import { NewQueryJoin, SelectItemValidated, asNameAlias } from "../QueryBuilder/QueryBuilder";
+import type { SortItem } from "../DboBuilder";
+import type { NewQueryJoin, SelectItemValidated } from "../QueryBuilder/QueryBuilder";
+import { asNameAlias } from "../../utils/asNameAlias";
 
 /* This relates only to SELECT */
 export const prepareSortItems = (

package/lib/DboBuilder/ViewHandler/prepareWhere.ts

@@ -1,9 +1,10 @@
-import { AnyObject, FieldFilter, getKeys, isDefined, isObject } from "prostgles-types/dist";
-import { ParsedTableRule } from "../../PublishParser/PublishParser";
-import { ExistsFilterConfig, Filter, LocalParams } from "../DboBuilder";
+import type { AnyObject, FieldFilter} from "prostgles-types/dist";
+import { getKeys, isDefined, isObject } from "prostgles-types/dist";
+import type { ParsedTableRule } from "../../PublishParser/PublishParser";
+import type { ExistsFilterConfig, Filter, LocalParams } from "../DboBuilder";
 import { getCondition } from "../getCondition";
 import { type SelectItemValidated } from "../QueryBuilder/QueryBuilder";
-import { ViewHandler } from "./ViewHandler";
+import type { ViewHandler } from "./ViewHandler";
 
 export type PrepareWhereParams = {
   filter?: Filter;

package/lib/DboBuilder/ViewHandler/size.ts

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

package/lib/DboBuilder/ViewHandler/subscribe.ts

@@ -1,14 +1,15 @@
-import { AnyObject, SubscribeParams, SubscriptionChannels } from "prostgles-types";
-import { ParsedTableRule } from "../../PublishParser/PublishParser";
-import {
+import type { AnyObject, SubscribeParams, SubscriptionChannels } from "prostgles-types";
+import type { ParsedTableRule } from "../../PublishParser/PublishParser";
+import type {
   Filter,
+  LocalParams} from "../DboBuilder";
+import {
   getErrorAsObject,
-  getSerializedClientErrorFromPGError,
-  LocalParams,
+  getSerializedClientErrorFromPGError
 } from "../DboBuilder";
 import { getSubscribeRelatedTables } from "../getSubscribeRelatedTables";
-import { NewQuery } from "../QueryBuilder/QueryBuilder";
-import { ViewHandler } from "./ViewHandler";
+import type { NewQuery } from "../QueryBuilder/QueryBuilder";
+import type { ViewHandler } from "./ViewHandler";
 import { getValidatedSubscribeOptions } from "./getValidatedSubscribeOptions";
 
 type OnData = (items: AnyObject[]) => any;

package/lib/DboBuilder/ViewHandler/validateViewRules.ts

@@ -1,6 +1,6 @@
-import { AnyObject, FieldFilter } from "prostgles-types/dist";
-import { UpdateRule } from "../../PublishParser/PublishParser";
-import { ViewHandler } from "./ViewHandler";
+import type { AnyObject, FieldFilter } from "prostgles-types/dist";
+import type { UpdateRule } from "../../PublishParser/PublishParser";
+import type { ViewHandler } from "./ViewHandler";
 
 export async function validateViewRules(
   this: ViewHandler,

package/lib/DboBuilder/dboBuilderUtils.ts

@@ -3,31 +3,18 @@
  *  Licensed under the MIT License. See LICENSE in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import {
-  AnyObject,
-  PG_COLUMN_UDT_DATA_TYPE,
-  ProstglesError,
-  TS_PG_Types,
-  getKeys,
-  isObject,
-  omitKeys,
-  pickKeys,
-} from "prostgles-types";
-import { DB } from "../Prostgles";
-import { LocalParams, SortItem, pgp } from "./DboBuilderTypes";
-import { asNameAlias } from "./QueryBuilder/QueryBuilder";
-import { ViewHandler } from "./ViewHandler/ViewHandler";
+import type { AnyObject, ProstglesError } from "prostgles-types";
+import { asNameAlias } from "../utils/asNameAlias";
+import { isObject, omitKeys, pickKeys } from "prostgles-types";
+import type { DB } from "../Prostgles";
+import type { LocalParams, SortItem } from "./DboBuilderTypes";
+import { pgp } from "./DboBuilderTypes";
 import { getSchemaFilter } from "./schema/getTablesForSchemaPostgresSQL";
+import type { ViewHandler } from "./ViewHandler/ViewHandler";
 
-import { ProstglesInitOptions } from "../ProstglesTypes";
+import type { ProstglesInitOptions } from "../ProstglesTypes";
 import { sqlErrCodeToMsg } from "./sqlErrCodeToMsg";
-import { TableHandler } from "./TableHandler/TableHandler";
-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);
-}
+import type { TableHandler } from "./TableHandler/TableHandler";
 
 const safeStringify = (obj: AnyObject) => {
   const seen = new WeakSet();
@@ -214,23 +201,6 @@ export const getConstraints = async (
   );
 };
 
-/**
- * @deprecated
- * use isObject
- */
-export function isPlainObject(o: any): o is Record<string, any> {
-  return Object(o) === o && Object.getPrototypeOf(o) === Object.prototype;
-}
-
-export function postgresToTsType(udt_data_type: PG_COLUMN_UDT_DATA_TYPE): keyof typeof TS_PG_Types {
-  return (
-    getKeys(TS_PG_Types).find((k) => {
-      // @ts-ignore
-      return TS_PG_Types[k].includes(udt_data_type);
-    }) ?? "any"
-  );
-}
-
 export const prepareOrderByQuery = (items: SortItem[], tableAlias?: string): string[] => {
   if (!items.length) return [];
   return [
@@ -269,10 +239,3 @@ export const withUserRLS = (localParams: LocalParams | undefined, query: string)
 
   return [firstQuery, query].join("\n");
 };
-
-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);
-}

package/lib/DboBuilder/getColumns.ts

@@ -1,21 +1,18 @@
-import {
+import type {
   AnyObject,
-  PG_COLUMN_UDT_DATA_TYPE,
-  ValidatedColumnInfo,
+  ValidatedColumnInfo} from "prostgles-types";
+import {
   _PG_geometric,
   isDefined,
   isObject,
   omitKeys,
-} from "prostgles-types";
-import { ParsedTableRule } from "../PublishParser/PublishParser";
-import {
-  LocalParams,
-  getErrorAsObject,
-  getSerializedClientErrorFromPGError,
   postgresToTsType,
-} from "./DboBuilder";
-import { TableHandler } from "./TableHandler/TableHandler";
-import { ViewHandler } from "./ViewHandler/ViewHandler";
+} from "prostgles-types";
+import type { ParsedTableRule } from "../PublishParser/PublishParser";
+import type { LocalParams} from "./DboBuilder";
+import { getErrorAsObject, getSerializedClientErrorFromPGError } from "./DboBuilder";
+import type { TableHandler } from "./TableHandler/TableHandler";
+import type { ViewHandler } from "./ViewHandler/ViewHandler";
 
 export const isTableHandler = (v: any): v is TableHandler => "parseUpdateRules" in v;
 

package/lib/DboBuilder/getCondition.ts

@@ -1,10 +1,11 @@
 import { pickKeys } from "prostgles-types";
 import { parseFilterItem } from "../Filtering";
-import { ParsedTableRule } from "../PublishParser/PublishParser";
-import { ExistsFilterConfig, LocalParams, pgp } from "./DboBuilder";
-import { FUNCTIONS } from "./QueryBuilder/Functions";
-import { SelectItem, type SelectItemValidated } from "./QueryBuilder/QueryBuilder";
-import { ViewHandler } from "./ViewHandler/ViewHandler";
+import type { ParsedTableRule } from "../PublishParser/PublishParser";
+import type { ExistsFilterConfig, LocalParams} from "./DboBuilder";
+import { pgp } from "./DboBuilder";
+import { FUNCTIONS } from "./QueryBuilder/Functions/Functions";
+import { type SelectItemValidated } from "./QueryBuilder/QueryBuilder";
+import type { ViewHandler } from "./ViewHandler/ViewHandler";
 import { getExistsCondition } from "./ViewHandler/getExistsCondition";
 import { getExistsFilters } from "./ViewHandler/getExistsFilters";
 import { parseComplexFilter } from "./ViewHandler/parseComplexFilter";

package/lib/DboBuilder/getSubscribeRelatedTables.ts

@@ -1,15 +1,17 @@
-import {
+import type {
   AnyObject,
-  asName,
   ParsedJoinPath,
-  reverseParsedPath,
-  SubscribeParams,
+  SubscribeParams} from "prostgles-types";
+import {
+  asName,
+  reverseParsedPath
 } from "prostgles-types";
-import { ParsedTableRule } from "../PublishParser/PublishParser";
-import { ViewSubscriptionOptions } from "../PubSubManager/PubSubManager";
-import { Filter, getSerializedClientErrorFromPGError, LocalParams } from "./DboBuilder";
-import { NewQuery } from "./QueryBuilder/QueryBuilder";
-import { ViewHandler } from "./ViewHandler/ViewHandler";
+import type { ParsedTableRule } from "../PublishParser/PublishParser";
+import type { ViewSubscriptionOptions } from "../PubSubManager/PubSubManager";
+import type { Filter, LocalParams } from "./DboBuilder";
+import { getSerializedClientErrorFromPGError } from "./DboBuilder";
+import type { NewQuery } from "./QueryBuilder/QueryBuilder";
+import type { ViewHandler } from "./ViewHandler/ViewHandler";
 import { log } from "../PubSubManager/PubSubManagerUtils";
 
 type Args = {