prostgles-server 4.2.183 → 4.2.185

package/lib/JSONBValidation/validate_jsonb_schema_sql.ts

@@ -1,20 +1,16 @@
 import { DATA_TYPES } from "prostgles-types";
 import { PubSubManager } from "../PubSubManager/PubSubManager";
 
-
 const raiseException = (err: string) => `
 IF (context->'silent')::BOOLEAN = TRUE THEN
   RETURN FALSE;
 ELSE
   RAISE EXCEPTION ${err} USING HINT = path, COLUMN = colname, TABLE = tablename, CONSTRAINT = 'validate_jsonb_schema: ' || jsonb_pretty(jsonb_schema::JSONB);
 END IF;
-`
+`;
 
 export const VALIDATE_SCHEMA_FUNCNAME = "validate_jsonb_schema" as const;
-export const JSONB_DATA_TYPES = [
-  ...DATA_TYPES,
-  "Lookup","Lookup[]"
-] as const; 
+export const JSONB_DATA_TYPES = [...DATA_TYPES, "Lookup", "Lookup[]"] as const;
 
 export const validate_jsonb_schema_sql = `
 
@@ -499,4 +495,3 @@ SELECT ${VALIDATE_SCHEMA_FUNCNAME}('{ "type": "Date"}', '"2222-22-22"');
 
 SELECT ${VALIDATE_SCHEMA_FUNCNAME}('{ "oneOf": ["number"]}','2');
 `;
- 

package/lib/JSONBValidation/validation.ts

@@ -1,53 +1,81 @@
-import { getKeys, isEmpty, isObject, JSONB, TableSchema } from "prostgles-types";
+import {
+  getKeys,
+  isEmpty,
+  isObject,
+  JSONB,
+  TableSchema,
+} from "prostgles-types";
 import { postgresToTsType } from "../DboBuilder/DboBuilder";
 import { asValue } from "../PubSubManager/PubSubManager";
 
-
-
 const getFieldTypeObj = (rawFieldType: JSONB.FieldType): JSONB.FieldTypeObj => {
-  if(typeof rawFieldType === "string") return { type: rawFieldType };
+  if (typeof rawFieldType === "string") return { type: rawFieldType };
 
   return rawFieldType;
-} 
+};
 
-export function validate<T>(obj: T, key: keyof T, rawFieldType: JSONB.FieldType): boolean {
+export function validate<T>(
+  obj: T,
+  key: keyof T,
+  rawFieldType: JSONB.FieldType,
+): boolean {
   let err = `The provided value for ${JSON.stringify(key)} is of invalid type. Expecting `;
   const val = obj[key];
   const fieldType = getFieldTypeObj(rawFieldType);
   if ("type" in fieldType && fieldType.type) {
     if (typeof fieldType.type !== "string") {
-      getKeys(fieldType.type).forEach(subKey => {
-        validate(val, subKey as any, (fieldType.type as JSONB.ObjectType["type"])[subKey]!)
+      getKeys(fieldType.type).forEach((subKey) => {
+        validate(
+          val,
+          subKey as any,
+          (fieldType.type as JSONB.ObjectType["type"])[subKey]!,
+        );
       });
     }
     err += fieldType.type;
-    if (fieldType.type === "boolean" && typeof val !== fieldType.type) throw new Error(err)
-    if (fieldType.type === "string" && typeof val !== fieldType.type) throw new Error(err)
-    if (fieldType.type === "number" && !Number.isFinite(val)) throw new Error(err)
-    if (fieldType.type === "integer" && !Number.isInteger(val)) throw new Error(err);
-
+    if (fieldType.type === "boolean" && typeof val !== fieldType.type)
+      throw new Error(err);
+    if (fieldType.type === "string" && typeof val !== fieldType.type)
+      throw new Error(err);
+    if (fieldType.type === "number" && !Number.isFinite(val))
+      throw new Error(err);
+    if (fieldType.type === "integer" && !Number.isInteger(val))
+      throw new Error(err);
   } else if (fieldType.enum) {
     err += `on of: ${fieldType.enum}`;
-    if (!fieldType.enum.includes(val)) throw new Error(err)
+    if (!fieldType.enum.includes(val)) throw new Error(err);
   }
-  return true
+  return true;
 }
 
-export function validateSchema<S extends JSONB.ObjectType["type"]>(schema: S, obj: JSONB.GetObjectType<S>, objName?: string, optional = false) {
-  if ((!schema || isEmpty(schema)) && !optional) throw new Error(`Expecting ${objName} to be defined`);
-  getKeys(schema).forEach(k => validate(obj as any, k, schema[k]!));
+export function validateSchema<S extends JSONB.ObjectType["type"]>(
+  schema: S,
+  obj: JSONB.GetObjectType<S>,
+  objName?: string,
+  optional = false,
+) {
+  if ((!schema || isEmpty(schema)) && !optional)
+    throw new Error(`Expecting ${objName} to be defined`);
+  getKeys(schema).forEach((k) => validate(obj as any, k, schema[k]!));
 }
 
-
-type ColOpts = { nullable?: boolean }; 
-
-
-export function getJSONBSchemaTSTypes(schema: JSONB.JSONBSchema, colOpts: ColOpts, outerLeading = "", tables: TableSchema[]): string { 
- 
-  const getFieldType = (rawFieldType: JSONB.FieldType, isOneOf = false, innerLeading = "", depth = 0): string => {
+type ColOpts = { nullable?: boolean };
+
+export function getJSONBSchemaTSTypes(
+  schema: JSONB.JSONBSchema,
+  colOpts: ColOpts,
+  outerLeading = "",
+  tables: TableSchema[],
+): string {
+  const getFieldType = (
+    rawFieldType: JSONB.FieldType,
+    isOneOf = false,
+    innerLeading = "",
+    depth = 0,
+  ): string => {
     const fieldType = getFieldTypeObj(rawFieldType);
-    const nullType = (fieldType.nullable ? `null | ` : "");
-    
+    const nullType = fieldType.nullable ? `null | ` : "";
+
     /** Primitives */
     if (typeof fieldType?.type === "string") {
       const correctType = fieldType.type
@@ -55,89 +83,126 @@ export function getJSONBSchemaTSTypes(schema: JSONB.JSONBSchema, colOpts: ColOpt
         .replace("time", "string")
         .replace("timestamp", "string")
         .replace("Date", "string");
-        
+
       if (fieldType.allowedValues && fieldType.type.endsWith("[]")) {
-        return nullType + ` (${fieldType.allowedValues.map(v => JSON.stringify(v)).join(" | ")})[]`
+        return (
+          nullType +
+          ` (${fieldType.allowedValues.map((v) => JSON.stringify(v)).join(" | ")})[]`
+        );
       }
       return nullType + correctType;
 
-    /** Object */
+      /** Object */
     } else if (isObject(fieldType.type)) {
-      const addSemicolonIfMissing = (v: string) => v.trim().endsWith(";")? v : (v.trim() + ";");
+      const addSemicolonIfMissing = (v: string) =>
+        v.trim().endsWith(";") ? v : v.trim() + ";";
       const { type } = fieldType;
       const spacing = isOneOf ? " " : "  ";
-      let objDef = ` {${spacing}` + getKeys(type).map(key => {
-        const fieldType = getFieldTypeObj(type[key]!);
-        const escapedKey = isValidIdentifier(key) ? key : JSON.stringify(key);
-        return `${spacing}${escapedKey}${fieldType.optional ? "?" : ""}: ` + addSemicolonIfMissing(getFieldType(fieldType, true, undefined, depth + 1));
-      }).join(" ") + `${spacing}}`;
-      if(!isOneOf){
+      let objDef =
+        ` {${spacing}` +
+        getKeys(type)
+          .map((key) => {
+            const fieldType = getFieldTypeObj(type[key]!);
+            const escapedKey = isValidIdentifier(key)
+              ? key
+              : JSON.stringify(key);
+            return (
+              `${spacing}${escapedKey}${fieldType.optional ? "?" : ""}: ` +
+              addSemicolonIfMissing(
+                getFieldType(fieldType, true, undefined, depth + 1),
+              )
+            );
+          })
+          .join(" ") +
+        `${spacing}}`;
+      if (!isOneOf) {
         objDef = addSemicolonIfMissing(objDef);
       }
-    
+
       /** Keep single line */
-      if (isOneOf){
+      if (isOneOf) {
         objDef = objDef.split("\n").join("");
       }
       return nullType + objDef;
-
     } else if (fieldType?.enum) {
-      return nullType + fieldType.enum.map(v => asValue(v)).join(" | ");
-
+      return nullType + fieldType.enum.map((v) => asValue(v)).join(" | ");
     } else if (fieldType?.oneOf || fieldType?.oneOfType) {
-      const oneOf = fieldType?.oneOf || fieldType?.oneOfType.map(type => ({ type }));
-      return (fieldType.nullable ? `\n${innerLeading} | null` : "") + oneOf.map(v => `\n${innerLeading} | ` + getFieldType(v, true, undefined, depth + 1)).join("");
-
+      const oneOf =
+        fieldType?.oneOf || fieldType?.oneOfType.map((type) => ({ type }));
+      return (
+        (fieldType.nullable ? `\n${innerLeading} | null` : "") +
+        oneOf
+          .map(
+            (v) =>
+              `\n${innerLeading} | ` +
+              getFieldType(v, true, undefined, depth + 1),
+          )
+          .join("")
+      );
     } else if (fieldType?.arrayOf || fieldType?.arrayOfType) {
       const arrayOf = fieldType?.arrayOf || { type: fieldType?.arrayOfType };
       return `${fieldType.nullable ? `null | ` : ""} ( ${getFieldType(arrayOf, true, undefined, depth + 1)} )[]`;
-
     } else if (fieldType?.record) {
       const { keysEnum, values, partial } = fieldType.record;
       // TODO: ensure props with undefined values are not allowed in the TS type (strict union)
-      const getRecord = (v: string) => partial? `Partial<Record<${v}>>` : `Record<${v}>`;
-      return `${fieldType.nullable ? `null |` : ""} ${getRecord(`${keysEnum?.map(v => asValue(v)).join(" | ") ?? "string"}, ${!values? "any" : getFieldType(values, true, undefined, depth + 1)}`)}`
-
-    } else if(fieldType?.lookup){
-
+      const getRecord = (v: string) =>
+        partial ? `Partial<Record<${v}>>` : `Record<${v}>`;
+      return `${fieldType.nullable ? `null |` : ""} ${getRecord(`${keysEnum?.map((v) => asValue(v)).join(" | ") ?? "string"}, ${!values ? "any" : getFieldType(values, true, undefined, depth + 1)}`)}`;
+    } else if (fieldType?.lookup) {
       const l = fieldType.lookup;
-      if(l.type === "data-def"){
-        return `${fieldType.nullable ? `null |` : ""} ${
-          getFieldType({ 
-            type: {
-              table: "string",
-              column: "string", 
-              filter: { record: {}, optional: true }, 
-              isArray: { type: "boolean", optional: true }, 
-              searchColumns: { type: "string[]", optional: true }, 
-              isFullRow: { optional: true, type: { 
-                displayColumns:{ type: "string[]", optional: true } 
-              }}, 
-              showInRowCard: { optional: true, record: {} }
-            } 
-          })
-      }`;
-      } 
-      
+      if (l.type === "data-def") {
+        return `${fieldType.nullable ? `null |` : ""} ${getFieldType({
+          type: {
+            table: "string",
+            column: "string",
+            filter: { record: {}, optional: true },
+            isArray: { type: "boolean", optional: true },
+            searchColumns: { type: "string[]", optional: true },
+            isFullRow: {
+              optional: true,
+              type: {
+                displayColumns: { type: "string[]", optional: true },
+              },
+            },
+            showInRowCard: { optional: true, record: {} },
+          },
+        })}`;
+      }
+
       const isSChema = l.type === "schema";
-      let type = isSChema? (l.object === "table"? "string" : `{ "table": string; "column": string; }`) : "";
-      if(!isSChema){
-        const cols = tables.find(t => t.name === l.table)?.columns
-        if(!l.isFullRow){
-          type = postgresToTsType(cols?.find(c => c.name === l.column)?.udt_name ?? "text");
+      let type = isSChema
+        ? l.object === "table"
+          ? "string"
+          : `{ "table": string; "column": string; }`
+        : "";
+      if (!isSChema) {
+        const cols = tables.find((t) => t.name === l.table)?.columns;
+        if (!l.isFullRow) {
+          type = postgresToTsType(
+            cols?.find((c) => c.name === l.column)?.udt_name ?? "text",
+          );
         } else {
-          type = !cols? "any" : `{ ${cols.map(c => `${JSON.stringify(c.name)}: ${c.is_nullable? "null | " : "" } ${postgresToTsType(c.udt_name)}; `).join(" ")} }`
+          type = !cols
+            ? "any"
+            : `{ ${cols.map((c) => `${JSON.stringify(c.name)}: ${c.is_nullable ? "null | " : ""} ${postgresToTsType(c.udt_name)}; `).join(" ")} }`;
         }
       }
-      return `${fieldType.nullable ? `null | ` : ""}${type}${l.isArray? "[]" : ""}`;
-
-    } else throw "Unexpected getSchemaTSTypes: " + JSON.stringify({ fieldType, schema }, null, 2)
-  } 
- 
-  return getFieldType({ ...schema as any, nullable: colOpts.nullable }, undefined, outerLeading);
+      return `${fieldType.nullable ? `null | ` : ""}${type}${l.isArray ? "[]" : ""}`;
+    } else
+      throw (
+        "Unexpected getSchemaTSTypes: " +
+        JSON.stringify({ fieldType, schema }, null, 2)
+      );
+  };
+
+  return getFieldType(
+    { ...(schema as any), nullable: colOpts.nullable },
+    undefined,
+    outerLeading,
+  );
 }
 
 const isValidIdentifier = (str: string) => {
   const identifierRegex = /^[A-Za-z$_][A-Za-z0-9$_]*$/;
   return identifierRegex.test(str);
-}
+};

package/lib/Logging.ts

@@ -5,127 +5,137 @@ import { TableHandler } from "./DboBuilder/TableHandler/TableHandler";
 type ClientInfo = {
   socketId: string | undefined;
   sid: string | undefined;
-}
+};
 
 export namespace EventTypes {
   type DebugInfo = {
     duration: number;
     error?: any;
-  }
-
-  export type Table = ClientInfo & DebugInfo & {
-    type: "table";
-    tableName: string;
-    command: keyof TableHandler;
-    txInfo: AnyObject | undefined;
-    data: AnyObject;
-    localParams: LocalParams | undefined;
   };
 
-  type SyncOneClient = ClientInfo & DebugInfo & {
-    type: "sync";
-    tableName: string;
-    localParams?: LocalParams;
-    connectedSocketIds: string[];
-  } & (
-    {
-      command: "syncData";
-      source: "client" | "trigger";
-      connectedSocketIds: string[];
-      lr: string;
-    } | {
-      command: "upsertData" | "pushData";
-      rows: number;
-      socketId: string;
-    } | {
-      command: "addTrigger";
-      state: "ok" | "fail";
-      /** If no socket id then it's a local subscribe */
-      socketId: string | undefined;
-      condition: string;
-    } | {
-      command: "addSync" | "unsync";
-      socketId: string;
-      condition: string;
-    } | {
-      command: "upsertSocket.disconnect";
-      socketId: string;
-      remainingSyncs: string;
-      remainingSubs: string;
+  export type Table = ClientInfo &
+    DebugInfo & {
+      type: "table";
+      tableName: string;
+      command: keyof TableHandler;
+      txInfo: AnyObject | undefined;
+      data: AnyObject;
+      localParams: LocalParams | undefined;
+    };
+
+  type SyncOneClient = ClientInfo &
+    DebugInfo & {
+      type: "sync";
+      tableName: string;
+      localParams?: LocalParams;
       connectedSocketIds: string[];
-    }
-  );
+    } & (
+      | {
+          command: "syncData";
+          source: "client" | "trigger";
+          connectedSocketIds: string[];
+          lr: string;
+        }
+      | {
+          command: "upsertData" | "pushData";
+          rows: number;
+          socketId: string;
+        }
+      | {
+          command: "addTrigger";
+          state: "ok" | "fail";
+          /** If no socket id then it's a local subscribe */
+          socketId: string | undefined;
+          condition: string;
+        }
+      | {
+          command: "addSync" | "unsync";
+          socketId: string;
+          condition: string;
+        }
+      | {
+          command: "upsertSocket.disconnect";
+          socketId: string;
+          remainingSyncs: string;
+          remainingSubs: string;
+          connectedSocketIds: string[];
+        }
+    );
   export type SyncMultiClient = {
     type: "sync";
     tableName: string;
     localParams?: LocalParams;
     connectedSocketIds: string[];
-  } & (
-    {
-      command: "notifListener";
-      op_name: string | undefined;
-      condition_ids_str: string | undefined;
-      tableTriggers: string[] | undefined;
-      tableSyncs: string;
-      state: "ok" | "error" | "no-triggers" | "invalid_condition_ids";
-    }
-  );
+  } & {
+    command: "notifListener";
+    op_name: string | undefined;
+    condition_ids_str: string | undefined;
+    tableTriggers: string[] | undefined;
+    tableSyncs: string;
+    state: "ok" | "error" | "no-triggers" | "invalid_condition_ids";
+  };
 
   export type Sync = SyncOneClient | SyncMultiClient;
 
-  export type Connection = (ClientInfo & {
-    type: "connect" | "disconnect";
-    socketId: string;
-    connectedSocketIds: string[];
-  }) | (ClientInfo & DebugInfo & {
-    type: "connect.getClientSchema";
-  });
+  export type Connection =
+    | (ClientInfo & {
+        type: "connect" | "disconnect";
+        socketId: string;
+        connectedSocketIds: string[];
+      })
+    | (ClientInfo &
+        DebugInfo & {
+          type: "connect.getClientSchema";
+        });
 
-  export type Method = ClientInfo & DebugInfo & {
-    type: "method";
-    args: any[];
-    localParams: LocalParams;
-  };
-  export type Auth = ClientInfo & DebugInfo & {
-    type: "auth";
-  } & (
-  | { command: "getClientInfo"; } 
-  | { command: "login"; } 
-  );
+  export type Method = ClientInfo &
+    DebugInfo & {
+      type: "method";
+      args: any[];
+      localParams: LocalParams;
+    };
+  export type Auth = ClientInfo &
+    DebugInfo & {
+      type: "auth";
+    } & ({ command: "getClientInfo" } | { command: "login" });
 
-  export type Debug = DebugInfo & ({
-    type: "debug";
-    command: 
-    | "initFileTable" 
-    | "initTableConfig"
-    | "runSQLFile" 
-    | "schemaChangeNotif" 
-    | "TableConfig.runQueries.start" 
-    | "TableConfig.runQueries.end" 
-    | "refreshDBO.start" 
-    | "refreshDBO.end"
-    | "tableConfigurator.init.start"
-    | "tableConfigurator.init.end"
-    | "initFileTable.start"
-    | "initFileTable.end"
-    | "initFileManager.runQuery"
-    | "DboBuilder.getTablesForSchemaPostgresSQL"
-    | "PubSubManager.create"
-    data?: AnyObject;
-  } | {
-    type: "debug";
-    command: "pushSocketSchema";
-    data: { socketId: string, clientSchema: ClientSchema; }
-  })
+  export type Debug = DebugInfo &
+    (
+      | {
+          type: "debug";
+          command:
+            | "initFileTable"
+            | "initTableConfig"
+            | "runSQLFile"
+            | "schemaChangeNotif"
+            | "TableConfig.runQueries.start"
+            | "TableConfig.runQueries.end"
+            | "refreshDBO.start"
+            | "refreshDBO.end"
+            | "tableConfigurator.init.start"
+            | "tableConfigurator.init.end"
+            | "initFileTable.start"
+            | "initFileTable.end"
+            | "initFileManager.runQuery"
+            | "DboBuilder.getTablesForSchemaPostgresSQL"
+            | "PubSubManager.create";
+          data?: AnyObject;
+        }
+      | {
+          type: "debug";
+          command: "pushSocketSchema";
+          data: { socketId: string; clientSchema: ClientSchema };
+        }
+    );
 }
 
 export type EventInfo =
   | EventTypes.Auth
   | EventTypes.Table
   | EventTypes.Method
-  | EventTypes.Sync 
-  | EventTypes.SyncMultiClient 
+  | EventTypes.Sync
+  | EventTypes.SyncMultiClient
   | EventTypes.Connection
   | EventTypes.Debug;
 
-export type TableEvent = EventTypes.Table;
+export type TableEvent = EventTypes.Table;