prostgles-server 4.2.159 → 4.2.161

package/lib/JSONBValidation/validate_jsonb_schema_sql.ts

@@ -0,0 +1,502 @@
+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 validate_jsonb_schema_sql = `
+
+/* 
+* ${PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID}
+*/
+
+CREATE OR REPLACE FUNCTION ${VALIDATE_SCHEMA_FUNCNAME}(
+  jsonb_schema TEXT, 
+  data JSONB, 
+  context JSONB DEFAULT '{}'::JSONB, /* { table: string; column: string; silent: boolean } */
+  checked_path TEXT[] DEFAULT ARRAY[]::TEXT[]
+) RETURNS boolean AS 
+$f$
+DECLARE
+  sub_schema RECORD;
+  array_element RECORD;
+  obj_key_val RECORD;
+  schema JSONB;
+  path text;
+  allowed_types text[] = '{${JSONB_DATA_TYPES.join(",")}}';
+  typeStr TEXT = NULL; 
+  optional boolean;
+  nullable boolean; 
+  colname TEXT = COALESCE(context->>'column', '');
+  tablename TEXT = COALESCE(context->>'table', '');
+  oneof JSONB;
+  arrayof JSONB;
+  lookup_data_def_schema TEXT = $d$  
+    { 
+      "type": { "enum": ["data", "data-def"] },
+      "table": "string",
+      "column": "string",
+      "lookup": { "type": "any", "optional": true },
+      "isArray": { "type": "boolean", "optional": true },
+      "filter": { "optional": true, "type": "any" },
+      "isFullRow": { "optional": true, "type": {
+        "displayColumns": { "optional": true, "type": "string[]" }
+      }},
+      "searchColumns": { "optional": true, "type": "string[]" },
+      "showInRowCard": { "optional": true, "type": "any" }
+    }  
+  
+  $d$;
+  lookup_schema_schema TEXT = $d$  
+    { 
+      "type": { "enum": ["schema"] },
+      "object": { "enum": ["table", "column"] },
+      "isArray": { "type": "boolean", "optional": true },
+      "lookup": { "type": "any", "optional": true },
+      "filter": { "optional": true, "type": "any" }
+    }  
+  $d$;
+
+  extra_keys TEXT[];
+
+  /* Used for oneOf schema errors */
+  v_state   TEXT;
+  v_msg     TEXT;
+  v_detail  TEXT;
+  v_hint    TEXT;
+  v_context TEXT;
+  v_one_of_errors TEXT;
+
+BEGIN
+  path = concat_ws(', ', 
+    'Path: ' || array_to_string(checked_path, '.'), 
+    'Data: ' || data::TEXT, 
+    'JSONBSchema: ' || schema::TEXT
+  );
+
+  IF length(jsonb_schema) = 0 THEN
+    ${raiseException(`'Empty schema. %', path`)}
+  END IF;
+
+  /* Sometimes text comes double quoted from jsonb, e.g.: '"string"' */
+  jsonb_schema = CASE WHEN jsonb_schema::text ilike '"%"' THEN  LEFT(RIGHT(jsonb_schema::text, -1), -1) ELSE jsonb_schema END;
+
+  /* 'string' */
+  IF ARRAY[jsonb_schema] <@ allowed_types THEN
+    schema = jsonb_build_object('type', jsonb_schema);
+  /* { "type": ... } */ 
+  ELSIF BTRIM(replace(jsonb_schema,E'\n','')) ILIKE '{%' THEN
+    schema = jsonb_schema::JSONB;
+  ELSE
+    ${raiseException(`$$Invalid schema. Expecting 'typename' or { "type": "typename" } but received: %, %$$, jsonb_schema, path`)} 
+  END IF;
+
+
+  nullable = COALESCE((schema->>'nullable')::BOOLEAN, FALSE);
+  IF data IS NULL OR jsonb_typeof(data) = 'null' THEN
+    IF NOT nullable THEN
+      ${raiseException(`'Is not nullable. %', path`)}  
+    ELSE
+      RETURN true;
+    END IF;
+  END IF;
+  
+  IF schema ? 'enum' THEN 
+    IF 
+      jsonb_typeof(schema->'enum') != 'array' OR 
+      jsonb_array_length(schema->'enum') < 1 
+    THEN
+      ${raiseException(`'Invalid schema enum (%) .Must be a non empty array %', schema->'enum', path`)}  
+    END IF;
+    
+    IF NOT jsonb_build_array(data) <@ (schema->'enum') THEN
+      ${raiseException(`'Data not in allowed enum list (%), %', schema->'enum', path`)}  
+    END IF;
+
+  ELSIF schema ? 'lookup' THEN
+
+    /* TODO: Finish validating data-def */
+    IF (schema->'lookup'->>'type' = 'data-def') THEN
+      RETURN TRUE;
+    END IF;
+
+    /* Validate lookup schema */
+    IF NOT ${VALIDATE_SCHEMA_FUNCNAME}(
+      '{ "oneOfType": [' || concat_ws(',',lookup_data_def_schema, lookup_schema_schema)  || '] }',
+      schema->'lookup',
+      context,
+      checked_path || '.schema'::TEXT
+    ) THEN
+      
+      RETURN FALSE;
+    END IF;
+
+    RETURN ${VALIDATE_SCHEMA_FUNCNAME}(
+      CASE WHEN schema->'lookup'->>'type' = 'data-def' THEN
+        lookup_data_def_schema
+      WHEN schema->'lookup'->>'type' = 'schema' THEN 
+        ( 
+          CASE WHEN schema->'lookup'->>'object' = 'table' THEN 
+            'string' || (CASE WHEN (schema->'lookup'->'isArray')::BOOLEAN THEN '[]' ELSE '' END)
+          ELSE 
+            '{ "type": { "table": "string", "column": "string' || (CASE WHEN (schema->'lookup'->'isArray')::BOOLEAN THEN '[]' ELSE '' END) || '" } }' 
+          END
+        )
+      ELSE 
+        (CASE WHEN (schema->'lookup'->'isArray')::BOOLEAN THEN 'any[]' ELSE 'any' END)
+      END,
+      data,
+      context,
+      checked_path
+    );
+
+  ELSIF schema ? 'type' THEN    
+    
+    IF jsonb_typeof(schema->'type') = 'string' THEN
+      typeStr = schema->>'type';
+      IF NOT ARRAY[typeStr] <@ allowed_types THEN
+        ${raiseException(`'Bad schema type "%", allowed types: %. %',typeStr, allowed_types, path`)}  
+      END IF;
+      
+      /** Primitive array */
+      IF typeStr LIKE '%[]' THEN
+ 
+        typeStr = left(typeStr, -2);
+
+        IF jsonb_typeof(data) != 'array' THEN
+          ${raiseException(`'Types not matching. Expecting an array. %', path`)}  
+        END IF;
+
+        FOR array_element IN
+          SELECT value, row_number() OVER() -1 as idx
+          FROM jsonb_array_elements(data)
+        LOOP
+          IF NOT ${VALIDATE_SCHEMA_FUNCNAME}(
+              CASE WHEN schema->'allowedValues' IS NOT NULL THEN 
+                jsonb_build_object('type', typeStr, 'allowedValues', schema->'allowedValues')::TEXT
+              ELSE typeStr END, 
+              array_element.value, 
+              context,
+              checked_path || array_element.idx::TEXT
+          ) THEN
+            
+            RETURN FALSE;
+          END IF;
+        END LOOP;
+
+        RETURN TRUE;
+
+      /** Primitive */
+      ELSE 
+
+        IF (
+          typeStr = 'number' AND jsonb_typeof(data) != typeStr OR
+          (typeStr = 'integer' AND (jsonb_typeof(data) != 'number' OR ceil(data::NUMERIC) != floor(data::NUMERIC))) OR
+          typeStr = 'boolean' AND jsonb_typeof(data) != typeStr OR
+          typeStr = 'string' AND jsonb_typeof(data) != typeStr OR
+          typeStr = 'any' AND jsonb_typeof(data) = 'null'
+        ) THEN
+          ${raiseException(`'Data type not matching. Expected: %, Actual: %, %', typeStr, jsonb_typeof(data), path`)}  
+        END IF;
+
+        IF schema ? 'allowedValues' AND NOT(jsonb_build_array(data) <@ (schema->'allowedValues')) THEN
+          IF (
+            SELECT COUNT(distinct jsonb_typeof(value))
+            FROM jsonb_array_elements(schema->'allowedValues')
+          ) > 1 THEN
+            ${raiseException(`'Invalid schema. schema.allowedValues (%) contains more than one data type . %', schema->>'allowedValues', path`)}  
+          END IF;
+
+          IF EXISTS(
+            SELECT 1
+            FROM jsonb_array_elements(schema->'allowedValues')
+            WHERE jsonb_typeof(value) != jsonb_typeof(data)
+          ) THEN
+            ${raiseException(`'Invalid schema. schema.allowedValues (%) contains contains values not matchine the schema.type %', schema->>'allowedValues', path`)}  
+          END IF;
+
+          ${raiseException(`'Data not in allowedValues (%). %', schema->>'allowedValues', path`)}  
+
+        END IF;
+
+      END IF;
+
+    /* Object */
+    ELSIF jsonb_typeof(schema->'type') = 'object' THEN
+
+      IF jsonb_typeof(data) != 'object' THEN
+        ${raiseException(`E'Expecting an object: \n %', path`)}  
+      END IF;
+
+      extra_keys = ARRAY(SELECT k FROM (
+        SELECT jsonb_object_keys(data) as k
+        EXCEPT
+        SELECT jsonb_object_keys(schema->'type') as k
+      ) t);
+
+      IF array_length(extra_keys, 1) > 0 THEN
+        ${raiseException(`E'Object contains % invalid keys: [ % ] \n %', array_length(extra_keys, 1)::TEXT, array_to_string(extra_keys, ', '), path`)}  
+      END IF;
+      
+      FOR sub_schema IN
+        SELECT key, value
+        FROM jsonb_each(schema->'type')
+      LOOP
+
+        optional = COALESCE((sub_schema.value->>'optional')::BOOLEAN, FALSE);
+        IF NOT (data ? sub_schema.key) THEN
+          IF NOT optional THEN
+            ${raiseException(`'Types not matching. Required property ("%") is missing. %', sub_schema.key , path`)}  
+          END IF;
+
+        ELSIF NOT ${VALIDATE_SCHEMA_FUNCNAME}(
+          -- sub_schema.value::TEXT, 
+          CASE WHEN jsonb_typeof(sub_schema.value) = 'string' THEN TRIM(both '"' from sub_schema.value::TEXT) ELSE sub_schema.value::TEXT END,
+          data->sub_schema.key, 
+          context,
+          checked_path || sub_schema.key
+        ) THEN
+          RETURN false;
+        END IF;
+
+      END LOOP;
+
+      RETURN TRUE;
+    ELSE 
+      ${raiseException(`'Unexpected schema.type ( % ), %',jsonb_typeof(schema->'type'), path`)}  
+    END IF; 
+
+  /* oneOfType: [{ key_name: { type: "string" } }] */
+  ELSIF (schema ? 'oneOf' OR schema ? 'oneOfType') THEN 
+
+    oneof = COALESCE(schema->'oneOf', schema->'oneOfType');
+
+    IF jsonb_typeof(oneof) != 'array' THEN
+      ${raiseException(`'Unexpected oneOf schema. Expecting an array of objects but received: % , %', oneof::TEXT, path`)}  
+    END IF;
+
+    FOR sub_schema IN
+      SELECT CASE WHEN schema ? 'oneOfType' THEN jsonb_build_object('type', value) ELSE value END as value, 
+        row_number() over() - 1 as idx
+      FROM jsonb_array_elements(oneof)
+    LOOP
+
+      BEGIN
+
+        IF ${VALIDATE_SCHEMA_FUNCNAME}(
+          sub_schema.value::TEXT, 
+          data, 
+          context,
+          checked_path
+        ) THEN
+          RETURN true;
+        END IF;
+
+      /* Ignore exceptions in case the last schema will match */
+      EXCEPTION WHEN others THEN
+
+        GET STACKED DIAGNOSTICS
+          v_state   = returned_sqlstate,
+          v_msg     = message_text,
+          v_detail  = pg_exception_detail,
+          v_hint    = pg_exception_hint,
+          v_context = pg_exception_context;
+
+        /* Ignore duplicate errors */
+        IF v_one_of_errors IS NULL OR v_one_of_errors NOT ilike '%' || v_msg || '%' THEN
+          v_one_of_errors = concat_ws(
+            E'\n\n', 
+            v_one_of_errors,  
+            concat_ws(
+              ', ', 
+              'Schema index ' || sub_schema.idx::TEXT || ' error:', 
+              'state: ' || v_state, 
+              'message: ' || v_msg,
+              'detail: ' || v_detail,
+              'hint: ' || v_hint
+              -- 'context: ' || v_context
+            )
+          );
+        END IF;
+      END;
+
+    END LOOP;
+
+    ${raiseException(`E'No oneOf schemas matching:\n  % ), %', v_one_of_errors, path`)}  
+
+  /* arrayOfType: { key_name: { type: "string" } } */
+  ELSIF (schema ? 'arrayOf' OR schema ? 'arrayOfType') THEN
+
+    arrayof = COALESCE(schema->'arrayOf', schema->'arrayOfType');
+
+    IF jsonb_typeof(data) != 'array' THEN
+      ${raiseException(`'% is not an array.', path`)}  
+    END IF;
+
+    FOR array_element IN 
+      SELECT value, row_number() OVER() -1 as idx  
+      FROM jsonb_array_elements(data)
+    LOOP
+      IF NOT ${VALIDATE_SCHEMA_FUNCNAME}(
+        ( CASE WHEN schema ? 'arrayOf' 
+          THEN 
+            schema->'arrayOf' 
+          ELSE 
+          (schema - 'arrayOfType' || jsonb_build_object('type', schema->'arrayOfType')) 
+          END
+        )::TEXT,
+        array_element.value, 
+        context,
+        checked_path || array_element.idx::TEXT
+      ) THEN
+        RETURN false;
+      END IF; 
+    END LOOP;
+  
+  /* record: { keysEnum?: string[], values?: FieldType } */
+  ELSIF schema ? 'record' THEN
+    IF 
+      jsonb_typeof(schema->'record') != 'object' OR 
+      NOT (schema->'record') ? 'keysEnum' 
+      AND NOT (schema->'record') ? 'values'
+    THEN
+      ${raiseException(`'Invalid/empty record schema. Expecting a non empty record of: { keysEnum?: string[]; values?: FieldType } : %, %', schema, path`)}  
+    END IF;
+
+    IF jsonb_typeof(data) != 'object' THEN
+      ${raiseException(`'% is not an object.', path`)}  
+    END IF;
+
+    FOR obj_key_val IN
+      SELECT jsonb_build_object('key',  key, 'value', value) as obj
+      FROM jsonb_each(data)
+    LOOP
+      RETURN (CASE WHEN NOT (schema->'record') ? 'keysEnum' THEN TRUE ELSE ${VALIDATE_SCHEMA_FUNCNAME}( 
+        jsonb_build_object('enum', schema->'record'->'keysEnum')::TEXT,
+        (obj_key_val.obj)->'key', 
+        context,
+        checked_path || ARRAY[(obj_key_val.obj)->>'key']
+      ) END) 
+      AND 
+      (CASE WHEN NOT (schema->'record') ? 'values' THEN TRUE ELSE ${VALIDATE_SCHEMA_FUNCNAME}(
+        schema->'record'->>'values', 
+        (obj_key_val.obj)->'value', 
+        context,
+        checked_path || ARRAY[(obj_key_val.obj)->>'key']
+      ) END);
+    END LOOP;
+
+  ELSE
+    ${raiseException(`'Unexpected schema: %, %', schema, path`)}
+  END IF;
+  
+  RETURN true;
+END;
+$f$ LANGUAGE 'plpgsql' IMMUTABLE;
+
+COMMENT ON FUNCTION ${VALIDATE_SCHEMA_FUNCNAME}  /* ${PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID} */
+IS $$prostgles-server internal function used in column CHECK conditions to validate jsonb data against a column schema specified in tableConfig.
+Example usage:
+validate_jsonb_schema(
+  '{ "type": { "a": "number[]" } }', 
+  '{ "a": [2] }'
+)
+$$;
+ 
+
+/* TESTS */
+
+SELECT ${VALIDATE_SCHEMA_FUNCNAME}(
+  '{ "enum": ["a", "b", 2] }', 
+  '"a"'::JSONB
+);
+
+
+SELECT ${VALIDATE_SCHEMA_FUNCNAME}(
+  '{ "record": { "keysEnum": ["a", "b"] , "values": { "enum": [1, 2] } } }', 
+  '{"a": 1, "b": 2 }'::JSONB
+);
+
+SELECT ${VALIDATE_SCHEMA_FUNCNAME}(
+  '{ "record": { "keysEnum": ["a", "b"] , "values": { "enum": [1, 2] } } }', 
+  '{"a": 1 }'::JSONB
+);
+
+SELECT ${VALIDATE_SCHEMA_FUNCNAME}(
+  '{ "record": { "keysEnum": ["a", "b"] , "values": { "enum": [1, 2] } } }', 
+  '{ }'::JSONB
+);
+
+SELECT ${VALIDATE_SCHEMA_FUNCNAME}(
+  '{ "record": { "keysEnum": ["a", "b"]    } }', 
+  '{"a": 1, "b": 2 }'::JSONB
+);
+SELECT ${VALIDATE_SCHEMA_FUNCNAME}(
+  '{ "enum": ["a", "b", 2] }', 
+  '2'::JSONB
+);
+
+SELECT ${VALIDATE_SCHEMA_FUNCNAME}(
+  '{ 
+    "oneOfType": [
+      { "a": "string" } , 
+      {
+        "a": {
+          "type": "boolean", 
+          "allowedValues": [false], 
+          "optional": true 
+        }
+      }
+    ] 
+  }', 
+  '{ "a": false }'
+);
+
+SELECT ${VALIDATE_SCHEMA_FUNCNAME}(
+  '{ "arrayOfType": { "a": "string", "narr": { "arrayOfType": { "a": { "type": "string", "optional": false, "nullable": true } } } } }', 
+  '[{ "a": "ddd", "narr": [{ "a": null }] }]'::JSONB
+);
+
+SELECT ${VALIDATE_SCHEMA_FUNCNAME}(
+  '{ "type": { "a": { "type": "integer[]", "allowedValues": [2] } } }'::TEXT, 
+  '{ "a": [2, 2] }'
+); 
+
+SELECT ${VALIDATE_SCHEMA_FUNCNAME}(
+  '{ "type": { "a": { "type": "string[]", "allowedValues": ["2"] } } }'::TEXT, 
+  '{ "a": ["2"] }'
+);
+
+SELECT ${VALIDATE_SCHEMA_FUNCNAME}('{ "type": "any"}', '{}');
+
+SELECT ${VALIDATE_SCHEMA_FUNCNAME}('{ "type": { "a": { "enum": ["a"] } } }', '{ "a": "a"}');
+
+SELECT ${VALIDATE_SCHEMA_FUNCNAME}('{ "arrayOfType": { "a": { "enum": ["a"] } } }', '[{ "a": "a"}]');
+
+
+SELECT ${VALIDATE_SCHEMA_FUNCNAME}('{ "lookup": { "type": "data", "table": "tblName", "column": "colName" } }', '{}');
+SELECT ${VALIDATE_SCHEMA_FUNCNAME}('{ "lookup": { "type": "data", "table": "tblName", "column": "colName", "isArray": true } }', '[{}]');
+SELECT ${VALIDATE_SCHEMA_FUNCNAME}('{ "lookup": { "type": "schema", "object": "table" } }', '"tblName"'::JSONB);
+SELECT ${VALIDATE_SCHEMA_FUNCNAME}('{ "lookup": { "type": "schema", "object": "table", "isArray": true } }', '["tblName"]');
+SELECT ${VALIDATE_SCHEMA_FUNCNAME}('{ "lookup": { "type": "schema", "object": "column" } }', '{  "table": "tblName", "column": "colName" }');
+SELECT ${VALIDATE_SCHEMA_FUNCNAME}('{ "lookup": { "type": "schema", "object": "column", "isArray": true } }', '{  "table": "tblName", "column": ["colName"] }');
+
+SELECT ${VALIDATE_SCHEMA_FUNCNAME}('{ "type": "time"}', '"22:22"');
+SELECT ${VALIDATE_SCHEMA_FUNCNAME}('{ "type": "Date"}', '"2222-22-22"');
+
+
+SELECT ${VALIDATE_SCHEMA_FUNCNAME}('{ "oneOf": ["number"]}','2');
+`;
+ 

package/lib/JSONBValidation/validation.ts

@@ -0,0 +1,143 @@
+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 };
+
+  return rawFieldType;
+} 
+
+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]!)
+      });
+    }
+    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);
+
+  } else if (fieldType.enum) {
+    err += `on of: ${fieldType.enum}`;
+    if (!fieldType.enum.includes(val)) throw new Error(err)
+  }
+  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]!));
+}
+
+
+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 | ` : "");
+    
+    /** Primitives */
+    if (typeof fieldType?.type === "string") {
+      const correctType = fieldType.type
+        .replace("integer", "number")
+        .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 + correctType;
+
+    /** 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);
+      }
+    
+      /** 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 } 
+              }}, 
+              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(" ")} }`
+        }
+      }
+      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);
+}