prostgles-server 4.2.622 → 4.2.624

package/lib/PublishParser/PublishParser.ts

@@ -1,9 +1,13 @@
-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 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 +16,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 +35,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 +44,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 +151,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);
+
+    const publishResult = (() => {
+      if (!isPublishProfiles(parsedPublish)) {
+        return parsedPublish;
+      }
+
+      const { user } = publishParams;
+      if (!user) return;
+      return parsedPublish.find(({ userTypes }) => userTypes.includes(user.type))?.publish;
+    })();
 
-    return publish || undefined;
+    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 +212,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 +222,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 +294,28 @@ 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,
+    const publishRulesExcludingFileTable = await this.getParsedPublishTable({
+      clientReq,
+      tableName,
       clientInfo,
-      overriddenPublish,
-    );
-    if (this.dbo[args.tableName]?.is_media) {
+      resolvedPublishObject: overriddenPublish,
+    });
+    if (this.dbo[tableName]?.is_media) {
       const { rules: fileTableRules } = await getFileTableRules.bind(this)(
-        args.tableName,
-        fileTablePublishRules,
-        args.clientReq,
+        tableName,
+        publishRulesExcludingFileTable,
+        clientReq,
         clientInfo,
         scope,
         overriddenPublish,
@@ -314,17 +331,32 @@ export class PublishParser {
     return applyScopeToTableRules(
       tableName,
       tableHandler,
-      parsePublishTableRule(fileTablePublishRules),
+      parsePublishTableRule(publishRulesExcludingFileTable),
       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/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;
+};

package/lib/PublishParser/getPublishedObjectFromResult.ts

@@ -0,0 +1,104 @@
+import {
+  fromEntries,
+  getJSONBSchemaValidationError,
+  getProperty,
+  isObject,
+  pickKeys,
+  type TableSchema,
+} from "prostgles-types";
+import { isArray } from "../utils/utils";
+import type {
+  PublishContextValue,
+  PublishedResult,
+  PublishObject,
+  PublishParams,
+} from "./publishTypesAndUtils";
+
+export const getPublishedObjectFromResult = (
+  publish: PublishedResult | undefined,
+  tablesOrViews: TableSchema[],
+  publishParams: PublishParams | undefined,
+): PublishObject => {
+  if (!publish) return {};
+  if (publish === "*") {
+    return Object.fromEntries(tablesOrViews.map((table) => [table.name, "*"]));
+  }
+
+  if (isArray(publish)) {
+    const validation = getJSONBSchemaValidationError(
+      {
+        tuple: [
+          { enum: ["*"] },
+          {
+            record: {
+              keysEnum: ["select", "update", "insert", "delete"] as const,
+              values: { enum: ["*", false, true] },
+              partial: true,
+            },
+          },
+        ],
+      } as const,
+      publish,
+    );
+    if (validation.error !== undefined) {
+      throw new Error(`Invalid publish all tables: ${validation.error}`);
+    }
+
+    const [_, allTableRules] = validation.data;
+    return fromEntries(
+      tablesOrViews.map((table) => {
+        return [table.name, table.is_view ? pickKeys(allTableRules, ["select"]) : allTableRules];
+      }),
+    );
+  }
+
+  return replaceContextPlaceholders(publish, publishParams);
+};
+
+const replaceContextPlaceholders = <T>(publish: T, publishParams: PublishParams | undefined): T => {
+  const context = { user: publishParams?.user };
+  if (!publishParams) return publish;
+  if (isArray(publish)) {
+    return publish.map((item) => replaceContextPlaceholders(item, publishParams)) as T;
+  }
+  if (isObject(publish) && isPlainObject(publish)) {
+    const { data } = getJSONBSchemaValidationError(
+      {
+        type: {
+          $prostglesContext: {
+            type: { objectName: { enum: ["user"] as const }, objectPropertyName: "string" },
+          },
+        },
+      },
+      publish,
+      { allowExtraProperties: false },
+    );
+    if (data) {
+      data satisfies PublishContextValue;
+      const { objectName, objectPropertyName } = data["$prostglesContext"];
+      const contextObject = getProperty(context, objectName);
+      if (!contextObject) {
+        throw new Error(`Context object "${objectName}" not found`);
+      }
+      const contextProperty = getProperty(contextObject, objectPropertyName);
+      if (contextProperty === undefined) {
+        throw new Error(
+          `Context property "${objectPropertyName}" not found/undefined in context object "${objectName}"`,
+        );
+      }
+      return contextProperty as T;
+    }
+    return Object.fromEntries(
+      Object.entries(publish).map(([key, value]) => [
+        key,
+        replaceContextPlaceholders(value, publishParams),
+      ]),
+    ) as T;
+  }
+  return publish;
+};
+const isPlainObject = (value: unknown): value is Record<string, unknown> => {
+  if (!value || typeof value !== "object") return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+};

package/lib/PublishParser/getPublishedTableNames.ts

@@ -6,7 +6,12 @@ export const getPublishedTableNames = (
   publishObject: PublishObject,
 ) => {
   const txKey = !publishParserInstance.prostgles.opts.transactions ? "" : "tx";
-  const tableNames = Object.keys(publishObject).filter((k) => !txKey || txKey !== k);
+  if (txKey && txKey in publishObject) {
+    throw new Error(
+      `Transactions key ${JSON.stringify(txKey)} collides with a published table name`,
+    );
+  }
+  const tableNames = Object.keys(publishObject);
 
   /**
    * Add file table to the list of published tables if it's referenced by other published tables.

package/lib/PublishParser/getSchemaFromPublish.ts

@@ -27,18 +27,18 @@ export async function getSchemaFromPublish(
     if (clientInfo === "new-session-redirect") {
       throw "new-session-redirect";
     }
-    let publish: PublishObject | undefined;
+    let resolvedPublishObject: PublishObject | undefined;
     try {
-      publish = await this.getPublishObject(clientReq, clientInfo);
+      resolvedPublishObject = await this.getPublishObjectForUser(clientReq, clientInfo);
     } catch (err) {
       console.error("Error within then Publish function ", err);
       throw err;
     }
 
-    if (!publish || !Object.keys(publish).length) {
+    if (!resolvedPublishObject || !Object.keys(resolvedPublishObject).length) {
       return { tables, tableSchemaErrors };
     }
-    const tableNames = getPublishedTableNames(this, publish);
+    const tableNames = getPublishedTableNames(this, resolvedPublishObject);
 
     await Promise.all(
       tableNames.map(async (tableName) => {
@@ -52,11 +52,13 @@ export async function getSchemaFromPublish(
           throw errMsg;
         }
 
-        const parsedTableRule = await this.getTableRules(
-          { clientReq, tableName },
+        const parsedTableRule = await this.getTableRules({
+          clientReq,
+          tableName,
           clientInfo,
           scope,
-        );
+          resolvedPublishObject,
+        });
 
         if (!parsedTableRule || isEmpty(parsedTableRule)) return;
         if (!isObject(parsedTableRule)) {

package/lib/PublishParser/publishTypesAndUtils.ts

@@ -27,6 +27,7 @@ import type {
 import type { AuthClientRequest, LoginClientInfo, SessionUser } from "../Auth/AuthTypes";
 import type { TableSchemaColumn } from "../DboBuilder/DboBuilderTypes";
 import type { ClientHandlers } from "../WebsocketAPI/getClientHandlers";
+import { isArray } from "../utils/utils";
 
 export type InsertRequestData = {
   data: object | object[];
@@ -556,16 +557,40 @@ export type ParsedPublishTables = {
 };
 
 type PublishAllOrNothingRoot = Exclude<PublishAllOrNothing, boolean>;
-export type PublishedResult<Schema = void> = PublishAllOrNothingRoot | PublishFullyTyped<Schema>;
+export type PublishAllTables = [
+  "*",
+  Partial<{ select: boolean; update: boolean; insert: boolean; delete: boolean }>,
+];
+export type PublishedResult<Schema = void> =
+  PublishAllOrNothingRoot | PublishAllTables | PublishFullyTyped<Schema>;
+
 export type PublishProfile<Schema = void> = {
   /** Exported schema type name; defaults to Publish1Schema, Publish2Schema, etc. */
   name?: string;
-  userTypes: string[];
+  userTypes: readonly string[] | string[];
   publish: PublishedResult<Schema>;
 };
+
+/**
+ * Used in PublishProfile to provide user data
+ */
+export type PublishContextValue<C extends { user: AnyObject } = { user: AnyObject }> = {
+  $prostglesContext: {
+    [K in keyof C]: {
+      objectName: K;
+      objectPropertyName: keyof C[K];
+    };
+  }[keyof C];
+};
+
 export type Publish<Schema = void, SUser extends SessionUser = SessionUser> =
-  | PublishProfile<Schema>[]
   | PublishedResult<Schema>
-  | ((
-      params: PublishParams<Schema, SUser>,
-    ) => Awaitable<PublishedResult<Schema> | PublishProfile<Schema>[]>);
+  | PublishProfile<Schema>[]
+  | readonly PublishProfile<Schema>[]
+  | ((params: PublishParams<Schema, SUser>) => Awaitable<PublishedResult<Schema>>);
+
+export const isPublishProfiles = <const P extends Publish | undefined>(
+  publish: P,
+): publish is Extract<P, PublishProfile[] | readonly PublishProfile[]> => {
+  return isArray(publish) && publish[0] !== "*";
+};