prostgles-server 4.0.57 → 4.0.59

package/lib/JSONBValidation/validate_jsonb_schema_sql.js

@@ -1,500 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validate_jsonb_schema_sql = exports.JSONB_DATA_TYPES = exports.VALIDATE_SCHEMA_FUNCNAME = void 0;
-const prostgles_types_1 = require("prostgles-types");
-const PubSubManager_1 = require("../PubSubManager/PubSubManager");
-const raiseException = (err) => `
-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;
-`;
-exports.VALIDATE_SCHEMA_FUNCNAME = "validate_jsonb_schema";
-exports.JSONB_DATA_TYPES = [
-    ...prostgles_types_1.DATA_TYPES,
-    "Lookup", "Lookup[]"
-];
-exports.validate_jsonb_schema_sql = `
-
-/* 
-* ${PubSubManager_1.PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID}
-*/
-
-CREATE OR REPLACE FUNCTION ${exports.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[] = '{${exports.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 ${exports.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 ${exports.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 ${exports.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 ${exports.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 ${exports.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 ${exports.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 ${exports.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 ${exports.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 ${exports.VALIDATE_SCHEMA_FUNCNAME}  /* ${PubSubManager_1.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 ${exports.VALIDATE_SCHEMA_FUNCNAME}(
-  '{ "enum": ["a", "b", 2] }', 
-  '"a"'::JSONB
-);
-
-
-SELECT ${exports.VALIDATE_SCHEMA_FUNCNAME}(
-  '{ "record": { "keysEnum": ["a", "b"] , "values": { "enum": [1, 2] } } }', 
-  '{"a": 1, "b": 2 }'::JSONB
-);
-
-SELECT ${exports.VALIDATE_SCHEMA_FUNCNAME}(
-  '{ "record": { "keysEnum": ["a", "b"] , "values": { "enum": [1, 2] } } }', 
-  '{"a": 1 }'::JSONB
-);
-
-SELECT ${exports.VALIDATE_SCHEMA_FUNCNAME}(
-  '{ "record": { "keysEnum": ["a", "b"] , "values": { "enum": [1, 2] } } }', 
-  '{ }'::JSONB
-);
-
-SELECT ${exports.VALIDATE_SCHEMA_FUNCNAME}(
-  '{ "record": { "keysEnum": ["a", "b"]    } }', 
-  '{"a": 1, "b": 2 }'::JSONB
-);
-SELECT ${exports.VALIDATE_SCHEMA_FUNCNAME}(
-  '{ "enum": ["a", "b", 2] }', 
-  '2'::JSONB
-);
-
-SELECT ${exports.VALIDATE_SCHEMA_FUNCNAME}(
-  '{ 
-    "oneOfType": [
-      { "a": "string" } , 
-      {
-        "a": {
-          "type": "boolean", 
-          "allowedValues": [false], 
-          "optional": true 
-        }
-      }
-    ] 
-  }', 
-  '{ "a": false }'
-);
-
-SELECT ${exports.VALIDATE_SCHEMA_FUNCNAME}(
-  '{ "arrayOfType": { "a": "string", "narr": { "arrayOfType": { "a": { "type": "string", "optional": false, "nullable": true } } } } }', 
-  '[{ "a": "ddd", "narr": [{ "a": null }] }]'::JSONB
-);
-
-SELECT ${exports.VALIDATE_SCHEMA_FUNCNAME}(
-  '{ "type": { "a": { "type": "integer[]", "allowedValues": [2] } } }'::TEXT, 
-  '{ "a": [2, 2] }'
-); 
-
-SELECT ${exports.VALIDATE_SCHEMA_FUNCNAME}(
-  '{ "type": { "a": { "type": "string[]", "allowedValues": ["2"] } } }'::TEXT, 
-  '{ "a": ["2"] }'
-);
-
-SELECT ${exports.VALIDATE_SCHEMA_FUNCNAME}('{ "type": "any"}', '{}');
-
-SELECT ${exports.VALIDATE_SCHEMA_FUNCNAME}('{ "type": { "a": { "enum": ["a"] } } }', '{ "a": "a"}');
-
-SELECT ${exports.VALIDATE_SCHEMA_FUNCNAME}('{ "arrayOfType": { "a": { "enum": ["a"] } } }', '[{ "a": "a"}]');
-
-
-SELECT ${exports.VALIDATE_SCHEMA_FUNCNAME}('{ "lookup": { "type": "data", "table": "tblName", "column": "colName" } }', '{}');
-SELECT ${exports.VALIDATE_SCHEMA_FUNCNAME}('{ "lookup": { "type": "data", "table": "tblName", "column": "colName", "isArray": true } }', '[{}]');
-SELECT ${exports.VALIDATE_SCHEMA_FUNCNAME}('{ "lookup": { "type": "schema", "object": "table" } }', '"tblName"'::JSONB);
-SELECT ${exports.VALIDATE_SCHEMA_FUNCNAME}('{ "lookup": { "type": "schema", "object": "table", "isArray": true } }', '["tblName"]');
-SELECT ${exports.VALIDATE_SCHEMA_FUNCNAME}('{ "lookup": { "type": "schema", "object": "column" } }', '{  "table": "tblName", "column": "colName" }');
-SELECT ${exports.VALIDATE_SCHEMA_FUNCNAME}('{ "lookup": { "type": "schema", "object": "column", "isArray": true } }', '{  "table": "tblName", "column": ["colName"] }');
-
-SELECT ${exports.VALIDATE_SCHEMA_FUNCNAME}('{ "type": "time"}', '"22:22"');
-SELECT ${exports.VALIDATE_SCHEMA_FUNCNAME}('{ "type": "Date"}', '"2222-22-22"');
-
-
-SELECT ${exports.VALIDATE_SCHEMA_FUNCNAME}('{ "oneOf": ["number"]}','2');
-`;

package/lib/JSONBValidation/validation.d.ts

@@ -1,9 +0,0 @@
-import { JSONB, TableSchema } from "prostgles-types";
-export declare function validate<T>(obj: T, key: keyof T, rawFieldType: JSONB.FieldType): boolean;
-export declare function validateSchema<S extends JSONB.ObjectType["type"]>(schema: S, obj: JSONB.GetObjectType<S>, objName?: string, optional?: boolean): void;
-type ColOpts = {
-    nullable?: boolean;
-};
-export declare function getJSONBSchemaTSTypes(schema: JSONB.JSONBSchema, colOpts: ColOpts, outerLeading: string, tables: TableSchema[]): string;
-export {};
-//# sourceMappingURL=validation.d.ts.map

package/lib/JSONBValidation/validation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAYjF,wBAAgB,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,YAAY,EAAE,KAAK,CAAC,SAAS,GAAG,OAAO,CAqBxF;AAED,wBAAgB,cAAc,CAAC,CAAC,SAAS,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,QAAQ,UAAQ,QAG5I;AAGD,KAAK,OAAO,GAAG;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAGtC,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,KAAK,CAAC,WAAW,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,QAAK,EAAE,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CA2FnI"}

package/lib/JSONBValidation/validation.js

@@ -1,131 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getJSONBSchemaTSTypes = exports.validateSchema = exports.validate = void 0;
-const prostgles_types_1 = require("prostgles-types");
-const DboBuilder_1 = require("../DboBuilder");
-const PubSubManager_1 = require("../PubSubManager/PubSubManager");
-const getFieldTypeObj = (rawFieldType) => {
-    if (typeof rawFieldType === "string")
-        return { type: rawFieldType };
-    return rawFieldType;
-};
-function validate(obj, key, rawFieldType) {
-    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") {
-            (0, prostgles_types_1.getKeys)(fieldType.type).forEach(subKey => {
-                validate(val, subKey, fieldType.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;
-}
-exports.validate = validate;
-function validateSchema(schema, obj, objName, optional = false) {
-    if ((!schema || (0, prostgles_types_1.isEmpty)(schema)) && !optional)
-        throw new Error(`Expecting ${objName} to be defined`);
-    (0, prostgles_types_1.getKeys)(schema).forEach(k => validate(obj, k, schema[k]));
-}
-exports.validateSchema = validateSchema;
-function getJSONBSchemaTSTypes(schema, colOpts, outerLeading = "", tables) {
-    const getFieldType = (rawFieldType, isOneOf = false, innerLeading = "", depth = 0) => {
-        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 ((0, prostgles_types_1.isObject)(fieldType.type)) {
-            const addSemicolonIfMissing = (v) => v.trim().endsWith(";") ? v : (v.trim() + ";");
-            const { type } = fieldType;
-            const spacing = isOneOf ? " " : "  ";
-            let objDef = ` {${spacing}` + (0, prostgles_types_1.getKeys)(type).map(k => {
-                const fieldType = getFieldTypeObj(type[k]);
-                return `${spacing}${k}${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 => (0, PubSubManager_1.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 } = fieldType.record;
-            // TODO: ensure props with undefined values are not allowed in the TS type
-            return `${fieldType.nullable ? `null |` : ""} Partial<Record<${keysEnum?.map(v => (0, PubSubManager_1.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 = (0, DboBuilder_1.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 | " : ""} ${(0, DboBuilder_1.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, nullable: colOpts.nullable }, undefined, outerLeading);
-}
-exports.getJSONBSchemaTSTypes = getJSONBSchemaTSTypes;

package/lib/PostgresNotifListenManager.d.ts

@@ -1,28 +0,0 @@
-import { DB } from "./Prostgles";
-import pg from "pg-promise/typescript/pg-subset";
-import pgPromise from "pg-promise";
-export type PrglNotifListener = (args: {
-    length: number;
-    processId: number;
-    channel: string;
-    payload: string;
-    name: string;
-}) => void;
-export declare class PostgresNotifListenManager {
-    connection?: pgPromise.IConnected<{}, pg.IClient>;
-    db_pg: DB;
-    notifListener: PrglNotifListener;
-    db_channel_name: string;
-    isListening: any;
-    client?: pg.IClient;
-    static create: (db_pg: DB, notifListener: PrglNotifListener, db_channel_name: string) => Promise<PostgresNotifListenManager>;
-    constructor(db_pg: DB, notifListener: PrglNotifListener, db_channel_name: string, noInit?: boolean);
-    init(): Promise<PostgresNotifListenManager>;
-    isReady(): any;
-    startListening(): Promise<unknown>;
-    destroyed: boolean;
-    destroy: () => void;
-    stopListening: () => void;
-    reconnect(delay?: number | undefined, maxAttempts?: number | undefined): Promise<unknown>;
-}
-//# sourceMappingURL=PostgresNotifListenManager.d.ts.map

package/lib/PostgresNotifListenManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PostgresNotifListenManager.d.ts","sourceRoot":"","sources":["PostgresNotifListenManager.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AACjC,OAAO,EAAE,MAAM,iCAAiC,CAAC;AACjD,OAAO,SAAS,MAAM,YAAY,CAAC;AAEnC,MAAM,MAAM,iBAAiB,GAAG,CAAC,IAAI,EAAE;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CAChB,KAAK,IAAI,CAAC;AAEX,qBAAa,0BAA0B;IACnC,UAAU,CAAC,EAAE,SAAS,CAAC,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC;IAClD,KAAK,EAAE,EAAE,CAAC;IACV,aAAa,EAAE,iBAAiB,CAAC;IACjC,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,GAAG,CAAC;IACjB,MAAM,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC;IAEpB,MAAM,CAAC,MAAM,6BAA8B,iBAAiB,mBAAmB,MAAM,KAAG,QAAQ,0BAA0B,CAAC,CAG1H;gBAEW,KAAK,EAAE,EAAE,EAAE,aAAa,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,UAAQ;IAS1F,IAAI,IAAI,OAAO,CAAC,0BAA0B,CAAC;IAQjD,OAAO;IAIP,cAAc;IA+Bd,SAAS,UAAS;IAClB,OAAO,aAMN;IAED,aAAa,aAKZ;IAED,SAAS,CAAC,KAAK,GAAE,MAAM,GAAG,SAAa,EAAE,WAAW,GAAE,MAAM,GAAG,SAAa;CA0D/E"}