prostgles-server 4.2.623 → 4.2.625

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

@@ -1,9 +1,14 @@
-import { getObjectEntries, includes, SQL_COMMAND_TABLE_METHODS } from "prostgles-types";
+import {
+  getObjectEntries,
+  includes,
+  SQL_COMMAND_TABLE_METHODS,
+  type TableSchema,
+} 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 type { ProstglesInitOptions } from "../ProstglesTypes";
 import { getClientHandlers } from "../WebsocketAPI/getClientHandlers";
 import { applyScopeToTableRules } from "./applyScopeToTableRules";
 import type {
@@ -12,15 +17,18 @@ import type {
   UnrestrictedFunctionContext,
 } from "./defineServerFunction";
 import { getFileTableRules } from "./getFileTableRules";
+import { getPublishedObjectFromResult } from "./getPublishedObjectFromResult";
 import { getSchemaFromPublish } from "./getSchemaFromPublish";
-import { getTableRulesWithoutFileTable } from "./getTableRulesWithoutFileTable";
+import { getParsedPublishTable } from "./getParsedPublishTable";
 import type {
   DboTable,
   DboTableCommand,
   ParsedTableRule,
+  Publish,
   PublishParams,
 } from "./publishTypesAndUtils";
 import {
+  isPublishProfiles,
   parsePublishTableRule,
   type PermissionScope,
   type PublishObject,
@@ -28,9 +36,7 @@ import {
 import { validatePublishProfiles } from "./validatePublishProfiles";
 
 export class PublishParser {
-  publish:
-    | Exclude<ProstglesInitOptions<void, SessionUser, any>["publish"], unknown[]>
-    | ReturnType<typeof validatePublishProfiles>;
+  parsedPublish: ReturnType<typeof getParsedPublish>;
   publishRawSQL?: any;
   dbo: DBHandlerServer;
   db: DB;
@@ -39,7 +45,8 @@ export class PublishParser {
   constructor(prostgles: Prostgles) {
     this.prostgles = prostgles;
     const { publish } = prostgles.opts;
-    this.publish = Array.isArray(publish) ? validatePublishProfiles(publish) : publish;
+
+    this.parsedPublish = getParsedPublish(publish, prostgles.dboBuilder.tablesOrViews ?? []);
 
     // eslint-disable-next-line @typescript-eslint/unbound-method
     this.publishRawSQL = prostgles.opts.publishRawSQL;
@@ -145,50 +152,54 @@ export class PublishParser {
   /**
    * Parses the first level of publish. (If false then nothing if * then all tables and views)
    */
-  async getPublishObject(
+  async getPublishObjectForUser(
     clientReq: AuthClientRequest,
     clientInfo: AuthResultWithSID | undefined,
   ): Promise<PublishObject | undefined> {
     const publishParams = await this.getPublishParams(clientReq, clientInfo);
 
-    const result = await applyParamsIfFunc(this.publish, publishParams);
-    const publish =
-      Array.isArray(result) ?
-        validatePublishProfiles(result).find((profile) =>
-          publishParams.user ? profile.userTypes.includes(publishParams.user.type) : false,
-        )?.publish
-      : result;
-
-    if (publish === "*") {
-      const publish: PublishObject = {};
-      this.prostgles.dboBuilder.tablesOrViews?.map((tov) => {
-        publish[tov.name] = "*";
-      });
-      return publish;
-    }
+    const parsedPublish = await applyParamsIfFunc(this.parsedPublish, publishParams);
 
-    return publish || undefined;
+    const publishResult = (() => {
+      if (!isPublishProfiles(parsedPublish)) {
+        return parsedPublish;
+      }
+
+      const { user } = publishParams;
+      if (!user) return;
+      return parsedPublish.find(({ userTypes }) => userTypes.includes(user.type))?.publish;
+    })();
+
+    if (!publishResult) return;
+
+    const publishedObject = getPublishedObjectFromResult(
+      publishResult,
+      this.prostgles.dboBuilder.tablesOrViews ?? [],
+      publishParams,
+    );
+    return publishedObject;
   }
 
   async getValidatedRequestRuleWusr(
     { tableName, command, clientReq }: DboTableCommand,
     scope: PermissionScope | undefined,
   ): Promise<ParsedTableRule> {
-    const rules = await this.getParsedTableRule({ tableName, clientReq }, undefined, scope);
     const clientInfo =
       clientReq && (await this.prostgles.authHandler.getSidAndUserFromRequest(clientReq));
     if (clientInfo === "new-session-redirect") {
       throw "new-session-redirect";
     }
+    const rules = await this.getParsedTableRule({ tableName, clientReq, scope, clientInfo });
     this.validateRequestRule({ tableName, command, clientReq }, rules, scope);
     return rules;
   }
 
-  async getParsedTableRule(
-    { tableName, clientReq }: Pick<DboTableCommand, "tableName" | "clientReq">,
-    clientInfo: AuthResultWithSID | undefined,
-    scope: PermissionScope | undefined,
-  ): Promise<ParsedTableRule> {
+  async getParsedTableRule({
+    tableName,
+    clientReq,
+    clientInfo,
+    scope,
+  }: Omit<TableRequest, "resolvedPublishObject">): Promise<ParsedTableRule> {
     if (!tableName) throw "tableName missing";
 
     /* Must be local request -> allow everything */
@@ -202,7 +213,7 @@ export class PublishParser {
     }
 
     /* Must be from socket. Must have a publish */
-    if (!this.publish) throw "publish is missing";
+    if (!this.parsedPublish) throw "publish is missing";
 
     const tableErrors = clientReq.socket?.prostgles?.get(this.prostgles.appId)?.tableSchemaErrors[
       tableName
@@ -212,7 +223,13 @@ export class PublishParser {
       throw errorInfo.error;
     });
 
-    const tableRule = await this.getTableRules({ tableName, clientReq }, clientInfo, scope);
+    const tableRule = await this.getTableRules({
+      tableName,
+      clientReq,
+      clientInfo,
+      scope,
+      resolvedPublishObject: undefined,
+    });
 
     if (!tableRule) {
       throw {
@@ -278,27 +295,52 @@ export class PublishParser {
     }
   }
 
-  async getTableRules(
-    args: DboTable,
-    clientInfo: AuthResultWithSID | undefined,
-    scope: PermissionScope | undefined,
-    overriddenPublish?: PublishObject,
-  ): Promise<ParsedTableRule | undefined> {
-    const { tableName } = args;
+  async getTableRules({
+    resolvedPublishObject: overriddenPublish,
+    scope,
+    clientInfo,
+    clientReq,
+    tableName,
+  }: TableRequest): Promise<ParsedTableRule | undefined> {
     const tableHandler = this.dbo[tableName];
     if (!tableHandler) {
-      throw "INTERNAL ERROR: table handler not found for " + args.tableName;
+      throw "INTERNAL ERROR: table handler not found for " + tableName;
     }
-    const fileTablePublishRules = await this.getTableRulesWithoutFileTable(
-      args,
-      clientInfo,
-      overriddenPublish,
-    );
-    if (this.dbo[args.tableName]?.is_media) {
+    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)(
-        args.tableName,
-        fileTablePublishRules,
-        args.clientReq,
+        tableName,
+        publishRulesExcludingInferredTables,
+        clientReq,
         clientInfo,
         scope,
         overriddenPublish,
@@ -314,17 +356,32 @@ export class PublishParser {
     return applyScopeToTableRules(
       tableName,
       tableHandler,
-      parsePublishTableRule(fileTablePublishRules),
+      parsePublishTableRule(publishRulesExcludingInferredTables),
       scope,
     );
   }
 
-  getTableRulesWithoutFileTable = getTableRulesWithoutFileTable.bind(this);
+  getParsedPublishTable = getParsedPublishTable.bind(this);
 
   /* Prepares schema for client. Only allowed views and commands will be present */
   getSchemaFromPublish = getSchemaFromPublish.bind(this);
 }
 
+const getParsedPublish = (publish: Publish | undefined, tablesOrViews: TableSchema[]) => {
+  if (!publish) return;
+  return (
+    isPublishProfiles(publish) ? validatePublishProfiles(publish)
+    : typeof publish === "function" ? publish
+    : getPublishedObjectFromResult(publish, tablesOrViews, undefined)
+  );
+};
+
+export type TableRequest = DboTable & {
+  clientInfo: AuthResultWithSID | undefined;
+  scope: PermissionScope | undefined;
+  resolvedPublishObject: PublishObject | undefined;
+};
+
 export * from "./publishTypesAndUtils";
 
 type FunctionWithArguments = (...args: any) => any;

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/getFileTableRules.ts

@@ -20,8 +20,8 @@ export async function getFileTableRules(
   fileTablePublishRules: ParsedPublishTable | undefined,
   clientReq: AuthClientRequest | undefined,
   clientInfo: AuthResultWithSID | undefined,
-  scope: LocalParams["scope"],
-  overriddenPublish?: PublishObject,
+  scope: LocalParams["scope"] | undefined,
+  resolvedPublishObject: PublishObject | undefined,
 ) {
   const forcedDeleteFilters: FullFilter<AnyObject, void>[] = [];
   const forcedSelectFilters: FullFilter<AnyObject, void>[] = [];
@@ -43,51 +43,58 @@ export async function getFileTableRules(
     .filter(isDefined);
   if (referencedColumns?.length) {
     for (const { tableName, fileColumns, allColumns } of referencedColumns) {
-      const tableRules = await this.getTableRules({ clientReq, tableName }, clientInfo, scope, overriddenPublish);
-      if (tableRules) {
-        fileColumns.map((column) => {
-          const path = [{ table: tableName, on: [{ id: column }] }];
-          if (tableRules.delete) {
-            forcedDeleteFilters.push({
+      const tableRules = await this.getTableRules({
+        clientReq,
+        tableName,
+        clientInfo,
+        scope,
+        resolvedPublishObject,
+      });
+      if (!tableRules) {
+        continue;
+      }
+      fileColumns.map((column) => {
+        const path = [{ table: tableName, on: [{ id: column }] }];
+        if (tableRules.delete) {
+          forcedDeleteFilters.push({
+            $existsJoined: {
+              path,
+              filter: tableRules.delete.forcedFilter ?? {},
+            },
+          });
+        }
+        if (tableRules.select) {
+          const parsedFields = parseFieldFilter(tableRules.select.fields, false, allColumns);
+          /** Must be allowed to view this column */
+          if (includes(parsedFields, column)) {
+            forcedSelectFilters.push({
               $existsJoined: {
                 path,
-                filter: tableRules.delete.forcedFilter ?? {},
+                filter: tableRules.select.forcedFilter ?? {},
               },
             });
           }
-          if (tableRules.select) {
-            const parsedFields = parseFieldFilter(tableRules.select.fields, false, allColumns);
-            /** Must be allowed to view this column */
-            if (includes(parsedFields, column)) {
-              forcedSelectFilters.push({
-                $existsJoined: {
-                  path,
-                  filter: tableRules.select.forcedFilter ?? {},
-                },
-              });
-            }
-          }
-          if (tableRules.insert) {
-            const parsedFields = parseFieldFilter(tableRules.insert.fields, false, allColumns);
-            /** Must be allowed to view this column */
-            if (includes(parsedFields, column)) {
-              allowedNestedInserts.push({ table: tableName, column });
-            }
+        }
+        if (tableRules.insert) {
+          const parsedFields = parseFieldFilter(tableRules.insert.fields, false, allColumns);
+          /** Must be allowed to view this column */
+          if (includes(parsedFields, column)) {
+            allowedNestedInserts.push({ table: tableName, column });
           }
-          if (tableRules.update) {
-            const parsedFields = parseFieldFilter(tableRules.update.fields, false, allColumns);
-            /** Must be allowed to view this column */
-            if (includes(parsedFields, column)) {
-              forcedUpdateFilters.push({
-                $existsJoined: {
-                  path,
-                  filter: tableRules.update.forcedFilter ?? {},
-                },
-              });
-            }
+        }
+        if (tableRules.update) {
+          const parsedFields = parseFieldFilter(tableRules.update.fields, false, allColumns);
+          /** Must be allowed to view this column */
+          if (includes(parsedFields, column)) {
+            forcedUpdateFilters.push({
+              $existsJoined: {
+                path,
+                filter: tableRules.update.forcedFilter ?? {},
+              },
+            });
           }
-        });
-      }
+        }
+      });
     }
   }
 
@@ -137,11 +144,11 @@ export async function getFileTableRules(
     };
   }
 
-  /** Add missing implied methods (getColumns, getInfo) */
-  const rules = await this.getTableRulesWithoutFileTable.bind(this)(
-    { clientReq, tableName: fileTableName },
+  const rules = await this.getParsedPublishTable.bind(this)({
+    clientReq,
+    tableName: fileTableName,
     clientInfo,
-    { [fileTableName]: fileTableRule },
-  );
+    resolvedPublishObject: { [fileTableName]: fileTableRule },
+  });
   return { rules, allowedInserts: allowedNestedInserts };
 }

package/lib/PublishParser/{getTableRulesWithoutFileTable.ts → getParsedPublishTable.ts}

@@ -1,24 +1,22 @@
-import { isAuditTable } from "../Audit/getAuditTableConfig";
 import { getObjectEntries, isObject } from "prostgles-types";
-import type { AuthResultWithSID } from "../Auth/AuthTypes";
+import { isAuditTable } from "../Audit/getAuditTableConfig";
 import type { TableHandler } from "../DboBuilder/TableHandler/TableHandler";
 import type { ViewHandler } from "../DboBuilder/ViewHandler/ViewHandler";
-import type { PublishParser } from "./PublishParser";
-import type { DboTable, ParsedPublishTable } from "./publishTypesAndUtils";
-import { TABLE_RULE_NO_LIMITS, type PublishObject } from "./publishTypesAndUtils";
+import type { PublishParser, TableRequest } from "./PublishParser";
+import type { ParsedPublishTable } from "./publishTypesAndUtils";
+import { TABLE_RULE_NO_LIMITS } from "./publishTypesAndUtils";
 
-export async function getTableRulesWithoutFileTable(
+export async function getParsedPublishTable(
   this: PublishParser,
-  { tableName, clientReq }: DboTable,
-  clientInfo: AuthResultWithSID | undefined,
-  overridenPublish?: PublishObject,
+  { tableName, clientReq, clientInfo, resolvedPublishObject }: Omit<TableRequest, "scope">,
 ): Promise<ParsedPublishTable | undefined> {
   if (!tableName) {
     throw new Error("tableName is missing in getTableRules");
   }
 
   const publish =
-    overridenPublish ?? (clientReq && (await this.getPublishObject(clientReq, clientInfo)));
+    resolvedPublishObject ??
+    (clientReq && (await this.getPublishObjectForUser(clientReq, clientInfo)));
 
   const rawTableRule = publish?.[tableName];
   if (!rawTableRule || (isObject(rawTableRule) && Object.values(rawTableRule).every((v) => !v))) {
@@ -53,8 +51,14 @@ export async function getTableRulesWithoutFileTable(
       }
     : rawTableRule;
 
-  const tableRulesObject = isAuditTable(this.prostgles, tableName)
-    ? { select: rawTableRulesObject.select, insert: undefined, update: undefined, delete: undefined }
+  const tableRulesObject =
+    isAuditTable(this.prostgles, tableName) ?
+      {
+        select: rawTableRulesObject.select,
+        insert: undefined,
+        update: undefined,
+        delete: undefined,
+      }
     : rawTableRulesObject;
 
   const selectRule =

package/lib/PublishParser/getPublishSchemas.ts

@@ -0,0 +1,49 @@
+import { fromEntries, type DBSchemaTable } from "prostgles-types";
+import { getRawColumns } from "../DboBuilder/getColumns";
+import { getRawInfo } from "../DboBuilder/ViewHandler/getRawInfo";
+import type { ClientSchemaProfiles } from "../DBSchemaBuilder/getClientDBGeneratedSchemas";
+import { isArray } from "../utils/utils";
+import { getPublishedObjectFromResult } from "./getPublishedObjectFromResult";
+import { getPublishedTableNames } from "./getPublishedTableNames";
+import type { PublishParser } from "./PublishParser";
+
+export const getPublishSchemas = async (
+  publishParser: PublishParser,
+): Promise<ClientSchemaProfiles | undefined> => {
+  if (!isArray(publishParser.parsedPublish)) {
+    return;
+  }
+  const entries = publishParser.parsedPublish;
+  const { tablesOrViews = [] } = publishParser.prostgles.dboBuilder;
+  const profiles: ClientSchemaProfiles = fromEntries(
+    await Promise.all(
+      entries.map(async ({ name, publish }) => {
+        const resolvedPublishObject = getPublishedObjectFromResult(
+          publish,
+          tablesOrViews,
+          undefined,
+        );
+        const tableNames = getPublishedTableNames(publishParser, resolvedPublishObject);
+        const tableSchema: DBSchemaTable[] = [];
+        for (const tableName of tableNames) {
+          const rules = await publishParser.getTableRules({
+            tableName,
+            resolvedPublishObject,
+            clientReq: undefined,
+            clientInfo: undefined,
+            scope: undefined,
+          });
+          if (!rules || !Object.values(rules).some(Boolean)) continue;
+          const table = publishParser.dbo[tableName]!;
+          tableSchema.push({
+            ...getRawInfo.call(table, undefined, rules),
+            name: tableName,
+            columns: await getRawColumns.call(table, undefined, undefined, rules),
+          });
+        }
+        return [name, { tableSchema }];
+      }),
+    ),
+  );
+  return profiles;
+};