prostgles-server 4.2.265 → 4.2.267

package/lib/DboBuilder/ViewHandler/getValidatedSubscribeOptions.ts

@@ -0,0 +1,72 @@
+import { isDefined, isEmpty, type SubscribeOptions } from "prostgles-types";
+import { getJSONBObjectSchemaValidationError } from "../../JSONBValidation/JSONBValidation";
+import { type Required_ish, type SubscribeRule } from "../../PublishParser/PublishParser";
+
+export const getValidatedSubscribeOptions = (
+  rawVal: Required_ish<SubscribeOptions>,
+  subscribeRule: SubscribeRule | undefined
+): Required_ish<SubscribeOptions> => {
+  const { data, error } = getJSONBObjectSchemaValidationError(
+    {
+      throttle: { type: "integer", optional: true },
+      throttleOpts: {
+        type: {
+          skipFirst: { type: "boolean", optional: true },
+        },
+        optional: true,
+      },
+      skipFirst: { type: "boolean", optional: true },
+      actions: {
+        oneOf: [
+          {
+            record: {
+              keysEnum: ["insert", "update", "delete"],
+              partial: true,
+              values: {
+                enum: [true],
+              },
+            },
+          },
+          {
+            record: {
+              keysEnum: ["insert", "update", "delete"],
+              partial: true,
+              values: {
+                enum: [false],
+              },
+            },
+          },
+        ],
+        optional: true,
+      },
+    } as const,
+    rawVal,
+    "subscribeParams"
+  );
+  if (error !== undefined) {
+    throw error;
+  }
+
+  const publishedThrottle = subscribeRule?.throttle || 0;
+  const { actions, throttleOpts, skipFirst, throttle = publishedThrottle } = data;
+  if (actions && isEmpty(actions)) {
+    throw `addSub: actions cannot be empty`;
+  }
+  if (
+    publishedThrottle &&
+    Number.isInteger(publishedThrottle) &&
+    publishedThrottle > 0 &&
+    throttle < publishedThrottle
+  ) {
+    throw `addSub: throttle ${throttle} is less than the minimum allowed throttle ${publishedThrottle}`;
+  }
+  if (isDefined(throttle) && !Number.isInteger(throttle)) {
+    throw `addSub: throttle ${throttle} must be an integer`;
+  }
+  return {
+    actions: actions,
+    skipFirst,
+    throttle,
+    throttleOpts,
+  };
+};

package/lib/DboBuilder/ViewHandler/parseComplexFilter.ts

@@ -7,7 +7,7 @@ import {
 import { FUNCTIONS, parseFunction } from "../QueryBuilder/Functions";
 import { asNameAlias, parseFunctionObject } from "../QueryBuilder/QueryBuilder";
 import { TableSchemaColumn } from "../DboBuilderTypes";
-import { asValue } from "../../PubSubManager/PubSubManager";
+import { asValue } from "../../PubSubManager/PubSubManagerUtils";
 
 const allowedComparators = FILTER_OPERANDS; //[">", "<", "=", "<=", ">=", "<>", "!="]
 type Args = {
@@ -73,32 +73,26 @@ export const parseComplexFilter = ({
   const leftVal = getFuncQuery(leftFilter);
   let result = leftVal;
   if (comparator) {
-    if (
-      typeof comparator !== "string" ||
-      !allowedComparators.includes(comparator as any)
-    ) {
+    if (typeof comparator !== "string" || !allowedComparators.includes(comparator as any)) {
       throw `Invalid $filter. comparator ${JSON.stringify(comparator)} is not valid. Expecting one of: ${allowedComparators}`;
     }
     if (!rightFilterOrValue) {
       throw "Invalid $filter. Expecting a value or function after the comparator";
     }
-    const maybeValidComparator =
-      comparator as keyof typeof FILTER_OPERAND_TO_SQL_OPERAND;
+    const maybeValidComparator = comparator as keyof typeof FILTER_OPERAND_TO_SQL_OPERAND;
     const sqlOperand = FILTER_OPERAND_TO_SQL_OPERAND[maybeValidComparator];
     if (!sqlOperand) {
       throw `Invalid $filter. comparator ${comparator} is not valid. Expecting one of: ${allowedComparators}`;
     }
 
-    let rightVal = isObject(rightFilterOrValue)
-      ? getFuncQuery(rightFilterOrValue)
+    let rightVal =
+      isObject(rightFilterOrValue) ?
+        getFuncQuery(rightFilterOrValue)
       : parseFilterRightValue(rightFilterOrValue, {
           selectItem: undefined,
           expect: ["$in", "$nin"].includes(comparator) ? "csv" : undefined,
         });
-    if (
-      maybeValidComparator === "$between" ||
-      maybeValidComparator === "$notBetween"
-    ) {
+    if (maybeValidComparator === "$between" || maybeValidComparator === "$notBetween") {
       if (!Array.isArray(rightVal) || rightVal.length !== 2) {
         throw "Between filter expects an array of two values";
       }

package/lib/DboBuilder/ViewHandler/subscribe.ts

@@ -2,13 +2,14 @@ import { AnyObject, SubscribeParams, SubscriptionChannels } from "prostgles-type
 import { ParsedTableRule } from "../../PublishParser/PublishParser";
 import {
   Filter,
-  LocalParams,
   getErrorAsObject,
   getSerializedClientErrorFromPGError,
+  LocalParams,
 } from "../DboBuilder";
 import { getSubscribeRelatedTables } from "../getSubscribeRelatedTables";
 import { NewQuery } from "../QueryBuilder/QueryBuilder";
 import { ViewHandler } from "./ViewHandler";
+import { getValidatedSubscribeOptions } from "./getValidatedSubscribeOptions";
 
 type OnData = (items: AnyObject[]) => any;
 export type LocalFuncs =
@@ -80,7 +81,7 @@ async function subscribe(
       throw " Cannot have localFunc AND socket ";
     }
 
-    const { throttle = 0, throttleOpts, ...selectParams } = params;
+    const { throttle, throttleOpts, skipFirst, actions, ...selectParams } = params;
 
     /** Ensure request is valid */
     await this.find(filter, { ...selectParams, limit: 0 }, undefined, table_rules, localParams);
@@ -107,10 +108,12 @@ async function subscribe(
       condition: newQuery.whereOpts.condition,
       table_name: this.name,
       filter: { ...filter },
-      params: { ...selectParams },
-      throttle,
-      throttleOpts,
-      last_throttled: 0,
+      selectParams: { ...selectParams },
+      subscribeOptions: getValidatedSubscribeOptions(
+        { actions, skipFirst, throttle, throttleOpts },
+        table_rules?.subscribe
+      ),
+      lastPushed: 0,
     } as const;
 
     const pubSubManager = await this.dboBuilder.getPubSubManager();

package/lib/DboBuilder/dboBuilderUtils.ts

@@ -11,9 +11,9 @@ import {
   getKeys,
   isObject,
   omitKeys,
+  pickKeys,
 } from "prostgles-types";
 import { DB } from "../Prostgles";
-import { pickKeys } from "../PubSubManager/PubSubManager";
 import { LocalParams, SortItem, pgp } from "./DboBuilderTypes";
 import { asNameAlias } from "./QueryBuilder/QueryBuilder";
 import { ViewHandler } from "./ViewHandler/ViewHandler";

package/lib/DboBuilder/getSubscribeRelatedTables.ts

@@ -6,10 +6,11 @@ import {
   SubscribeParams,
 } from "prostgles-types";
 import { ParsedTableRule } from "../PublishParser/PublishParser";
-import { log, ViewSubscriptionOptions } from "../PubSubManager/PubSubManager";
+import { ViewSubscriptionOptions } from "../PubSubManager/PubSubManager";
 import { Filter, getSerializedClientErrorFromPGError, LocalParams } from "./DboBuilder";
 import { NewQuery } from "./QueryBuilder/QueryBuilder";
 import { ViewHandler } from "./ViewHandler/ViewHandler";
+import { log } from "../PubSubManager/PubSubManagerUtils";
 
 type Args = {
   selectParams: Omit<SubscribeParams, "throttle">;

package/lib/JSONBValidation/JSONBValidation.spec.ts

@@ -45,7 +45,7 @@ void describe("JSONBValidation", async () => {
     assert.deepStrictEqual(
       getJSONBObjectSchemaValidationError(schema.type, { ...obj, age: 22.2 }, "test"),
       {
-        error: "age is of invalid type. Expecting integer",
+        error: "age is of invalid type. Expecting null | integer",
       }
     );
     assert.deepStrictEqual(
@@ -64,7 +64,7 @@ void describe("JSONBValidation", async () => {
         { ...obj, address: { ...obj.address, street_number: 22.22 } },
         "test"
       ),
-      { error: "address.street_number is of invalid type. Expecting integer" }
+      { error: "address.street_number is of invalid type. Expecting undefined | integer" }
     );
     assert.deepStrictEqual(
       getJSONBObjectSchemaValidationError(
@@ -88,7 +88,42 @@ void describe("JSONBValidation", async () => {
         { ...obj, address: { ...obj.address, t: 2 } },
         "test"
       ),
-      { error: 'address.t is of invalid type. Expecting one of: "a","b","c",null' }
+      { error: 'address.t is of invalid type. Expecting undefined | "a" | "b" | "c"' }
+    );
+  });
+  await test("getJSONBObjectSchemaValidationError oneOf record", () => {
+    assert.deepStrictEqual(
+      getJSONBObjectSchemaValidationError(
+        {
+          d: { record: { keysEnum: ["a", "b"], values: "boolean" } },
+          o: { optional: true, oneOf: ["number", "string[]"] },
+        },
+        { d: { a: true, b: 1 } },
+        "test"
+      ),
+      { error: "d.b is of invalid type. Expecting boolean" }
+    );
+    assert.deepStrictEqual(
+      getJSONBObjectSchemaValidationError(
+        {
+          d: { record: { keysEnum: ["a", "b"], values: "boolean" } },
+          o: { optional: true, oneOf: ["number", "string[]"] },
+        },
+        { d: { a: true, b: true }, o: false },
+        "test"
+      ),
+      { error: "o is of invalid type. Expecting undefined | number | string[]" }
+    );
+    assert.deepStrictEqual(
+      getJSONBObjectSchemaValidationError(
+        {
+          d: { record: { keysEnum: ["a", "b"], values: "boolean" } },
+          o: { optional: true, oneOf: ["number", "string[]"] },
+        },
+        { d: { a: true, b: true }, o: ["str"] },
+        "test"
+      ),
+      { data: { d: { a: true, b: true }, o: ["str"] } }
     );
   });
 });

package/lib/JSONBValidation/JSONBValidation.ts

@@ -1,4 +1,4 @@
-import { getKeys, getObjectEntries, isObject, JSONB } from "prostgles-types";
+import { getKeys, getObjectEntries, isEmpty, isObject, JSONB } from "prostgles-types";
 
 export const getFieldTypeObj = (rawFieldType: JSONB.FieldType): JSONB.FieldTypeObj => {
   if (typeof rawFieldType === "string") return { type: rawFieldType };
@@ -51,36 +51,35 @@ const getValidator = (type: Extract<DataType, string>) => {
 };
 
 const getPropertyValidationError = (
-  key: string,
-  val: any,
+  value: any,
   rawFieldType: JSONB.FieldType,
   path: string[] = []
 ): string | undefined => {
-  let err = `${[...path, key].join(".")} is of invalid type. Expecting `;
+  const err = `${path.join(".")} is of invalid type. Expecting ${getTypeDescription(rawFieldType).replaceAll("\n", "")}`;
   const fieldType = getFieldTypeObj(rawFieldType);
+
   const { type, allowedValues, nullable, optional } = fieldType;
-  if (nullable && val === null) return;
-  if (optional && val === undefined) return;
+  if (nullable && value === null) return;
+  if (optional && value === undefined) return;
   if (allowedValues) {
     throw new Error(`Allowed values are not supported for validation`);
   }
   if (type) {
     if (isObject(type)) {
-      if (!isObject(val)) {
-        return `${[...path, key].join(".")} is of invalid type. Expecting object`;
+      if (!isObject(value)) {
+        return err;
       }
       for (const [subKey, subSchema] of getObjectEntries(type)) {
-        const error = getPropertyValidationError(subKey, val[subKey], subSchema, [...path, key]);
-        if (error) {
+        const error = getPropertyValidationError(value[subKey], subSchema, [...path, subKey]);
+        if (error !== undefined) {
           return error;
         }
       }
       return;
     }
-    err += type;
 
     const { validator } = getValidator(type);
-    const isValid = validator(val);
+    const isValid = validator(value);
     if (!isValid) {
       return err;
     }
@@ -91,14 +90,102 @@ const getPropertyValidationError = (
     const otherOptions = [];
     if (fieldType.nullable) otherOptions.push(null);
     if (fieldType.optional) otherOptions.push(undefined);
-    err += `one of: ${JSON.stringify([...fieldType.enum, ...otherOptions]).slice(1, -1)}`;
+    // err += `one of: ${JSON.stringify([...fieldType.enum, ...otherOptions]).slice(1, -1)}`;
 
-    if (!fieldType.enum.includes(val)) return err;
+    if (!fieldType.enum.includes(value)) return err;
+    return;
+  }
+  if (fieldType.oneOf) {
+    if (!fieldType.oneOf.length) {
+      return err + "to not be empty";
+    }
+    let firstError: string | undefined;
+    const validMember = fieldType.oneOf.find((member) => {
+      const error = getPropertyValidationError(value, member, path);
+      firstError ??= error;
+      return error === undefined;
+    });
+    if (validMember) {
+      return;
+    }
+    return err;
+  }
+  if (fieldType.record) {
+    const { keysEnum, partial, values: valuesSchema } = fieldType.record;
+    if (!isObject(value)) {
+      return err + "object";
+    }
+    if (partial && isEmpty(value)) {
+      return;
+    }
+    const valueKeys = getKeys(value);
+    const missingKey = partial ? undefined : keysEnum?.find((key) => !valueKeys.includes(key));
+    if (missingKey !== undefined) {
+      return `${err} to have key ${missingKey}`;
+    }
+    const extraKeys = valueKeys.filter((key) => !keysEnum?.includes(key));
+    if (extraKeys.length) {
+      return `${err} has extra keys: ${extraKeys}`;
+    }
+    if (valuesSchema) {
+      for (const [propKey, propValue] of Object.entries(value)) {
+        const valError = getPropertyValidationError(propValue, valuesSchema, [...path, propKey]);
+        if (valError !== undefined) {
+          return `${valError}`;
+        }
+      }
+    }
     return;
   }
   return `Could not validate field type: ${JSON.stringify(fieldType)}`;
 };
 
+const getTypeDescription = (schema: JSONB.FieldType): string => {
+  const schemaObj = getFieldTypeObj(schema);
+  const { type, nullable, optional, oneOf, record } = schemaObj;
+  const allowedTypes: any[] = [];
+  if (nullable) allowedTypes.push("null");
+  if (optional) allowedTypes.push("undefined");
+  if (typeof type === "string") {
+    allowedTypes.push(type);
+  } else if (type) {
+    if (isObject(type)) {
+      const keyOpts: string[] = [];
+      Object.entries(type).forEach(([key, value]) => {
+        keyOpts.push(`${key}: ${getTypeDescription(value)}`);
+      });
+      allowedTypes.push(`{ ${keyOpts.join("; ")} }`);
+    }
+  }
+  schemaObj.enum?.forEach((v) => {
+    if (v === null) {
+      allowedTypes.push("null");
+    } else if (v === undefined) {
+      allowedTypes.push("undefined");
+    } else if (typeof v === "string") {
+      allowedTypes.push(JSON.stringify(v));
+    } else {
+      allowedTypes.push(v);
+    }
+  });
+  oneOf?.forEach((v) => {
+    const type = getTypeDescription(v);
+    allowedTypes.push(type);
+  });
+  if (record) {
+    const { keysEnum, partial, values } = record;
+    const optional = partial ? "?" : "";
+    const valueType = !values ? "any" : getTypeDescription(values);
+    if (keysEnum) {
+      allowedTypes.push(`{ [${keysEnum.join(" | ")}]${optional}: ${valueType} }`);
+    } else {
+      allowedTypes.push(`{ [key: string]${optional}: ${valueType} }`);
+    }
+  }
+
+  return allowedTypes.join(" | ");
+};
+
 export const getJSONBObjectSchemaValidationError = <S extends JSONB.ObjectType["type"]>(
   schema: S,
   obj: any,
@@ -110,7 +197,7 @@ export const getJSONBObjectSchemaValidationError = <S extends JSONB.ObjectType["
     return { error: `Expecting ${objName} to be an object` };
   }
   for (const [k, objSchema] of Object.entries(schema)) {
-    const error = getPropertyValidationError(k, obj[k], objSchema);
+    const error = getPropertyValidationError(obj[k], objSchema, [k]);
     if (error) {
       return { error };
     }

package/lib/JSONBValidation/getJSONBSchemaTSTypes.ts

@@ -1,6 +1,6 @@
 import { getKeys, isObject, type JSONB, type TableSchema } from "prostgles-types";
 import { postgresToTsType } from "../DboBuilder/DboBuilder";
-import { asValue } from "../PubSubManager/PubSubManager";
+import { asValue } from "../PubSubManager/PubSubManagerUtils";
 import { getFieldTypeObj } from "./JSONBValidation";
 
 type ColOpts = { nullable?: boolean };
@@ -11,124 +11,124 @@ export function getJSONBSchemaTSTypes(
   outerLeading = "",
   tables: TableSchema[]
 ): string {
-  const getFieldType = (
-    rawFieldType: JSONB.FieldType,
-    isOneOf = false,
-    innerLeading = "",
-    depth = 0
-  ): string => {
-    const fieldType = getFieldTypeObj(rawFieldType);
-    const nullType = fieldType.nullable ? `null | ` : "";
+  return getJSONBTSTypes(
+    tables,
+    { ...(schema as JSONB.FieldTypeObj), nullable: colOpts.nullable },
+    undefined,
+    outerLeading
+  );
+}
 
-    /** Primitives */
-    if (typeof fieldType.type === "string") {
-      const correctType = fieldType.type
-        .replace("integer", "number")
-        .replace("time", "string")
-        .replace("timestamp", "string")
-        .replace("Date", "string");
+export const getJSONBTSTypes = (
+  tables: TableSchema[],
+  rawFieldType: JSONB.FieldType,
+  isOneOf = false,
+  innerLeading = "",
+  depth = 0
+): string => {
+  const fieldType = getFieldTypeObj(rawFieldType);
+  const nullType = fieldType.nullable ? `null | ` : "";
 
-      if (fieldType.allowedValues && fieldType.type.endsWith("[]")) {
-        return (
-          nullType + ` (${fieldType.allowedValues.map((v) => JSON.stringify(v)).join(" | ")})[]`
-        );
-      }
-      return nullType + correctType;
+  /** Primitives */
+  if (typeof fieldType.type === "string") {
+    const correctType = fieldType.type
+      .replace("integer", "number")
+      .replace("time", "string")
+      .replace("timestamp", "string")
+      .replace("Date", "string");
 
-      /** Object */
-    } else if (isObject(fieldType.type)) {
-      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) {
-        objDef = addSemicolonIfMissing(objDef);
-      }
+    if (fieldType.allowedValues && fieldType.type.endsWith("[]")) {
+      return nullType + ` (${fieldType.allowedValues.map((v) => JSON.stringify(v)).join(" | ")})[]`;
+    }
+    return nullType + correctType;
 
-      /** Keep single line */
-      if (isOneOf) {
-        objDef = objDef.split("\n").join("");
-      }
-      return nullType + objDef;
-    } else if (fieldType.enum) {
-      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("")
-      );
-    } 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 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 },
-              },
+    /** Object */
+  } else if (isObject(fieldType.type)) {
+    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(getJSONBTSTypes(tables, fieldType, true, undefined, depth + 1))
+          );
+        })
+        .join(" ") +
+      `${spacing}}`;
+    if (!isOneOf) {
+      objDef = addSemicolonIfMissing(objDef);
+    }
+
+    /** Keep single line */
+    if (isOneOf) {
+      objDef = objDef.split("\n").join("");
+    }
+    return nullType + objDef;
+  } else if (fieldType.enum) {
+    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} | ` + getJSONBTSTypes(tables, v, true, undefined, depth + 1))
+        .join("")
+    );
+  } else if (fieldType.arrayOf || fieldType.arrayOfType) {
+    const arrayOf = fieldType.arrayOf || { type: fieldType.arrayOfType };
+    return `${fieldType.nullable ? `null | ` : ""} ( ${getJSONBTSTypes(tables, 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" : getJSONBTSTypes(tables, values, true, undefined, depth + 1)}`)}`;
+  } else if (fieldType.lookup) {
+    const l = fieldType.lookup;
+    if (l.type === "data-def") {
+      return `${fieldType.nullable ? `null |` : ""} ${getJSONBTSTypes(tables, {
+        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: {} },
           },
-        })}`;
-      }
+          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");
-        } else {
-          type =
-            !cols ? "any" : (
-              `{ ${cols.map((c) => `${JSON.stringify(c.name)}: ${c.is_nullable ? "null | " : ""} ${postgresToTsType(c.udt_name)}; `).join(" ")} }`
-            );
-        }
+    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");
+      } else {
+        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 JSONB.FieldTypeObj), nullable: colOpts.nullable },
-    undefined,
-    outerLeading
-  );
-}
+    }
+    return `${fieldType.nullable ? `null | ` : ""}${type}${l.isArray ? "[]" : ""}`;
+  } else throw "Unexpected getSchemaTSTypes: " + JSON.stringify({ fieldType }, null, 2);
+};
 
 const isValidIdentifier = (str: string) => {
   const identifierRegex = /^[A-Za-z$_][A-Za-z0-9$_]*$/;