prostgles-server 4.2.183 → 4.2.185

package/lib/PublishParser/publishTypesAndUtils.ts

@@ -1,4 +1,10 @@
-import { AnyObject, DBSchema, FullFilter, Method, RULE_METHODS } from "prostgles-types";
+import {
+  AnyObject,
+  DBSchema,
+  FullFilter,
+  Method,
+  RULE_METHODS,
+} from "prostgles-types";
 import type { DBOFullyTyped, PublishFullyTyped } from "../DBSchemaBuilder";
 import {
   CommonTableRules,
@@ -9,8 +15,11 @@ import {
 } from "../DboBuilder/DboBuilder";
 import { DB, DBHandlerServer } from "../Prostgles";
 
-export type PublishMethods<S = void, SUser extends SessionUser = SessionUser> = (
-  params: PublishParams<S, SUser>
+export type PublishMethods<
+  S = void,
+  SUser extends SessionUser = SessionUser,
+> = (
+  params: PublishParams<S, SUser>,
 ) => { [key: string]: Method } | Promise<{ [key: string]: Method } | null>;
 
 export type Awaitable<T> = T | Promise<T>;
@@ -71,7 +80,11 @@ export const RULE_TO_METHODS = [
     rule: "update",
     sqlRule: "update",
     methods: RULE_METHODS.update,
-    no_limits: <UpdateRule>{ fields: "*", filterFields: "*", returningFields: "*" },
+    no_limits: <UpdateRule>{
+      fields: "*",
+      filterFields: "*",
+      returningFields: "*",
+    },
     table_only: true,
     allowed_params: {
       checkFilter: 1,
@@ -158,7 +171,10 @@ export type DeleteRequestData = {
   filter: object;
   returning: FieldFilter;
 };
-export type UpdateRequestDataOne<R extends AnyObject, S extends DBSchema | void = void> = {
+export type UpdateRequestDataOne<
+  R extends AnyObject,
+  S extends DBSchema | void = void,
+> = {
   filter: FullFilter<R, S>;
   data: Partial<R>;
   returning: FieldFilter<R>;
@@ -179,28 +195,42 @@ export type ValidateRowArgs<R = AnyObject, DBX = DBHandlerServer> = {
   dbx: DBX;
   localParams: LocalParams;
 };
-export type ValidateUpdateRowArgs<U = Partial<AnyObject>, F = Filter, DBX = DBHandlerServer> = {
+export type ValidateUpdateRowArgs<
+  U = Partial<AnyObject>,
+  F = Filter,
+  DBX = DBHandlerServer,
+> = {
   update: U;
   filter: F;
   dbx: DBX;
   localParams: LocalParams;
 };
 export type ValidateRow<R extends AnyObject = AnyObject, S = void> = (
-  args: ValidateRowArgs<R, DBOFullyTyped<S>>
+  args: ValidateRowArgs<R, DBOFullyTyped<S>>,
 ) => R | Promise<R>;
 export type PostValidateRow<R extends AnyObject = AnyObject, S = void> = (
-  args: ValidateRowArgs<R, DBOFullyTyped<S>>
+  args: ValidateRowArgs<R, DBOFullyTyped<S>>,
 ) => void | Promise<void>;
-export type PostValidateRowBasic = (args: ValidateRowArgs) => void | Promise<void>;
-export type ValidateRowBasic = (args: ValidateRowArgs) => AnyObject | Promise<AnyObject>;
-export type ValidateUpdateRow<R extends AnyObject = AnyObject, S extends DBSchema | void = void> = (
-  args: ValidateUpdateRowArgs<Partial<R>, FullFilter<R, S>, DBOFullyTyped<S>>
+export type PostValidateRowBasic = (
+  args: ValidateRowArgs,
+) => void | Promise<void>;
+export type ValidateRowBasic = (
+  args: ValidateRowArgs,
+) => AnyObject | Promise<AnyObject>;
+export type ValidateUpdateRow<
+  R extends AnyObject = AnyObject,
+  S extends DBSchema | void = void,
+> = (
+  args: ValidateUpdateRowArgs<Partial<R>, FullFilter<R, S>, DBOFullyTyped<S>>,
 ) => Partial<R> | Promise<Partial<R>>;
 export type ValidateUpdateRowBasic = (
-  args: ValidateUpdateRowArgs
+  args: ValidateUpdateRowArgs,
 ) => AnyObject | Promise<AnyObject>;
 
-export type SelectRule<Cols extends AnyObject = AnyObject, S extends DBSchema | void = void> = {
+export type SelectRule<
+  Cols extends AnyObject = AnyObject,
+  S extends DBSchema | void = void,
+> = {
   /**
    * Fields allowed to be selected.
    * Tip: Use false to exclude field
@@ -231,7 +261,9 @@ export type SelectRule<Cols extends AnyObject = AnyObject, S extends DBSchema |
   /**
    * Validation logic to check/update data for each request
    */
-  validate?(args: SelectRequestData): SelectRequestData | Promise<SelectRequestData>;
+  validate?(
+    args: SelectRequestData,
+  ): SelectRequestData | Promise<SelectRequestData>;
 };
 
 export type CommonInsertUpdateRule<
@@ -279,7 +311,9 @@ export type InsertRule<
    * Validation logic to check/update data after the insert.
    * Happens in the same transaction so upon throwing an error the record will be deleted (not committed)
    */
-  postValidate?: S extends DBSchema ? PostValidateRow<Required<Cols>, S> : PostValidateRowBasic;
+  postValidate?: S extends DBSchema
+    ? PostValidateRow<Required<Cols>, S>
+    : PostValidateRowBasic;
 
   /**
    * If defined then only nested inserts from these tables are allowed
@@ -331,16 +365,23 @@ export type UpdateRule<
   /**
    * Validation logic to check/update data for each request
    */
-  validate?: S extends DBSchema ? ValidateUpdateRow<Cols, S> : ValidateUpdateRowBasic;
+  validate?: S extends DBSchema
+    ? ValidateUpdateRow<Cols, S>
+    : ValidateUpdateRowBasic;
 
   /**
    * Validation logic to check/update data after the insert.
    * Happens in the same transaction so upon throwing an error the record will be deleted (not committed)
    */
-  postValidate?: S extends DBSchema ? PostValidateRow<Required<Cols>, S> : PostValidateRowBasic;
+  postValidate?: S extends DBSchema
+    ? PostValidateRow<Required<Cols>, S>
+    : PostValidateRowBasic;
 };
 
-export type DeleteRule<Cols extends AnyObject = AnyObject, S extends DBSchema | void = void> = {
+export type DeleteRule<
+  Cols extends AnyObject = AnyObject,
+  S extends DBSchema | void = void,
+> = {
   /**
    * Filter added to every query (e.g. user_id) to restrict access
    */
@@ -407,7 +448,10 @@ export type TableRule<
   sync?: SyncRule<RowType>;
   subscribe?: SubscribeRule;
 };
-export type PublishViewRule<Col extends AnyObject = AnyObject, S extends DBSchema | void = void> = {
+export type PublishViewRule<
+  Col extends AnyObject = AnyObject,
+  S extends DBSchema | void = void,
+> = {
   select?: SelectRule<Col, S> | PublishAllOrNothing;
   getColumns?: PublishAllOrNothing;
   getInfo?: PublishAllOrNothing;
@@ -451,12 +495,19 @@ export type PublishParams<S = void, SUser extends SessionUser = SessionUser> = {
 export type RequestParams = { dbo?: DBHandlerServer; socket?: any };
 export type PublishAllOrNothing = boolean | "*" | null;
 export type PublishObject = {
-  [table_name: string]: PublishTableRule | PublishViewRule | PublishAllOrNothing;
+  [table_name: string]:
+    | PublishTableRule
+    | PublishViewRule
+    | PublishAllOrNothing;
 };
 export type ParsedPublishTables = {
   [table_name: string]: ParsedPublishTable;
 };
-export type PublishedResult<Schema = void> = PublishAllOrNothing | PublishFullyTyped<Schema>;
+export type PublishedResult<Schema = void> =
+  | PublishAllOrNothing
+  | PublishFullyTyped<Schema>;
 export type Publish<Schema = void, SUser extends SessionUser = SessionUser> =
   | PublishedResult<Schema>
-  | ((params: PublishParams<Schema, SUser>) => Awaitable<PublishedResult<Schema>>);
+  | ((
+      params: PublishParams<Schema, SUser>,
+    ) => Awaitable<PublishedResult<Schema>>);

package/lib/RestApi.ts

@@ -4,7 +4,11 @@ import { HTTPCODES } from "./Auth/AuthHandler";
 import { ExpressReq, ExpressRes } from "./Auth/AuthTypes";
 import { getSerializedClientErrorFromPGError } from "./DboBuilder/DboBuilder";
 import { Prostgles } from "./Prostgles";
-import { runClientMethod, runClientRequest, runClientSqlRequest } from "./runClientRequest";
+import {
+  runClientMethod,
+  runClientRequest,
+  runClientSqlRequest,
+} from "./runClientRequest";
 import { VoidFunction } from "./SchemaWatch/SchemaWatch";
 const jsonParser = bodyParser.json();
 
@@ -49,7 +53,11 @@ export class RestApi {
     schema: string;
   };
   expressApp: Express;
-  constructor({ expressApp, routePrefix, prostgles }: RestApiConfig & { prostgles: Prostgles }) {
+  constructor({
+    expressApp,
+    routePrefix,
+    prostgles,
+  }: RestApiConfig & { prostgles: Prostgles }) {
     this.prostgles = prostgles;
     this.routes = {
       db: `${routePrefix}/db/:tableName/:command`,

package/lib/SchemaWatch/SchemaWatch.ts

@@ -1,67 +1,83 @@
 import type { DboBuilder } from "../DboBuilder/DboBuilder";
 import { EVENT_TRIGGER_TAGS } from "../Event_Trigger_Tags";
 import { PubSubManager, log } from "../PubSubManager/PubSubManager";
-import { ValidatedWatchSchemaType, getValidatedWatchSchemaType } from "./getValidatedWatchSchemaType";
-const COMMAND_FIRST_KEYWORDS = EVENT_TRIGGER_TAGS
-  .map(tag => tag.split(" ")[0]!)
-  .filter(tag => tag !== "SELECT"); /** SELECT INTO is not easily detectable with pg-node (command = "SELECT")  */
+import {
+  ValidatedWatchSchemaType,
+  getValidatedWatchSchemaType,
+} from "./getValidatedWatchSchemaType";
+const COMMAND_FIRST_KEYWORDS = EVENT_TRIGGER_TAGS.map(
+  (tag) => tag.split(" ")[0]!,
+).filter(
+  (tag) => tag !== "SELECT",
+); /** SELECT INTO is not easily detectable with pg-node (command = "SELECT")  */
 
-const DB_FALLBACK_COMMANDS = Array.from(new Set(COMMAND_FIRST_KEYWORDS))
-  .concat([
-    "DO",  // Do statement
-    "COMMIT" // Transaction block 
-  ]);
+const DB_FALLBACK_COMMANDS = Array.from(new Set(COMMAND_FIRST_KEYWORDS)).concat(
+  [
+    "DO", // Do statement
+    "COMMIT", // Transaction block
+  ],
+);
 
 export type VoidFunction = () => void;
 
-export type OnSchemaChangeCallback = ((event: { command: string; query: string }) => void);
+export type OnSchemaChangeCallback = (event: {
+  command: string;
+  query: string;
+}) => void;
 
 export class SchemaWatch {
-
   dboBuilder: DboBuilder;
   type: ValidatedWatchSchemaType;
-  private constructor(dboBuilder: DboBuilder){
+  private constructor(dboBuilder: DboBuilder) {
     this.dboBuilder = dboBuilder;
     this.type = getValidatedWatchSchemaType(dboBuilder);
-    if(this.type.watchType === "NONE") {
+    if (this.type.watchType === "NONE") {
       this.onSchemaChange = undefined;
       this.onSchemaChangeFallback = undefined;
     }
-    if(this.type.watchType === "DDL_trigger") {
+    if (this.type.watchType === "DDL_trigger") {
       this.onSchemaChangeFallback = undefined;
     }
   }
 
   static create = async (dboBuilder: DboBuilder) => {
     const instance = new SchemaWatch(dboBuilder);
-    if(instance.type.watchType === "DDL_trigger") {
+    if (instance.type.watchType === "DDL_trigger") {
       await dboBuilder.getPubSubManager();
       // TODO finish createSchemaWatchEventTrigger to ensure the query is not used in NOTIFY and exclude happens inside Postgres
     }
     return instance;
-  }
+  };
 
   /**
    * Fallback for watchSchema in case of not a superuser (cannot add db event listener)
    */
-  onSchemaChangeFallback: OnSchemaChangeCallback | undefined = async ({ command, query }) => {
-    
-    if (typeof query === "string" && query.includes(PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID)) {
-      log("Schema change event excluded from triggers due to EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID");
+  onSchemaChangeFallback: OnSchemaChangeCallback | undefined = async ({
+    command,
+    query,
+  }) => {
+    if (
+      typeof query === "string" &&
+      query.includes(PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID)
+    ) {
+      log(
+        "Schema change event excluded from triggers due to EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID",
+      );
       return;
     }
-    if(
-      this.type.watchType !== "prostgles_queries" || 
-      !this.onSchemaChange || 
+    if (
+      this.type.watchType !== "prostgles_queries" ||
+      !this.onSchemaChange ||
       !DB_FALLBACK_COMMANDS.includes(command)
-    ) return;
+    )
+      return;
+
+    this.onSchemaChange({ command, query });
+  };
 
-    this.onSchemaChange({ command, query })
-  }
-  
   onSchemaChange: OnSchemaChangeCallback | undefined = async (event) => {
-    
-    const { watchSchema, onReady, tsGeneratedTypesDir } = this.dboBuilder.prostgles.opts;
+    const { watchSchema, onReady, tsGeneratedTypesDir } =
+      this.dboBuilder.prostgles.opts;
     if (watchSchema && this.dboBuilder.prostgles.loaded) {
       log("Schema changed");
       const { query, command } = event;
@@ -70,7 +86,6 @@ export class SchemaWatch {
       if (typeof watchSchema === "function") {
         /* Only call the provided func */
         watchSchema(event);
-
       } else if (watchSchema === "hotReloadMode") {
         if (tsGeneratedTypesDir) {
           /* Hot reload integration. Will only touch tsGeneratedTypesDir */
@@ -79,12 +94,15 @@ export class SchemaWatch {
           await this.dboBuilder.prostgles.refreshDBO();
           this.dboBuilder.prostgles.writeDBSchema(true);
         }
-
       } else if (watchSchema) {
         /* Full re-init. Sockets must reconnect */
-        console.log("watchSchema: Full re-initialisation", { query })
-        this.dboBuilder.prostgles.init(onReady as any, { type: "schema change", query, command });
+        console.log("watchSchema: Full re-initialisation", { query });
+        this.dboBuilder.prostgles.init(onReady as any, {
+          type: "schema change",
+          query,
+          command,
+        });
       }
     }
   };
-}
+}

package/lib/SchemaWatch/createSchemaWatchEventTrigger.ts

@@ -1,3 +1,3 @@
 // export const createSchemaWatchEventTrigger = () => {
 
-// }
+// }

package/lib/SchemaWatch/getValidatedWatchSchemaType.ts

@@ -1,45 +1,55 @@
 import type { DboBuilder } from "../DboBuilder/DboBuilder";
 import { OnSchemaChangeCallback } from "./SchemaWatch";
 
-export type ValidatedWatchSchemaType = 
-| { watchType: "NONE" }
-| { watchType: "DDL_trigger"; onChange?: OnSchemaChangeCallback; }
-| { watchType: "prostgles_queries"; onChange?: OnSchemaChangeCallback; isFallbackFromDDL: boolean; }
+export type ValidatedWatchSchemaType =
+  | { watchType: "NONE" }
+  | { watchType: "DDL_trigger"; onChange?: OnSchemaChangeCallback }
+  | {
+      watchType: "prostgles_queries";
+      onChange?: OnSchemaChangeCallback;
+      isFallbackFromDDL: boolean;
+    };
+
+export const getValidatedWatchSchemaType = (
+  dboBuilder: DboBuilder,
+): ValidatedWatchSchemaType => {
+  const { watchSchema, watchSchemaType, tsGeneratedTypesDir, disableRealtime } =
+    dboBuilder.prostgles.opts;
+  if (!watchSchema) return { watchType: "NONE" };
 
-export const getValidatedWatchSchemaType = (dboBuilder: DboBuilder): ValidatedWatchSchemaType => {
-  const {watchSchema, watchSchemaType, tsGeneratedTypesDir, disableRealtime } = dboBuilder.prostgles.opts;
-  if(!watchSchema) return { watchType: "NONE" };
-  
   if (watchSchema === "hotReloadMode" && !tsGeneratedTypesDir) {
     throw "tsGeneratedTypesDir option is needed for watchSchema: hotReloadMode to work ";
   }
 
-  const onChange = typeof watchSchema === "function"? watchSchema : undefined;
-
-  if(watchSchemaType === "DDL_trigger" || !watchSchemaType){
-    if(!dboBuilder.prostgles.isSuperUser || disableRealtime){
+  const onChange = typeof watchSchema === "function" ? watchSchema : undefined;
 
-      if(watchSchemaType === "DDL_trigger"){
-        console.error(`watchSchemaType "DDL_trigger" cannot be used because db user is not a superuser. Will fallback to watchSchemaType "prostgles_queries" `)
+  if (watchSchemaType === "DDL_trigger" || !watchSchemaType) {
+    if (!dboBuilder.prostgles.isSuperUser || disableRealtime) {
+      if (watchSchemaType === "DDL_trigger") {
+        console.error(
+          `watchSchemaType "DDL_trigger" cannot be used because db user is not a superuser. Will fallback to watchSchemaType "prostgles_queries" `,
+        );
       } else {
-        console.warn(`watchSchema fallback to watchSchemaType "prostgles_queries" due to ${disableRealtime? "disableRealtime setting" : "non-superuser"}`)
+        console.warn(
+          `watchSchema fallback to watchSchemaType "prostgles_queries" due to ${disableRealtime ? "disableRealtime setting" : "non-superuser"}`,
+        );
       }
       return {
         watchType: "prostgles_queries",
         onChange,
-        isFallbackFromDDL: true
-      }
+        isFallbackFromDDL: true,
+      };
     }
 
     return {
       watchType: "DDL_trigger",
-      onChange
+      onChange,
     };
   }
-  
+
   return {
     watchType: watchSchemaType,
     isFallbackFromDDL: false,
-    onChange
-  }
-}
+    onChange,
+  };
+};

package/lib/SchemaWatch/getWatchSchemaTagList.ts

@@ -2,26 +2,34 @@ import { getKeys, isObject } from "prostgles-types";
 import { EVENT_TRIGGER_TAGS } from "../Event_Trigger_Tags";
 import { ProstglesInitOptions } from "../ProstglesTypes";
 
-export const getWatchSchemaTagList = (watchSchema: ProstglesInitOptions["watchSchema"]) => {
-  if(!watchSchema) return undefined;
+export const getWatchSchemaTagList = (
+  watchSchema: ProstglesInitOptions["watchSchema"],
+) => {
+  if (!watchSchema) return undefined;
 
-  if(watchSchema === "*"){
+  if (watchSchema === "*") {
     return EVENT_TRIGGER_TAGS.slice(0);
-  } 
-  if (isObject(watchSchema) && typeof watchSchema !== "function"){
+  }
+  if (isObject(watchSchema) && typeof watchSchema !== "function") {
     const watchSchemaKeys = getKeys(watchSchema);
-    const isInclusive = Object.values(watchSchema).every(v => v);
-    return EVENT_TRIGGER_TAGS
-      .slice(0)
-      .filter(v => {
-        const matches = watchSchemaKeys.includes(v);
-        return isInclusive? matches : !matches;
-      });
+    const isInclusive = Object.values(watchSchema).every((v) => v);
+    return EVENT_TRIGGER_TAGS.slice(0).filter((v) => {
+      const matches = watchSchemaKeys.includes(v);
+      return isInclusive ? matches : !matches;
+    });
   }
 
-  const coreTags: typeof EVENT_TRIGGER_TAGS[number][] = [
-    'COMMENT', 'CREATE TABLE', 'ALTER TABLE', 'DROP TABLE', 'CREATE VIEW', 
-    'DROP VIEW', 'ALTER VIEW', 'CREATE TABLE AS', 'SELECT INTO', 'CREATE POLICY'
+  const coreTags: (typeof EVENT_TRIGGER_TAGS)[number][] = [
+    "COMMENT",
+    "CREATE TABLE",
+    "ALTER TABLE",
+    "DROP TABLE",
+    "CREATE VIEW",
+    "DROP VIEW",
+    "ALTER VIEW",
+    "CREATE TABLE AS",
+    "SELECT INTO",
+    "CREATE POLICY",
   ];
   return coreTags;
-}
+};