prostgles-server 4.2.344 → 4.2.346

package/lib/DboBuilder/DboBuilder.ts

@@ -3,9 +3,8 @@
  *  Licensed under the MIT License. See LICENSE in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import type { PG_COLUMN_UDT_DATA_TYPE, SQLOptions } from "prostgles-types";
 import {
-  PG_COLUMN_UDT_DATA_TYPE,
-  SQLOptions,
   getJSONBTSTypes,
   getJoinHandlers,
   getObjectEntries,
@@ -14,16 +13,17 @@ import {
   tryCatchV2,
   type JSONB,
 } from "prostgles-types";
-import { getDBSchema } from "../DBSchemaBuilder";
-import { DB, Prostgles } from "../Prostgles";
-import { Join } from "../ProstglesTypes";
+import { getDBSchema } from "../DBSchemaBuilder/DBSchemaBuilder";
+import type { DB, Prostgles } from "../Prostgles";
+import type { Join } from "../ProstglesTypes";
 import { PubSubManager } from "../PubSubManager/PubSubManager";
 import { getCreatePubSubManagerError } from "../PubSubManager/getCreatePubSubManagerError";
-import { DbTableInfo, getV2Methods, PublishParser } from "../PublishParser/PublishParser";
+import type { DbTableInfo, PublishParser } from "../PublishParser/PublishParser";
+import { getV2Methods } from "../PublishParser/PublishParser";
 import { getQueryErrorPositionInfo } from "../TableConfig/runSQLFile";
-import { Graph } from "../shortestPath";
-import { clone } from "../utils";
-import {
+import type { Graph } from "../shortestPath";
+import { clone } from "../utils/utils";
+import type {
   DBHandlerServer,
   DbTxTableHandlers,
   LocalParams,
@@ -32,10 +32,11 @@ import {
 } from "./DboBuilderTypes";
 import { QueryStreamer } from "./QueryStreamer";
 import { TableHandler } from "./TableHandler/TableHandler";
-import { JoinPaths, ViewHandler } from "./ViewHandler/ViewHandler";
+import type { JoinPaths } from "./ViewHandler/ViewHandler";
+import { ViewHandler } from "./ViewHandler/ViewHandler";
 import { parseJoinPath } from "./ViewHandler/parseJoinPath";
+import type { PGConstraint } from "./dboBuilderUtils";
 import {
-  PGConstraint,
   getCanExecute,
   getConstraints,
   getSerializedClientErrorFromPGError,
@@ -240,7 +241,8 @@ export class DboBuilder {
       data: tablesOrViewsReq.durations,
       duration: Date.now() - start,
     });
-    this.tablesOrViews = tablesOrViewsReq.result;
+    const tablesOrViews = tablesOrViewsReq.result;
+    this.tablesOrViews = tablesOrViews;
 
     this.constraints = await getConstraints(this.db, this.prostgles.opts.schemaFilter);
     await this.prepareShortestJoinPaths();
@@ -301,7 +303,7 @@ export class DboBuilder {
     const v2Methods = getV2Methods(this.prostgles.opts.publishMethods);
     if (v2Methods) {
       const methodDefinitions = getObjectEntries(v2Methods).map(([name, method]) => {
-        const argumentTypes = getJSONBTSTypes(this.tablesOrViews ?? [], {
+        const argumentTypes = getJSONBTSTypes(tablesOrViews, {
           type: method.input as JSONB.ObjectType["type"],
         });
 
@@ -309,7 +311,7 @@ export class DboBuilder {
           v.trim().endsWith(";") ? v.trim().slice(0, -1) : v.trim();
         const returnType =
           !method.output ? "void" : (
-            getJSONBTSTypes(this.tablesOrViews ?? [], {
+            getJSONBTSTypes(tablesOrViews, {
               type: method.output as JSONB.ObjectType["type"],
             })
           );
@@ -329,7 +331,10 @@ export class DboBuilder {
 
     this.tsTypesDefinition = [
       `/* Schema definition generated by prostgles-server */`,
-      getDBSchema(this),
+      getDBSchema({
+        config: this.prostgles.opts.tableConfig,
+        tablesOrViews,
+      }),
       functionTypes,
     ].join("\n");
 

package/lib/DboBuilder/DboBuilderTypes.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as pgPromise from "pg-promise";
-import {
+import type {
   AnyObject,
   ClientSchema,
   ColumnInfo,
@@ -15,12 +15,12 @@ import {
   TableInfo as TInfo,
   UserLike,
 } from "prostgles-types";
-import { AuthClientRequest, BasicSession, SessionUser } from "../Auth/AuthTypes";
-import { BasicCallback } from "../PubSubManager/PubSubManager";
-import { PublishAllOrNothing } from "../PublishParser/PublishParser";
-import { FieldSpec } from "./QueryBuilder/Functions";
-import { TableHandler } from "./TableHandler/TableHandler";
-import { ParsedJoinPath } from "./ViewHandler/parseJoinPath";
+import type { AuthClientRequest, BasicSession, SessionUser } from "../Auth/AuthTypes";
+import type { BasicCallback } from "../PubSubManager/PubSubManager";
+import type { PublishAllOrNothing } from "../PublishParser/PublishParser";
+import type { FieldSpec } from "./QueryBuilder/Functions/Functions";
+import type { TableHandler } from "./TableHandler/TableHandler";
+import type { ParsedJoinPath } from "./ViewHandler/parseJoinPath";
 import pg = require("pg-promise/typescript/pg-subset");
 
 type PGP = pgPromise.IMain<{}, pg.IClient>;

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

@@ -0,0 +1,35 @@
+import { asNameAlias } from "../../../utils/asNameAlias";
+import type { FieldSpec } from "./Functions";
+/* The difference between a function and computed field is that the computed field does not require any arguments */
+export const COMPUTED_FIELDS: FieldSpec[] = [
+  /**
+   * Used instead of row id. Must be used as a last resort. Use all non pseudo or domain data type columns first!
+   */
+  {
+    name: "$rowhash",
+    type: "computed",
+    // description: ` order hash of row content  `,
+    getQuery: ({ allowedFields, tableAlias, ctidField }) => {
+      return (
+        "md5(" +
+        allowedFields
+
+          /* CTID not available in AFTER trigger */
+          // .concat(ctidField? [ctidField] : [])
+          .sort()
+          .map((f) => asNameAlias(f, tableAlias))
+          .map((f) => `md5(coalesce(${f}::text, 'dd'))`)
+          .join(" || ") +
+        `)`
+      );
+    },
+  },
+  // ,{
+  //   name: "ctid",
+  //   type: "computed",
+  //   // description: ` order hash of row content  `,
+  //   getQuery: ({ allowedFields, tableAlias, ctidField }) => {
+  //     return asNameAlias("ctid", tableAlias);
+  //   }
+  // }
+];

package/lib/DboBuilder/QueryBuilder/{Functions.ts → Functions/Functions.ts}

@@ -1,78 +1,16 @@
+import type { ColumnInfo, PG_COLUMN_UDT_DATA_TYPE } from "prostgles-types";
 import {
   asName,
-  ColumnInfo,
   includes,
   isEmpty,
   isObject,
-  PG_COLUMN_UDT_DATA_TYPE,
   TextFilter_FullTextSearchFilterKeys,
+  postgresToTsType,
 } from "prostgles-types";
-import { isPlainObject, pgp, postgresToTsType } from "../DboBuilder";
-import { parseFieldFilter } from "../ViewHandler/parseFieldFilter";
-import { asNameAlias } from "./QueryBuilder";
-
-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;
-};
+import { parseFieldFilter } from "../../ViewHandler/parseFieldFilter";
+import * as pgPromise from "pg-promise";
+import { asNameAlias } from "../../../utils/asNameAlias";
+const pgp = pgPromise();
 
 type GetQueryArgs = {
   allColumns: ColumnInfo[];
@@ -284,7 +222,7 @@ const FTS_Funcs: FunctionSpec[] =
       const searchTypes = TextFilter_FullTextSearchFilterKeys;
 
       /* { to_tsquery: 'search term' } */
-      if (isPlainObject(qVal)) {
+      if (isObject(qVal)) {
         const keys = Object.keys(qVal);
         if (!keys.length) throw "Bad arg";
         if (keys.length !== 1 || !searchTypes.includes(keys[0] as any))
@@ -1274,40 +1212,6 @@ export const FUNCTIONS: FunctionSpec[] = [
   } as FunctionSpec,
 ];
 
-/* The difference between a function and computed field is that the computed field does not require any arguments */
-export const COMPUTED_FIELDS: FieldSpec[] = [
-  /**
-   * Used instead of row id. Must be used as a last resort. Use all non pseudo or domain data type columns first!
-   */
-  {
-    name: "$rowhash",
-    type: "computed",
-    // description: ` order hash of row content  `,
-    getQuery: ({ allowedFields, tableAlias, ctidField }) => {
-      return (
-        "md5(" +
-        allowedFields
-
-          /* CTID not available in AFTER trigger */
-          // .concat(ctidField? [ctidField] : [])
-          .sort()
-          .map((f) => asNameAlias(f, tableAlias))
-          .map((f) => `md5(coalesce(${f}::text, 'dd'))`)
-          .join(" || ") +
-        `)`
-      );
-    },
-  },
-  // ,{
-  //   name: "ctid",
-  //   type: "computed",
-  //   // description: ` order hash of row content  `,
-  //   getQuery: ({ allowedFields, tableAlias, ctidField }) => {
-  //     return asNameAlias("ctid", tableAlias);
-  //   }
-  // }
-];
-
 /*
  
 

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[];