prostgles-server 4.2.549 → 4.2.551

package/lib/DboBuilder/TableHandler/runInsertUpdateQuery.ts

@@ -2,9 +2,10 @@ import type { AnyObject, FieldFilter, InsertParams, UpdateParams } from "prostgl
 import { asName } from "prostgles-types";
 import type { InsertRule, UpdateRule } from "../../PublishParser/PublishParser";
 import type { LocalParams } from "../DboBuilder";
-import { getClientErrorFromPGError, withUserRLS } from "../DboBuilder";
+import { rejectWithPGClientError, withUserRLS } from "../DboBuilder";
 import type { TableHandler } from "./TableHandler";
 import { getSelectItemQuery } from "./TableHandler";
+import { executeHooksCheckAndPostValidation } from "./executeHooksCheckAndPostValidation";
 
 type RunInsertUpdateQueryArgs = {
   tableHandler: TableHandler;
@@ -71,7 +72,12 @@ export const runInsertUpdateQuery = async (args: RunInsertUpdateQueryArgs) => {
       RETURNING *
     )
     SELECT 
-      count(*) as row_count,
+      count(*) as row_count, 
+      EXISTS (
+        SELECT *
+        FROM ${escapedTableName}
+        ${checkCondition} 
+      ) AS failed_check,
       (
         SELECT json_agg(item)
         FROM (
@@ -86,127 +92,47 @@ export const runInsertUpdateQuery = async (args: RunInsertUpdateQueryArgs) => {
           FROM ${escapedTableName}
           WHERE ${hasReturning ? "TRUE" : "FALSE"}
         ) item
-      ) as modified_returning,
-      ( 
-        SELECT json_agg(item)
-        FROM (
-          SELECT *
-          FROM ${escapedTableName}
-          ${checkCondition}
-          LIMIT 5
-        ) item
-      ) AS failed_check
+      ) as modified_returning
     FROM ${escapedTableName}
   `;
 
   const allowedFieldKeys = tableHandler.parseFieldFilter(fields);
-  let result: {
-    row_count: number | null;
-    modified: AnyObject[] | null;
-    failed_check: AnyObject[] | null;
-    modified_returning: AnyObject[] | null;
-  };
 
   const queryType = "one";
 
-  const tx = localParams?.tx?.t || tableHandler.tx?.t;
-  if (tx) {
-    result = await tx[queryType](query).catch((err: unknown) =>
-      getClientErrorFromPGError(err, {
-        type: "tableMethod",
-        localParams,
-        view: tableHandler,
-        allowedKeys: allowedFieldKeys,
-        prostgles: tableHandler.dboBuilder.prostgles,
-      }),
-    );
-  } else {
-    result = await tableHandler.db
-      .tx((t) => (t as any)[queryType](query))
-      .catch((err) =>
-        getClientErrorFromPGError(err, {
-          type: "tableMethod",
-          localParams,
-          view: tableHandler,
-          allowedKeys: allowedFieldKeys,
-          prostgles: tableHandler.dboBuilder.prostgles,
-        }),
-      );
-  }
+  const tx = tableHandler.getTransaction(localParams)?.t;
+  const queryPromise: Promise<{
+    row_count: number | null;
+    modified: AnyObject[] | null;
+    failed_check: boolean | null;
+    modified_returning: AnyObject[] | null;
+  }> = tx ? tx[queryType](query) : tableHandler.db.tx((t) => t[queryType](query));
+
+  const result = await queryPromise.catch((err: unknown) =>
+    rejectWithPGClientError(err, {
+      type: "tableMethod",
+      localParams,
+      view: tableHandler,
+      allowedKeys: allowedFieldKeys,
+      prostgles: tableHandler.dboBuilder.prostgles,
+    }),
+  );
 
-  if (checkFilter && result.failed_check?.length) {
+  if (checkFilter && result.failed_check) {
     throw new Error(
       `Insert ${name} records failed the check condition: ${JSON.stringify(checkFilter, null, 2)}`,
     );
   }
 
   const rows = result.modified ?? [];
-  const finalDBtx = tableHandler.getFinalDBtx(localParams);
-  const { postValidate } = rule ?? {};
-  const hooks = tableHandler.getHooksAndChecks(
-    command === "insert" ? { name: command, rule } : { name: command, rule },
-  );
-  let changedFieldsSet = undefined as undefined | Set<string>;
-  const getChangedFieldsSet = () => {
-    changedFieldsSet ??= new Set<string>(
-      (isArray(data) ? data : [data]).map((row) => Object.keys(row)).flat(),
-    );
-    return changedFieldsSet;
-  };
-  const applicableHooks = hooks.filter((hook) => {
-    if (hook.type === "checkFilter") return;
-    if (hook.type === "postValidate") return true;
-    const { commands, changedFields } = hook;
-    return (
-      commands[command] &&
-      (!changedFields || changedFields.some((f) => getChangedFieldsSet().has(f)))
-    );
-  });
-
-  if (postValidate && !localParams) {
-    throw new Error("Unexpected: no localParams for postValidate");
-  }
-
-  if (applicableHooks.length) {
-    if (!finalDBtx) throw new Error("Unexpected: no dbTX for hooks/postValidate");
-
-    for (const row of rows) {
-      const commonParams = {
-        row: row,
-        tx: tx || tableHandler.db,
-        dbx: finalDBtx,
-        command,
-        data,
-      } as const;
-      for (const hook of applicableHooks) {
-        if (hook.type === "afterEach") {
-          await hook.validate({
-            ...commonParams,
-            localParams,
-          });
-        } else if (hook.type === "postValidate") {
-          if (!localParams) throw new Error("Unexpected: no localParams for postValidate");
-          await hook.validate({
-            ...commonParams,
-            localParams,
-          });
-        }
-      }
-    }
 
-    for (const hook of applicableHooks) {
-      if (hook.type === "afterAll") {
-        await hook.validate({
-          tx: tx || tableHandler.db,
-          dbx: finalDBtx,
-          command,
-          data: Array.isArray(data) ? data : [data],
-          rows,
-          localParams,
-        });
-      }
-    }
-  }
+  await executeHooksCheckAndPostValidation({
+    tableHandler,
+    operation: command === "insert" ? { name: "insert", rule } : { name: "update", rule },
+    localParams,
+    rows,
+    data,
+  });
 
   let returnMany = false;
   if (args.command === "update") {
@@ -231,5 +157,3 @@ export const runInsertUpdateQuery = async (args: RunInsertUpdateQueryArgs) => {
 
   return returnMany ? modified_returning : modified_returning?.[0];
 };
-
-const isArray = <T>(data: T): data is Extract<T, readonly unknown[]> => Array.isArray(data);

package/lib/DboBuilder/TableHandler/update.ts

@@ -8,6 +8,7 @@ import { runInsertUpdateQuery } from "./runInsertUpdateQuery";
 import type { TableHandler } from "./TableHandler";
 import { updateFile } from "./updateFile";
 import { getInsertTableRules } from "./insert/getInsertTableRules";
+import { getReturnTypeQuery } from "../ViewHandler/getReturnTypeQuery";
 
 export async function update(
   this: TableHandler,
@@ -20,11 +21,10 @@ export async function update(
   const ACTION = "update";
   const start = Date.now();
   try {
-    /** postValidate */
-    const finalDBtx = this.getFinalDBtx(localParams);
+    const transaction = this.getTransaction(localParams);
     const wrapInTx = () =>
-      this.dboBuilder.getTX((_dbtx) =>
-        (_dbtx[this.name] as Partial<typeof this> | undefined)?.[ACTION]?.(
+      this.dboBuilder.getTX((th) =>
+        (th[this.name] as Partial<typeof this> | undefined)?.[ACTION]?.(
           filter,
           _newData,
           params,
@@ -33,7 +33,7 @@ export async function update(
         ),
       );
     const rule = tableRules?.[ACTION];
-    if (this.shouldWrapInTx({ name: ACTION, rule }, localParams)) {
+    if (this.shouldWrapInTx({ name: ACTION, rule }, localParams).shouldWrap) {
       return wrapInTx();
     }
 
@@ -60,7 +60,6 @@ export async function update(
     const { fields, validateRow, forcedData, returningFields, forcedFilter, filterFields } =
       parsedRules;
     const { removeDisallowedFields = false } = params || {};
-    const { returnQuery = false } = localParams ?? {};
 
     if (params) {
       const good_paramsObj: Record<keyof UpdateParams, 1> = {
@@ -103,18 +102,24 @@ export async function update(
     const nestedInserts = getReferenceColumnInserts(this, nData, true);
     const nestedInsertsResultsObj: Record<string, any> = {};
     if (nestedInserts.length) {
-      const updateCount = await this.count(updateFilter.filter);
+      const updateCount = await this.count(
+        updateFilter.filter,
+        undefined,
+        undefined,
+        tableRules,
+        localParams,
+      );
       if (+updateCount > 1) {
         throw "Cannot do a nestedInsert from an update that targets more than 1 row";
       }
-      if (!finalDBtx) {
+      if (!transaction) {
         return wrapInTx();
       }
       await Promise.all(
         nestedInserts.map(async (nestedInsert) => {
-          const nesedTableHandler = finalDBtx[nestedInsert.tableName];
-          if (!nesedTableHandler)
-            throw `nestedInsert Tablehandler not found for ${nestedInsert.tableName}`;
+          const nestedTableHandler = transaction.dbTX[nestedInsert.tableName];
+          if (!nestedTableHandler)
+            throw `nestedInsert TableHandler not found for ${nestedInsert.tableName}`;
           const refTableRules =
             !localParams ? undefined : (
               await getInsertTableRules(
@@ -133,7 +138,7 @@ export async function update(
               referencingColumn: nestedInsert.insertedFieldName,
             },
           };
-          const nestedInsertResult = (await nesedTableHandler.insert(
+          const nestedInsertResult = (await nestedTableHandler.insert(
             nestedInsert.data,
             { returning: "*" },
             undefined,
@@ -170,7 +175,17 @@ export async function update(
     const queryWithoutUserRLS = query;
     query = withUserRLS(localParams, query);
 
-    if (returnQuery) return query as unknown as void;
+    const queryToReturn = await getReturnTypeQuery({
+      handler: this,
+      localParams,
+      queryWithoutRLS: queryWithoutUserRLS,
+      queryWithRLS: query,
+      returnType: params?.returnType,
+      newQuery: undefined,
+    });
+    if (queryToReturn) {
+      return queryToReturn;
+    }
 
     const result = await runInsertUpdateQuery({
       tableHandler: this,

package/lib/DboBuilder/TableHandler/updateBatch.ts

@@ -2,12 +2,13 @@ import type { AnyObject, UpdateParams } from "prostgles-types";
 import type { ParsedTableRule } from "../../PublishParser/PublishParser";
 import type { Filter, LocalParams } from "../DboBuilder";
 import {
-  getClientErrorFromPGError,
+  rejectWithPGClientError,
   getErrorAsObject,
   getSerializedClientErrorFromPGError,
   withUserRLS,
 } from "../DboBuilder";
 import type { TableHandler } from "./TableHandler";
+import { getReturnTypeQuery } from "../ViewHandler/getReturnTypeQuery";
 
 export async function updateBatch(
   this: TableHandler,
@@ -38,6 +39,18 @@ export async function updateBatch(
     );
     const queries = [withUserRLS(localParams, ""), ...updateQueries];
 
+    const queryToReturn = await getReturnTypeQuery({
+      handler: this,
+      localParams,
+      queryWithoutRLS: queries.slice(1).join(";\n"),
+      queryWithRLS: queries.join(";\n"),
+      returnType: params?.returnType,
+      newQuery: undefined,
+    });
+    if (queryToReturn) {
+      return queryToReturn as unknown[];
+    }
+
     const t = localParams?.tx?.t ?? this.tx?.t;
     if (t) {
       const result = await t.none(queries.join(";\n"));
@@ -54,7 +67,7 @@ export async function updateBatch(
         return t.none(queries.join(";\n"));
       })
       .catch((err) =>
-        getClientErrorFromPGError(err, {
+        rejectWithPGClientError(err, {
           type: "tableMethod",
           localParams,
           view: this,

package/lib/DboBuilder/TableHandler/upsert.ts

@@ -32,8 +32,8 @@ export const upsert = async function (
         });
     };
 
-    /* Do it within a transaction to ensure consisency */
-    if (!this.tx) {
+    /* Do it within a transaction to ensure consistency */
+    if (!this.getTransaction(localParams)) {
       return this.dboBuilder.getTX((dbTX) => _upsert(dbTX[this.name] as TableHandler));
     }
     const result = await _upsert(this);

package/lib/DboBuilder/ViewHandler/ViewHandler.ts

@@ -104,6 +104,14 @@ export class ViewHandler {
     });
   }
 
+  getFinalDBtx = (localParams: LocalParams | undefined) => {
+    return localParams?.tx?.dbTX ?? this.tx?.dbTX;
+  };
+
+  getTransaction = (localParams: LocalParams | undefined) => {
+    return localParams?.tx || this.tx;
+  };
+
   _log = ({
     command,
     data,
@@ -298,20 +306,20 @@ export class ViewHandler {
 
   intersectColumns(
     allowedFields: FieldFilter,
-    dissallowedFields: FieldFilter,
+    disallowedFields: FieldFilter,
     removeDisallowedFields = false,
   ): string[] {
     let result: string[] = [];
     if (allowedFields) {
       result = this.parseFieldFilter(allowedFields);
     }
-    if (dissallowedFields) {
-      const _dissalowed = this.parseFieldFilter(dissallowedFields);
+    if (disallowedFields) {
+      const excludedFields = this.parseFieldFilter(disallowedFields);
 
       if (!removeDisallowedFields) {
-        throw `dissallowed/invalid field found for ${this.name}: `;
+        throw `disallowed/invalid field found for ${this.name}: `;
       }
-      result = result.filter((key) => !_dissalowed.includes(key));
+      result = result.filter((key) => !excludedFields.includes(key));
     }
 
     return result;

package/lib/DboBuilder/ViewHandler/count.ts

@@ -7,6 +7,7 @@ import {
   withUserRLS,
 } from "../dboBuilderUtils";
 import type { ViewHandler } from "./ViewHandler";
+import { getReturnTypeQuery } from "./getReturnTypeQuery";
 
 export async function count(
   this: ViewHandler,
@@ -32,15 +33,29 @@ export async function count(
         returnQuery: "noRLS",
         bypassLimit: true,
       })) as unknown as string;
-      const query = [
-        withUserRLS(localParams, ""),
-        "SELECT COUNT(*)",
-        "FROM (",
-        findQuery,
-        ") t",
-      ].join("\n");
+
+      const queryWithoutUserRLS = `
+        SELECT COUNT(*)
+        FROM ( 
+        ${findQuery}
+        ) t 
+      `;
+      const queryWithRLS = withUserRLS(localParams, queryWithoutUserRLS);
+
+      const queryToReturn = await getReturnTypeQuery({
+        handler: this,
+        localParams,
+        queryWithoutRLS: queryWithoutUserRLS,
+        queryWithRLS,
+        returnType: selectParams?.returnType,
+        newQuery: undefined,
+      });
+      if (queryToReturn) {
+        return queryToReturn as unknown[];
+      }
+
       const handler = this.tx?.t ?? this.db;
-      return handler.one(query).then(({ count }) => +count);
+      return handler.one(queryWithRLS).then(({ count }) => +count);
     });
 
     await this._log({
@@ -49,7 +64,7 @@ export async function count(
       data: { filter },
       duration: Date.now() - start,
     });
-    return result;
+    return result as number;
   } catch (e) {
     await this._log({
       command: "count",

package/lib/DboBuilder/ViewHandler/find.ts

@@ -1,18 +1,16 @@
-import type { SelectParams } from "prostgles-types";
+import type { AnyObject, SelectParams } from "prostgles-types";
 import { isObject } from "prostgles-types";
 import type { ParsedTableRule } from "../../PublishParser/PublishParser";
 import type { Filter, LocalParams } from "../DboBuilder";
 import {
-  getClientErrorFromPGError,
   getErrorAsObject,
   getSerializedClientErrorFromPGError,
+  rejectWithPGClientError,
   withUserRLS,
 } from "../DboBuilder";
 import { getNewQuery } from "../QueryBuilder/getNewQuery";
 import { getSelectQuery } from "../QueryBuilder/getSelectQuery";
-import type { NewQuery } from "../QueryBuilder/QueryBuilder";
-import { canRunSQL } from "../runSql/runSQL";
-import type { TableHandler } from "../TableHandler/TableHandler";
+import { getReturnTypeQuery } from "./getReturnTypeQuery";
 import type { ViewHandler } from "./ViewHandler";
 
 export const find = async function (
@@ -111,36 +109,42 @@ export const find = async function (
     );
 
     const queryWithRLS = withUserRLS(localParams, queryWithoutRLS);
-    // THIS HANGS TESTS
-    // if (testRule) {
-    //   try {
-    //     await this.db.any(withUserRLS(localParams, "EXPLAIN " + queryWithRLS));
-    //     return [];
-    //   } catch (e) {
-    //     console.error(e);
-    //     throw `Internal error: publish config is not valid for publish.${this.name}.select `;
-    //   }
-    // }
-
-    /** Used for subscribe  */
-    if (localParams?.returnNewQuery) return newQuery as unknown as any;
-    if (localParams?.returnQuery) {
-      if (localParams.returnQuery === "where-condition") {
-        return newQuery.whereOpts.condition as any;
-      }
-      return (localParams.returnQuery === "noRLS" ?
-        queryWithoutRLS
-      : queryWithRLS) as unknown as any[];
-    }
-
-    const result = await runQueryReturnType({
+    const queryToReturn = await getReturnTypeQuery({
+      handler: this,
+      localParams,
       queryWithoutRLS,
       queryWithRLS,
       returnType,
-      handler: this,
-      localParams,
       newQuery,
     });
+    if (queryToReturn) {
+      return queryToReturn as unknown[];
+    }
+
+    const query = queryWithRLS;
+    const isOneOrNone = returnType === "row" || returnType === "value";
+    const dbHandler = this.getTransaction(localParams)?.t ?? this.db;
+    const queryPromise =
+      isOneOrNone ?
+        dbHandler.oneOrNone<AnyObject>(query).then((data) => (data ? [data] : []))
+      : dbHandler.any<AnyObject>(query);
+
+    const parsedResult = await queryPromise
+      .then((rows) => {
+        if (returnType === "values" || returnType === "value") {
+          return rows.map((d) => Object.values(d)[0]);
+        }
+
+        return rows;
+      })
+      .catch((err) =>
+        rejectWithPGClientError(err, {
+          type: "tableMethod",
+          localParams,
+          view: this,
+          prostgles: this.dboBuilder.prostgles,
+        }),
+      );
 
     await this._log({
       command,
@@ -148,7 +152,8 @@ export const find = async function (
       data: { filter, selectParams },
       duration: Date.now() - start,
     });
-    return result;
+
+    return isOneOrNone ? parsedResult[0] : parsedResult;
   } catch (e) {
     await this._log({
       command,
@@ -165,68 +170,3 @@ export const find = async function (
     });
   }
 };
-
-type RunQueryReturnTypeArgs = {
-  queryWithRLS: string;
-  queryWithoutRLS: string;
-  returnType: SelectParams["returnType"];
-  handler: ViewHandler | TableHandler;
-  localParams: LocalParams | undefined;
-  newQuery: NewQuery | undefined;
-};
-
-export const runQueryReturnType = async ({
-  newQuery,
-  handler,
-  localParams,
-  queryWithRLS,
-  queryWithoutRLS,
-  returnType,
-}: RunQueryReturnTypeArgs) => {
-  const query = queryWithRLS;
-  const sqlTypes = ["statement", "statement-no-rls", "statement-where"] as const;
-  if (!returnType || returnType === "values") {
-    return handler.dbHandler
-      .any(query)
-      .then((data) => {
-        if (returnType === "values") {
-          return data.map((d) => Object.values(d)[0]);
-        }
-        return data;
-      })
-      .catch((err) =>
-        getClientErrorFromPGError(err, {
-          type: "tableMethod",
-          localParams,
-          view: handler,
-          prostgles: handler.dboBuilder.prostgles,
-        }),
-      );
-  } else if (sqlTypes.some((v) => v === returnType)) {
-    if (!(await canRunSQL(handler.dboBuilder.prostgles, localParams?.clientReq))) {
-      throw `Not allowed:  { returnType: ${JSON.stringify(returnType)} } requires execute sql privileges `;
-    }
-    if (returnType === "statement-no-rls") {
-      return queryWithoutRLS as unknown;
-    }
-    if (returnType === "statement-where") {
-      if (!newQuery) throw `returnType ${returnType} not possible for this command type`;
-      return newQuery.whereOpts.condition as unknown;
-    }
-    return query as unknown as unknown[];
-  } else if (["row", "value"].includes(returnType)) {
-    return handler.dbHandler
-      .oneOrNone(query)
-      .then((data) => {
-        return data && returnType === "value" ? Object.values(data)[0] : data;
-      })
-      .catch((err) =>
-        getClientErrorFromPGError(err, {
-          type: "tableMethod",
-          localParams,
-          view: handler,
-          prostgles: handler.dboBuilder.prostgles,
-        }),
-      );
-  }
-};

package/lib/DboBuilder/ViewHandler/getReturnTypeQuery.ts

@@ -0,0 +1,50 @@
+import type { SelectParams } from "prostgles-types";
+import type { LocalParams } from "../DboBuilder";
+import type { NewQuery } from "../QueryBuilder/QueryBuilder";
+import { canRunSQL } from "../runSql/runSQL";
+import type { TableHandler } from "../TableHandler/TableHandler";
+import type { ViewHandler } from "./ViewHandler";
+
+const sqlTypes = ["statement", "statement-no-rls", "statement-where"] as const;
+
+export const getReturnTypeQuery = async ({
+  handler,
+  returnType,
+  localParams,
+  queryWithRLS,
+  queryWithoutRLS,
+  newQuery,
+}: {
+  handler: TableHandler | ViewHandler;
+  returnType: SelectParams["returnType"];
+  localParams: LocalParams | undefined;
+  queryWithRLS: string;
+  queryWithoutRLS: string;
+  newQuery: NewQuery | undefined;
+}) => {
+  /** Used for subscribe  */
+  if (localParams?.returnNewQuery) {
+    return newQuery;
+  }
+
+  if (returnType === "statement-where" || localParams?.returnQuery === "where-condition") {
+    if (!newQuery) {
+      throw `returnType ${returnType} not possible for this command type`;
+    }
+    return newQuery.whereOpts.condition as unknown;
+  }
+  if (localParams?.returnQuery) {
+    return localParams.returnQuery === "noRLS" ? queryWithoutRLS : queryWithRLS;
+  }
+
+  if (!sqlTypes.some((v) => v === returnType)) {
+    return;
+  }
+  if (!(await canRunSQL(handler.dboBuilder.prostgles, localParams?.clientReq))) {
+    throw `Not allowed:  { returnType: ${JSON.stringify(returnType)} } requires execute sql privileges `;
+  }
+  if (returnType === "statement-no-rls") {
+    return queryWithoutRLS as unknown;
+  }
+  return queryWithRLS as unknown as unknown[];
+};