prostgles-server 4.2.343 → 4.2.345

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

package/lib/DboBuilder/parseUpdateRules.ts

@@ -1,13 +1,15 @@
-import { AnyObject, FieldFilter, isDefined, UpdateParams } from "prostgles-types";
-import {
+import type { AnyObject, FieldFilter, UpdateParams } from "prostgles-types";
+import { isDefined } from "prostgles-types";
+import type {
   UpdateRule,
   ValidateRowBasic,
-  ValidateUpdateRowBasic,
+  ValidateUpdateRowBasic} from "../PublishParser/PublishParser";
+import {
   type ParsedTableRule,
 } from "../PublishParser/PublishParser";
-import { Filter, LocalParams } from "./DboBuilder";
+import type { Filter, LocalParams } from "./DboBuilder";
 import { prepareNewData } from "./TableHandler/DataValidator";
-import { TableHandler } from "./TableHandler/TableHandler";
+import type { TableHandler } from "./TableHandler/TableHandler";
 
 /**
  * 1) Check if publish is valid

package/lib/DboBuilder/prepareShortestJoinPaths.ts

@@ -1,8 +1,10 @@
-import { DboBuilder } from "../DboBuilder/DboBuilder";
-import { JOIN_TYPES, Join } from "../ProstglesTypes";
-import { Graph, findShortestPath } from "../shortestPath";
-import { TableSchema } from "./DboBuilderTypes";
-import { JoinPaths } from "./ViewHandler/ViewHandler";
+import type { DboBuilder } from "../DboBuilder/DboBuilder";
+import type { Join } from "../ProstglesTypes";
+import { JOIN_TYPES } from "../ProstglesTypes";
+import type { Graph} from "../shortestPath";
+import { findShortestPath } from "../shortestPath";
+import type { TableSchema } from "./DboBuilderTypes";
+import type { JoinPaths } from "./ViewHandler/ViewHandler";
 
 type Result = {
   joinGraph?: Graph | undefined;

package/lib/DboBuilder/runSQL.ts

@@ -1,9 +1,13 @@
-import pgPromise, { ParameterizedQuery as PQ, ParameterizedQuery } from "pg-promise";
-import pg from "pg-promise/typescript/pg-subset";
-import { AnyObject, SQLOptions, SQLResult, SQLResultInfo } from "prostgles-types";
-import { DB, Prostgles } from "../Prostgles";
-import { DboBuilder, LocalParams, pgp, postgresToTsType } from "./DboBuilder";
-import { AuthClientRequest } from "../Auth/AuthTypes";
+import type { ParameterizedQuery } from "pg-promise";
+import type pgPromise from "pg-promise";
+import { ParameterizedQuery as PQ } from "pg-promise";
+import type pg from "pg-promise/typescript/pg-subset";
+import type { AnyObject, SQLOptions, SQLResult, SQLResultInfo} from "prostgles-types";
+import { postgresToTsType } from "prostgles-types";
+import type { DB, Prostgles } from "../Prostgles";
+import type { DboBuilder, LocalParams} from "./DboBuilder";
+import { pgp } from "./DboBuilder";
+import type { AuthClientRequest } from "../Auth/AuthTypes";
 
 export async function runSQL(
   this: DboBuilder,

package/lib/DboBuilder/schema/getMaterialViews.ts

@@ -1,5 +1,5 @@
-import { DBorTx } from "../../Prostgles";
-import { ProstglesInitOptions } from "../../ProstglesTypes";
+import type { DBorTx } from "../../Prostgles";
+import type { ProstglesInitOptions } from "../../ProstglesTypes";
 import { getSchemaFilter } from "./getTablesForSchemaPostgresSQL";
 
 export const getMaterialViews = (db: DBorTx, schema: ProstglesInitOptions["schemaFilter"]) => {

package/lib/DboBuilder/schema/getTablesForSchemaPostgresSQL.ts

@@ -1,10 +1,10 @@
 import { asName, tryCatchV2 } from "prostgles-types";
 import { omitKeys } from "prostgles-types/dist/util";
-import { DBorTx } from "../../Prostgles";
-import { ProstglesInitOptions } from "../../ProstglesTypes";
-import { clone } from "../../utils";
-import { DboBuilder } from "../DboBuilder";
-import { TableSchema, TableSchemaColumn } from "../DboBuilderTypes";
+import type { DBorTx } from "../../Prostgles";
+import type { ProstglesInitOptions } from "../../ProstglesTypes";
+import { clone } from "../../utils/utils";
+import type { DboBuilder } from "../DboBuilder";
+import type { TableSchema, TableSchemaColumn } from "../DboBuilderTypes";
 import { getFkeys } from "../getFkeys";
 import { getMaterialViews } from "./getMaterialViews";
 import { getViewReferenceColumns } from "./getViewReferenceColumns";

package/lib/DboBuilder/uploadFile.ts

@@ -1,7 +1,8 @@
-import { AnyObject, getKeys, isObject } from "prostgles-types";
-import { LocalParams, Media } from "./DboBuilder";
-import { ValidateRowBasic } from "../PublishParser/PublishParser";
-import { TableHandler } from "./TableHandler/TableHandler";
+import type { AnyObject} from "prostgles-types";
+import { getKeys, isObject } from "prostgles-types";
+import type { LocalParams, Media } from "./DboBuilder";
+import type { ValidateRowBasic } from "../PublishParser/PublishParser";
+import type { TableHandler } from "./TableHandler/TableHandler";
 
 export const isFile = (row: any): row is { data: Buffer; name: string } => {
   return Boolean(

package/lib/FileManager/FileManager.ts

@@ -1,21 +1,16 @@
 import * as fs from "fs";
-import * as stream from "stream";
+import type * as stream from "stream";
 
 // import * as sharp from "sharp";
 import checkDiskSpace from "check-disk-space";
 
-import {
-  ALLOWED_CONTENT_TYPE,
-  ALLOWED_EXTENSION,
-  CONTENT_TYPE_TO_EXT,
-  getKeys,
-  ValidatedColumnInfo,
-} from "prostgles-types";
-import { DB, DBHandlerServer, Prostgles } from "../Prostgles";
+import type { ALLOWED_CONTENT_TYPE, ALLOWED_EXTENSION, ValidatedColumnInfo } from "prostgles-types";
+import { CONTENT_TYPE_TO_EXT, getKeys } from "prostgles-types";
+import type { DB, DBHandlerServer, Prostgles } from "../Prostgles";
 
 import * as path from "path";
 import { removeExpressRoute } from "../Auth/utils/removeExpressRoute";
-import { ExpressApp } from "../RestApi";
+import type { ExpressApp } from "../RestApi";
 import { getValidatedFileType } from "./getValidatedFileType";
 import { initFileManager } from "./initFileManager";
 import { upload } from "./upload";
@@ -306,18 +301,6 @@ export class FileManager {
   };
 }
 
-export const removeExpressRouteByName = (app: ExpressApp | undefined, name: string) => {
-  const routes = app?._router?.stack;
-  if (routes) {
-    app._router!.stack = routes.filter((route) => {
-      if (route.name === name) {
-        return false;
-      }
-      return true;
-    });
-  }
-};
-
 export const getFileTypeFromFilename = (
   fileName: string
 ): { mime: ALLOWED_CONTENT_TYPE; ext: ALLOWED_EXTENSION } | undefined => {
@@ -346,6 +329,7 @@ export const getFileType = async (
   fileName: string
 ): Promise<{ mime: ALLOWED_CONTENT_TYPE; ext: ALLOWED_EXTENSION }> => {
   const { fileTypeFromBuffer } = await (eval('import("file-type")') as Promise<
+    // eslint-disable-next-line @typescript-eslint/consistent-type-imports
     typeof import("file-type")
   >);
 

package/lib/FileManager/getValidatedFileType.ts

@@ -1,12 +1,14 @@
+import type {
+  ALLOWED_CONTENT_TYPE} from "prostgles-types";
 import {
-  ALLOWED_CONTENT_TYPE,
   ALLOWED_EXTENSION,
   CONTENT_TYPE_TO_EXT,
   getKeys,
   isObject,
 } from "prostgles-types";
 import { parseFieldFilter } from "../DboBuilder/ViewHandler/parseFieldFilter";
-import { FileManager, getFileType, getFileTypeFromFilename } from "./FileManager";
+import type { FileManager} from "./FileManager";
+import { getFileType, getFileTypeFromFilename } from "./FileManager";
 
 type Args = {
   file: Buffer | string;

package/lib/FileManager/initFileManager.ts

@@ -2,12 +2,13 @@ import * as fs from "fs";
 import { asName, tryCatchV2 } from "prostgles-types";
 import { HTTP_FAIL_CODES } from "../Auth/AuthHandler";
 import type { Media } from "../DboBuilder/DboBuilderTypes";
-import { TableHandler } from "../DboBuilder/TableHandler/TableHandler";
+import type { TableHandler } from "../DboBuilder/TableHandler/TableHandler";
 import { canCreateTables } from "../DboBuilder/runSQL";
-import { Prostgles } from "../Prostgles";
+import type { Prostgles } from "../Prostgles";
 import type { SchemaRelatedOptions } from "../TableConfig/getCreateSchemaQueries";
 import { runClientRequest } from "../runClientRequest";
-import { FileManager, HOUR, LocalConfig } from "./FileManager";
+import type { FileManager, LocalConfig } from "./FileManager";
+import { HOUR } from "./FileManager";
 import { join } from "path";
 
 export const getFileManagerSchema = ({

package/lib/FileManager/upload.ts

@@ -1,4 +1,4 @@
-import { FileManager, LocalConfig, OnProgress, UploadedItem } from "./FileManager";
+import type { FileManager, LocalConfig, OnProgress, UploadedItem } from "./FileManager";
 import * as stream from "stream";
 import * as fs from "fs";
 

package/lib/FileManager/uploadStream.ts

@@ -1,4 +1,4 @@
-import { FileManager, OnProgress, UploadedItem } from "./FileManager";
+import type { FileManager, OnProgress, UploadedItem } from "./FileManager";
 import * as fs from "fs";
 import * as stream from "stream";
 import * as path from "path";

package/lib/Filtering.ts

@@ -1,9 +1,10 @@
+import type {
+  FilterDataType,
+  FullFilter} from "prostgles-types";
 import {
   BetweenFilterKeys,
   CompareFilterKeys,
   CompareInFilterKeys,
-  FilterDataType,
-  FullFilter,
   GeomFilterKeys,
   GeomFilter_Funcs,
   JsonbFilterKeys,

package/lib/Logging.ts

@@ -1,6 +1,6 @@
-import { AnyObject, ClientSchema, TableHandler } from "prostgles-types";
-import { LocalParams } from "./DboBuilder/DboBuilder";
-import { PubSubManagerTriggers } from "./PubSubManager/PubSubManager";
+import type { AnyObject, ClientSchema, TableHandler } from "prostgles-types";
+import type { LocalParams } from "./DboBuilder/DboBuilder";
+import type { PubSubManagerTriggers } from "./PubSubManager/PubSubManager";
 import type { NotifTypeName } from "./PubSubManager/PubSubManagerUtils";
 
 type ClientInfo = {

package/lib/PostgresNotifListenManager.ts

@@ -3,9 +3,9 @@
  *  Licensed under the MIT License. See LICENSE in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { DB } from "./Prostgles";
-import pg from "pg-promise/typescript/pg-subset";
-import pgPromise from "pg-promise";
+import type { DB } from "./Prostgles";
+import type pg from "pg-promise/typescript/pg-subset";
+import type pgPromise from "pg-promise";
 
 export type PrglNotifListener = (args: {
   length: number;

package/lib/Prostgles.ts

@@ -3,11 +3,12 @@
  *  Licensed under the MIT License. See LICENSE in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import * as pgPromise from "pg-promise";
+import type * as pgPromise from "pg-promise";
 import { AuthHandler } from "./Auth/AuthHandler";
 import { FileManager } from "./FileManager/FileManager";
-import { OnInitReason, initProstgles } from "./initProstgles";
-import { SchemaWatch } from "./SchemaWatch/SchemaWatch";
+import type { OnInitReason} from "./initProstgles";
+import { initProstgles } from "./initProstgles";
+import type { SchemaWatch } from "./SchemaWatch/SchemaWatch";
 import { getClientSchema } from "./WebsocketAPI/getClientSchema";
 import { onSocketConnected } from "./WebsocketAPI/onSocketConnected";
 import pg = require("pg-promise/typescript/pg-subset");
@@ -16,15 +17,16 @@ import type { ProstglesInitOptions } from "./ProstglesTypes";
 import { RestApi } from "./RestApi";
 import TableConfigurator from "./TableConfig/TableConfig";
 
-import { DBHandlerServer, DboBuilder, PRGLIOSocket } from "./DboBuilder/DboBuilder";
+import type { PRGLIOSocket } from "./DboBuilder/DboBuilder";
+import { DBHandlerServer, DboBuilder } from "./DboBuilder/DboBuilder";
 export { DBHandlerServer };
 export type PGP = pgPromise.IMain<{}, pg.IClient>;
 export { getEmailSender, getOrSetTransporter, verifySMTPConfig } from "./Auth/sendEmail";
 export { applyTableConfig } from "./TableConfig/applyTableConfig";
 
 import { CHANNELS, tryCatchV2 } from "prostgles-types";
-import { DBEventsManager } from "./DBEventsManager";
-import { PublishParser } from "./PublishParser/PublishParser";
+import type { DBEventsManager } from "./DBEventsManager";
+import type { PublishParser } from "./PublishParser/PublishParser";
 import { pushSocketSchema } from "./WebsocketAPI/pushSocketSchema";
 
 export type DB = pgPromise.IDatabase<{}, pg.IClient>;