prostgles-server 4.2.624 → 4.2.625

package/lib/DboBuilder/ViewHandler/getExistsCondition.ts

@@ -1,10 +1,11 @@
-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 { EXISTS_KEY } from "prostgles-types";
+import { EXISTS_KEYS } from "prostgles-types";
 import type { ParsedTableRule } from "../../PublishParser/PublishParser";
-import type { TableHandler } from "../TableHandler/TableHandler";
-import { getTableJoinQuery } from "./getTableJoinQuery";
+import type { ExistsFilterConfig, LocalParams } from "../DboBuilder";
+import { getQuerySourceSQL } from "../QueryBuilder/getQuerySource";
+import { getTableJoinAlias, getTableJoinQuery } from "./getTableJoinQuery";
+import type { ViewHandler } from "./ViewHandler";
+import { prepareWhere } from "./prepareWhere";
 
 export async function getExistsCondition(
   this: ViewHandler,
@@ -25,17 +26,22 @@ export async function getExistsCondition(
     };
   }
 
-  let t2Rules: ParsedTableRule | undefined = undefined,
-    forcedFilter: AnyObject | undefined,
-    filterFields: FieldFilter | undefined;
-
   /* Check if allowed to view data - forcedFilters will bypass this check through isForcedFilterBypass */
   if (localParams?.isRemoteRequest && !localParams.clientReq) {
     throw "Unexpected: localParams isRemoteRequest and missing clientReq";
   }
+
+  let targetTableRules: ParsedTableRule | undefined = undefined;
   const targetTable = eConfig.isJoined ? eConfig.parsedPath.at(-1)!.table : eConfig.targetTable;
-  if (localParams?.clientReq && this.dboBuilder.publishParser) {
-    t2Rules = await this.dboBuilder.publishParser.getValidatedRequestRuleWusr(
+  const tableHandler = this.dboBuilder.dboMap.get(targetTable);
+  if (!tableHandler) {
+    throw `Table handler for ${targetTable} not found`;
+  }
+  if (localParams?.clientReq) {
+    if (!this.dboBuilder.publishParser) {
+      throw "Unexpected: missing publishParser";
+    }
+    targetTableRules = await this.dboBuilder.publishParser.getValidatedRequestRuleWusr(
       {
         tableName: targetTable,
         command: "find",
@@ -44,27 +50,27 @@ export async function getExistsCondition(
       localParams.scope,
     );
 
-    if (!t2Rules.select) throw "Disallowed";
-    ({ forcedFilter, filterFields } = t2Rules.select);
+    if (!targetTableRules.select) throw "Disallowed";
   }
 
-  const tableHandler = this.dboBuilder.dbo[targetTable] as TableHandler;
-  const finalWhere = (
-    await tableHandler.prepareWhere({
-      select: undefined,
-      filter: targetTableFilter,
-      forcedFilter,
-      filterFields,
-      addWhere: false,
-      tableAlias: undefined,
-      localParams,
-      tableRule: t2Rules,
-    })
-  ).where;
+  const targetAlias =
+    eConfig.isJoined ? getTableJoinAlias(targetTable, eConfig.parsedPath.length - 1) : undefined;
+  const whereOpts = await prepareWhere(tableHandler, {
+    select: undefined,
+    selectParams: {},
+    filter: targetTableFilter,
+    forcedFilter: targetTableRules?.select?.forcedFilter,
+    filterFields: targetTableRules?.select?.filterFields,
+    tableRule: targetTableRules,
+    addWhere: false,
+    tableAlias: targetAlias,
+    localParams,
+  });
+  const { source: targetSource, where: finalWhere } = whereOpts;
 
   let innerQuery = [
     `SELECT 1`,
-    `FROM ${asName(targetTable)}`,
+    `FROM ${getQuerySourceSQL(targetSource)}`,
     `${finalWhere ? `WHERE ${finalWhere}` : ""}`,
   ].join("\n");
 
@@ -74,6 +80,7 @@ export async function getExistsCondition(
       rootTableAlias: rootTableAlias ?? rootTable,
       type: "EXISTS",
       finalWhere,
+      finalTableExpression: targetSource.expression,
     });
     innerQuery = query;
   }

package/lib/DboBuilder/ViewHandler/getTableJoinQuery.ts

@@ -1,10 +1,12 @@
 import { asName } from "prostgles-types";
+import type { PGIdentifier } from "../DboBuilder";
 import type { ParsedJoinPath } from "./parseJoinPath";
 
 type getTableJoinsArgs = {
   rootTableAlias: string;
   type: "INNER" | "LEFT" | "EXISTS";
   finalWhere?: string;
+  finalTableExpression?: string;
   path: ParsedJoinPath[];
 };
 export const getTableJoinQuery = ({
@@ -12,14 +14,14 @@ export const getTableJoinQuery = ({
   type,
   rootTableAlias,
   finalWhere,
+  finalTableExpression,
 }: getTableJoinsArgs): { targetAlias: string; query: string } => {
   const [firstPath] = path;
   if (!firstPath) {
     throw `Cannot create join query for empty path`;
   }
-  const aliasSufix = "jd";
   const getTableAlias = (table: string, pathIndex: number) =>
-    asName(`${aliasSufix}_${pathIndex}_${table}`);
+    getTableJoinAlias(table, pathIndex).escaped;
 
   const query = path
     .map(({ table, on }, i) => {
@@ -45,19 +47,19 @@ export const getTableJoinQuery = ({
        */
       const whereJoinCondition =
         isLast && isExists ?
-          `WHERE (${getJoinOnCondition({
-            on: firstPath.on,
-            leftAlias: rootTableAlias,
-            rightAlias: getTableAlias(firstPath.table, 0),
-          })})`
+          `WHERE (${[
+            getJoinOnCondition({
+              on: firstPath.on,
+              leftAlias: rootTableAlias,
+              rightAlias: getTableAlias(firstPath.table, 0),
+            }),
+            finalWhere,
+          ]
+            .filter(Boolean)
+            .join(") AND (")})`
         : "";
 
-      const tableSelect =
-        isExists && isLast ?
-          [`(`, ` SELECT *`, ` FROM ${tableName}`, finalWhere ? `  WHERE ${finalWhere}` : "", `)`]
-            .filter((v) => v)
-            .join("\n")
-        : tableName;
+      const tableSelect = isLast ? (finalTableExpression ?? tableName) : tableName;
       if (isExists && isFirst) {
         return [`SELECT 1`, `FROM ${tableSelect} ${tableAlias}`, whereJoinCondition]
           .filter((v) => v)
@@ -76,6 +78,12 @@ export const getTableJoinQuery = ({
   };
 };
 
+export const getTableJoinAlias = (table: string, pathIndex: number): PGIdentifier => {
+  const prefix = "jd";
+  const raw = `${prefix}_${pathIndex}_${table}`;
+  return { raw, escaped: asName(raw) };
+};
+
 type GetJoinOnConditionArgs = {
   on: Record<string, string>[];
   leftAlias: string;
@@ -95,7 +103,7 @@ export const getJoinOnConditions = ({
       .map(([leftCol, rightCol]) => {
         return `${leftAlias}.${getLeftColName(leftCol)} = ${rightAlias}.${getRightColName(rightCol)}`;
       })
-      .join(" AND ")
+      .join(" AND "),
   );
 };
 

package/lib/DboBuilder/ViewHandler/prepareWhere.ts

@@ -1,9 +1,10 @@
-import type { AnyObject, FieldFilter } from "prostgles-types/dist";
+import type { AnyObject, FieldFilter, SelectParams } from "prostgles-types/dist";
 import { getKeys, isDefined, isObject } from "prostgles-types/dist";
 import type { ParsedTableRule } from "../../PublishParser/PublishParser";
 import type { ExistsFilterConfig, Filter, LocalParams, PGIdentifier } from "../DboBuilder";
 import { getCondition } from "../getCondition";
 import { type SelectItemValidated } from "../QueryBuilder/QueryBuilder";
+import { getQuerySource, type QuerySource } from "../QueryBuilder/getQuerySource";
 import type { ViewHandler } from "./ViewHandler";
 
 export type PrepareWhereParams = {
@@ -16,46 +17,61 @@ export type PrepareWhereParams = {
   localParams: LocalParams | undefined;
   tableRule: ParsedTableRule | undefined;
   isHaving?: boolean;
+  selectParams?: SelectParams;
 };
 
-export async function prepareWhere(
-  this: ViewHandler,
-  params: PrepareWhereParams,
-): Promise<{
+export type WhereOptions = {
   columnsUsed: string[];
   condition: string;
   where: string;
   filter: AnyObject;
   exists: ExistsFilterConfig[];
-}> {
-  const {
+  source: QuerySource;
+};
+
+export const prepareWhere = async (
+  viewHandler: ViewHandler,
+  {
     filter,
     select,
     forcedFilter,
-    filterFields: ff,
     addWhere: addKeywords = true,
     tableAlias,
     localParams,
     tableRule,
-  } = params;
-  const { $and: $and_key, $or: $or_key } = this.dboBuilder.prostgles.keywords;
+    /* Local update allow all. TODO: tidy all calls */
+    filterFields = !tableRule ? "*" : undefined,
+    isHaving,
+    selectParams,
+  }: PrepareWhereParams,
+): Promise<WhereOptions> => {
+  const { $and: $and_key, $or: $or_key } = viewHandler.dboBuilder.prostgles.keywords;
+
+  if (localParams?.isRemoteRequest && !tableRule) {
+    throw "Unexpected: localParams isRemoteRequest and missing tableRule";
+  }
 
-  let filterFields = ff;
-  /* Local update allow all. TODO -> FIX THIS */
-  if (!ff && !tableRule) filterFields = "*";
+  const source = await getQuerySource(
+    viewHandler,
+    selectParams ? tableRule : undefined,
+    filter ?? {},
+    selectParams ?? {},
+    tableAlias,
+  );
 
   const exists: ExistsFilterConfig[] = [];
 
   type FilterItemResult = { condition: string; columnsUsed: string[] };
   const parseFullFilter = async (
-    f: any,
+    fullFilter: any,
     parentFilter: AnyObject | null = null,
     isForcedFilterBypass: boolean,
   ): Promise<FilterItemResult | undefined> => {
-    if (!f) throw "Invalid/missing group filter provided";
-    if (!isObject(f)) throw "\nInvalid filter\nExpecting an object but got -> " + JSON.stringify(f);
+    if (!fullFilter) throw "Invalid/missing group filter provided";
+    if (!isObject(fullFilter))
+      throw "\nInvalid filter\nExpecting an object but got -> " + JSON.stringify(fullFilter);
 
-    const keys = getKeys(f);
+    const keys = getKeys(fullFilter);
     if (!keys.length) {
       return;
     }
@@ -66,8 +82,8 @@ export async function prepareWhere(
         throw "group filter ($and/$or) can only be placed at the root or within another group filter";
     }
 
-    const { [$and_key]: $and, [$or_key]: $or } = f,
-      group: AnyObject[] | undefined = $and || $or;
+    const { [$and_key]: $and, [$or_key]: $or } = fullFilter;
+    const group = ($and || $or) as AnyObject[] | undefined;
 
     if (group && group.length) {
       const operand = $and ? " AND " : " OR ";
@@ -82,20 +98,24 @@ export async function prepareWhere(
       if (conditionItems.length) {
         const conditions = conditionItems.map((c) => c.condition);
         const columnsUsed = conditionItems.map((c) => c.columnsUsed).flat();
-        if (conditions.length === 1) return { columnsUsed, condition: conditions.join(operand) };
-        else return { columnsUsed, condition: ` ( ${conditions.sort().join(operand)} ) ` };
+        if (conditions.length === 1) {
+          return { columnsUsed, condition: conditions.join(operand) };
+        }
+        return { columnsUsed, condition: ` ( ${conditions.sort().join(operand)} ) ` };
       }
     } else if (!group) {
       /** forcedFilters do not get checked against publish and are treated as server-side requests */
-      const itemInfo = await getCondition.bind(this)({
-        filter: { ...f },
+      const itemInfo = await getCondition.bind(viewHandler)({
+        filter: { ...fullFilter },
         select,
         allowed_colnames:
-          isForcedFilterBypass ? this.column_names.slice(0) : this.parseFieldFilter(filterFields),
-        tableAlias,
+          isForcedFilterBypass ?
+            viewHandler.column_names.slice(0)
+          : viewHandler.parseFieldFilter(filterFields),
+        tableAlias: source.alias,
         localParams: isForcedFilterBypass ? undefined : localParams,
         tableRules: isForcedFilterBypass ? undefined : tableRule,
-        isHaving: params.isHaving,
+        isHaving,
       });
       exists.push(...itemInfo.exists);
       return {
@@ -135,5 +155,6 @@ export async function prepareWhere(
     where: combinedConditions || "",
     filter: finalFilter,
     exists,
+    source,
   };
-}
+};

package/lib/DboBuilder/getCondition.ts

@@ -1,4 +1,4 @@
-import { pickKeys } from "prostgles-types";
+import { pickKeys, type AnyObject } from "prostgles-types";
 import { parseFilterItem } from "../Filtering/Filtering";
 import type { ParsedTableRule } from "../PublishParser/PublishParser";
 import type { ExistsFilterConfig, LocalParams, PGIdentifier } from "./DboBuilder";
@@ -9,6 +9,7 @@ import type { ViewHandler } from "./ViewHandler/ViewHandler";
 import { getExistsCondition } from "./ViewHandler/getExistsCondition";
 import { getExistsFilters } from "./ViewHandler/getExistsFilters";
 import { parseComplexFilter } from "./ViewHandler/parseComplexFilter";
+import { isArray } from "../utils/utils";
 
 const FILTER_FUNCS = FUNCTIONS.filter((f) => f.canBeUsedForFilter);
 
@@ -21,7 +22,7 @@ const FILTER_FUNCS = FUNCTIONS.filter((f) => f.canBeUsedForFilter);
 export async function getCondition(
   this: ViewHandler,
   params: {
-    filter: any;
+    filter: AnyObject;
     select: SelectItemValidated[] | undefined;
     allowed_colnames: string[];
     tableAlias?: PGIdentifier;
@@ -44,21 +45,21 @@ export async function getCondition(
 
   const existsConfigs = getExistsFilters(filter, this);
 
-  const funcConds: string[] = [];
+  const functionConditions: string[] = [];
   const funcFilter = FILTER_FUNCS.filter((f) => f.name in filter);
 
   funcFilter.map((f) => {
     const funcArgs = filter[f.name];
-    if (!Array.isArray(funcArgs)) {
+    if (!isArray(funcArgs)) {
       throw `A function filter must contain an array. E.g: { $funcFilterName: ["col1"] } \n but got: ${JSON.stringify(pickKeys(filter, [f.name]))} `;
     }
     const fields = this.parseFieldFilter(f.getFields(funcArgs), true, allowed_colnames);
 
-    const dissallowedCols = fields.filter((fname) => !allowed_colnames.includes(fname));
-    if (dissallowedCols.length) {
-      throw `Invalid/disallowed columns found in function filter: ${dissallowedCols}`;
+    const disallowedCols = fields.filter((fname) => !allowed_colnames.includes(fname));
+    if (disallowedCols.length) {
+      throw `Invalid/disallowed columns found in function filter: ${disallowedCols}`;
     }
-    funcConds.push(
+    functionConditions.push(
       f.getQuery({
         args: funcArgs,
         allColumns: this.columns,
@@ -84,7 +85,7 @@ export async function getCondition(
   const p = this.getValidatedRules(tableRules, localParams);
   const computedFields = p.allColumns.filter((c) => c.type === "computed");
   const computedColConditions: string[] = [];
-  Object.keys(filter || {}).map((key) => {
+  Object.keys(filter).map((key) => {
     const compCol = computedFields.find((cf) => cf.name === key);
     if (compCol) {
       if (!p.select) throw new Error("Computed column filter requires p.select.fields");
@@ -231,7 +232,7 @@ export async function getCondition(
   let templates: string[] = q?.condition ? [q.condition] : [];
 
   if (existsCond) templates.push(existsCond);
-  templates = templates.concat(funcConds);
+  templates = templates.concat(functionConditions);
   templates = templates.concat(computedColConditions);
   templates = templates.concat(complexFilters);
 

package/lib/DboBuilder/getSubscribeRelatedTables.ts

@@ -8,6 +8,7 @@ import type { TableHandler } from "./TableHandler/TableHandler";
 import type { ViewHandler } from "./ViewHandler/ViewHandler";
 import { getViewRelatedTables } from "./ViewRelatedTables/getViewRelatedTables";
 import type { AddTriggerParams } from "../PubSubManager/addTrigger";
+import { prepareWhere } from "./ViewHandler/prepareWhere";
 
 type Args = {
   selectParams: Omit<SubscribeParams, "throttle">;
@@ -66,9 +67,9 @@ export async function getSubscribeRelatedTables(
         isEmpty(targetTableFilter) ? reversedJoinFilter : (
           { $and: [targetTableFilter, reversedJoinFilter] }
         );
-      const joinConditionInfo = await relatedTableOrViewHandler.prepareWhere({
-        select: undefined,
+      const joinConditionInfo = await prepareWhere(relatedTableOrViewHandler, {
         filter,
+        select: undefined,
         addWhere: false,
         localParams: undefined,
         tableRule: undefined,

package/lib/DboBuilder/parseUpdateRules.ts

@@ -9,6 +9,7 @@ import { type ParsedTableRule } from "../PublishParser/PublishParser";
 import type { Filter, LocalParams } from "./DboBuilder";
 import { prepareNewData } from "./TableHandler/DataValidator";
 import type { TableHandler } from "./TableHandler/TableHandler";
+import { prepareWhere } from "./ViewHandler/prepareWhere";
 
 /**
  * 1) Check if publish is valid
@@ -57,7 +58,7 @@ export async function parseUpdateRules(
       throw ` Invalid update rule fo r ${this.name}. fields missing `;
     }
     finalUpdateFilter = (
-      await this.prepareWhere({
+      await prepareWhere(this, {
         select: undefined,
         filter,
         forcedFilter,
@@ -77,7 +78,7 @@ export async function parseUpdateRules(
           /**
            * Validated filter and fields
            */
-          const condition = await this.prepareWhere({
+          const condition = await prepareWhere(this, {
             select: undefined,
             filterFields: this.column_names,
             filter: dfRule.filter,

package/lib/Prostgles.ts

@@ -320,6 +320,7 @@ export class Prostgles {
       this.dboBuilder = await DboBuilder.create(this);
     }
     this.dbo = this.dboBuilder.dbo;
+    if (this.publishParser) this.initPublishParser();
     await this.opts.onLog?.({
       type: "debug",
       command: "refreshDBO.end",

package/lib/ProstglesContext.spec.ts

@@ -2,6 +2,7 @@ import assert from "node:assert";
 import { describe, test } from "node:test";
 import type { DboBuilder } from "./DboBuilder/DboBuilder";
 import { Prostgles } from "./Prostgles";
+import type { PublishParser } from "./PublishParser/PublishParser";
 
 void describe("Prostgles context", async () => {
   await test("recreates context and runs cleanups in reverse order", async () => {
@@ -47,6 +48,35 @@ void describe("Prostgles context", async () => {
     assert.equal(prostgles.context, undefined);
   });
 
+  await test("recreates the publish parser with the rebuilt DBO", async () => {
+    const prostgles = new Prostgles({
+      dbConnection: "postgres://unused",
+      onReady: () => {},
+    });
+    prostgles.db = {} as typeof prostgles.db;
+    const rebuiltDbo = {};
+    const dboBuilder = {
+      build: () => {
+        dboBuilder.dbo = rebuiltDbo;
+        return Promise.resolve();
+      },
+      dbo: {},
+      sql: {},
+      tables: [],
+    };
+    prostgles.dboBuilder = dboBuilder as unknown as DboBuilder;
+
+    // PublishParser captures the DBO on construction, so it must be recreated after a rebuild.
+    const initialPublishParser = {} as PublishParser;
+    prostgles.publishParser = initialPublishParser;
+
+    await prostgles.rebuildDBO();
+
+    assert.equal(prostgles.dbo, rebuiltDbo);
+    assert.notEqual(prostgles.publishParser, initialPublishParser);
+    assert.equal(prostgles.publishParser.dbo, prostgles.dbo);
+  });
+
   await test("cleans partially-created context after an error", async () => {
     const events: string[] = [];
     const prostgles = new Prostgles({

package/lib/PublishParser/PublishParser.ts

@@ -6,6 +6,7 @@ import {
 } from "prostgles-types";
 import { getClientRequestIPsInfo } from "../Auth/AuthHandler";
 import type { AuthClientRequest, AuthResultWithSID, SessionUser } from "../Auth/AuthTypes";
+import { getAuditTableRules } from "../Audit/getAuditTableRules";
 import type { DBOFullyTyped } from "../DBSchemaBuilder/DBSchemaBuilder";
 import type { DB, DBHandlerServer, Prostgles } from "../Prostgles";
 import { getClientHandlers } from "../WebsocketAPI/getClientHandlers";
@@ -305,16 +306,40 @@ export class PublishParser {
     if (!tableHandler) {
       throw "INTERNAL ERROR: table handler not found for " + tableName;
     }
-    const publishRulesExcludingFileTable = await this.getParsedPublishTable({
-      clientReq,
-      tableName,
-      clientInfo,
-      resolvedPublishObject: overriddenPublish,
-    });
+    const audit = this.prostgles.resolvedAuditConfig;
+    const isAuditTable = audit?.tableName === tableName;
+    const resolvedPublishObject =
+      overriddenPublish ??
+      (isAuditTable && clientReq ?
+        await this.getPublishObjectForUser(clientReq, clientInfo)
+      : undefined);
+    const publishRulesExcludingInferredTables =
+      await this.getParsedPublishTable({
+        clientReq,
+        tableName,
+        clientInfo,
+        resolvedPublishObject,
+      });
+    if (audit && isAuditTable) {
+      const auditTableRules = await getAuditTableRules.bind(this)(
+        audit,
+        publishRulesExcludingInferredTables,
+        clientReq,
+        clientInfo,
+        scope,
+        resolvedPublishObject,
+      );
+      return applyScopeToTableRules(
+        tableName,
+        tableHandler,
+        parsePublishTableRule(auditTableRules),
+        scope,
+      );
+    }
     if (this.dbo[tableName]?.is_media) {
       const { rules: fileTableRules } = await getFileTableRules.bind(this)(
         tableName,
-        publishRulesExcludingFileTable,
+        publishRulesExcludingInferredTables,
         clientReq,
         clientInfo,
         scope,
@@ -331,7 +356,7 @@ export class PublishParser {
     return applyScopeToTableRules(
       tableName,
       tableHandler,
-      parsePublishTableRule(publishRulesExcludingFileTable),
+      parsePublishTableRule(publishRulesExcludingInferredTables),
       scope,
     );
   }

package/lib/PublishParser/applyScopeToTableRules.ts

@@ -1,4 +1,4 @@
-import { getObjectEntries, isDefined, isEmpty } from "prostgles-types";
+import { fromEntries, getObjectEntries, isDefined, isEmpty } from "prostgles-types";
 import type { TableHandler } from "../DboBuilder/TableHandler/TableHandler";
 import { type ParsedTableRule, type PermissionScope } from "./PublishParser";
 export const applyScopeToTableRules = (
@@ -68,9 +68,3 @@ export const applyScopeToTableRules = (
   ) as ParsedTableRule;
   return result;
 };
-
-export const fromEntries = <K extends string | number | symbol, V>(
-  entries: readonly (readonly [K, V])[],
-): Record<K, V> => {
-  return Object.fromEntries(entries) as Record<K, V>;
-};

package/lib/PublishParser/getPublishedTableNames.ts

@@ -1,3 +1,4 @@
+import { isObject } from "prostgles-types";
 import type { PublishParser } from "./PublishParser";
 import { type PublishObject } from "./PublishParser";
 
@@ -30,5 +31,26 @@ export const getPublishedTableNames = (
       tableNames.unshift(fileTableName);
     }
   }
+
+  const audit = publishParserInstance.prostgles.resolvedAuditConfig;
+  const publishedFileTableName =
+    fileTableName && tableNames.includes(fileTableName) ?
+      fileTableName
+    : undefined;
+  if (
+    audit &&
+    !tableNames.includes(audit.tableName) &&
+    Object.keys(audit.tables).some((tableName) => {
+      const rule = publishObject[tableName];
+      return (
+        tableName === publishedFileTableName ||
+        rule === "*" ||
+        rule === true ||
+        (isObject(rule) && Boolean(rule.select))
+      );
+    })
+  ) {
+    tableNames.unshift(audit.tableName);
+  }
   return tableNames;
 };

package/lib/PublishParser/publishTypesAndUtils.ts

@@ -228,11 +228,6 @@ export type SelectRule<Cols extends AnyObject = AnyObject, S extends DBSchema |
    * */
   filterFields?: FieldFilter<Cols>;
 
-  /**
-   * Validation logic to check/update data for each request
-   */
-  validate?(args: SelectRequestData): SelectRequestData | Promise<SelectRequestData>;
-
   subscribeThrottle?: number;
 
   disableMethods?: Partial<Record<"sync" | "subscribe", 1>>;

package/lib/TableConfig/getColumnSQLDefinitionQuery.ts

@@ -1,8 +1,14 @@
 import type pgPromise from "pg-promise";
-import { asName, getObjectEntries, isObject, pickKeys, type JSONB } from "prostgles-types";
+import {
+  asName,
+  fromEntries,
+  getObjectEntries,
+  isObject,
+  pickKeys,
+  type JSONB,
+} from "prostgles-types";
 import { VALIDATE_SCHEMA_FUNCNAME } from "../JSONBSchemaValidation/validateJSONBSchemaSQL";
 import type { DB } from "../Prostgles";
-import { fromEntries } from "../PublishParser/applyScopeToTableRules";
 import { asValue } from "../PubSubManager/PubSubManagerUtils";
 import type { BaseColumnTypes, ColumnConfig } from "./TableConfigTypes";
 

package/lib/index.ts

@@ -56,6 +56,7 @@ export type { FileTableRow } from "./StorageClient/getFileTableConfig";
 export { defineJoin };
 export {
   AUDIT_TABLE_COLUMN_DEFINITIONS,
+  AUDIT_TABLE_COLUMN_NAMES,
   AUDIT_TABLE_COLUMNS,
   type AuditTableRow,
 } from "./Audit/AuditTable";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-server",
-  "version": "4.2.624",
+  "version": "4.2.625",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",