prostgles-server 4.2.323 → 4.2.324

package/lib/JSONBValidation/JSONBValidation.spec.ts

@@ -1,129 +0,0 @@
-import { test, describe } from "node:test";
-import type { JSONB } from "prostgles-types";
-import { strict as assert } from "assert";
-import { getJSONBObjectSchemaValidationError } from "./JSONBValidation";
-
-void describe("JSONBValidation", async () => {
-  await test("getJSONBObjectSchemaValidationError", () => {
-    const schema: JSONB.ObjectType = {
-      type: {
-        name: "string",
-        age: { type: "integer", nullable: true },
-        address: {
-          type: {
-            street: "string",
-            city: "string",
-            street_number: { type: "integer", optional: true },
-            t: { enum: ["a", "b", "c"], optional: true },
-          },
-        },
-      },
-    };
-    const obj = {
-      name: "John Doe",
-      age: 30,
-      address: {
-        street: "123 Main St",
-        city: "New York",
-      },
-    };
-    assert.deepStrictEqual(getJSONBObjectSchemaValidationError(schema.type, null, "test"), {
-      error: "Expecting test to be an object",
-    });
-    assert.deepStrictEqual(getJSONBObjectSchemaValidationError(schema.type, {}, "test"), {
-      error: "name is of invalid type. Expecting string",
-    });
-    assert.deepStrictEqual(getJSONBObjectSchemaValidationError(schema.type, obj, "test"), {
-      data: obj,
-    });
-    assert.deepStrictEqual(
-      getJSONBObjectSchemaValidationError(schema.type, { ...obj, age: null }, "test"),
-      {
-        data: { ...obj, age: null },
-      }
-    );
-    assert.deepStrictEqual(
-      getJSONBObjectSchemaValidationError(schema.type, { ...obj, age: 22.2 }, "test"),
-      {
-        error: "age is of invalid type. Expecting null | integer",
-      }
-    );
-    assert.deepStrictEqual(
-      getJSONBObjectSchemaValidationError(
-        schema.type,
-        { ...obj, address: { ...obj.address, city: 22 } },
-        "test"
-      ),
-      {
-        error: "address.city is of invalid type. Expecting string",
-      }
-    );
-    assert.deepStrictEqual(
-      getJSONBObjectSchemaValidationError(
-        schema.type,
-        { ...obj, address: { ...obj.address, street_number: 22.22 } },
-        "test"
-      ),
-      { error: "address.street_number is of invalid type. Expecting undefined | integer" }
-    );
-    assert.deepStrictEqual(
-      getJSONBObjectSchemaValidationError(
-        schema.type,
-        { ...obj, address: { ...obj.address, street_number: undefined } },
-        "test"
-      ),
-      { data: { ...obj, address: { ...obj.address, street_number: undefined } } }
-    );
-    assert.deepStrictEqual(
-      getJSONBObjectSchemaValidationError(
-        schema.type,
-        { ...obj, address: { ...obj.address, t: "c" } },
-        "test"
-      ),
-      { data: { ...obj, address: { ...obj.address, t: "c" } } }
-    );
-    assert.deepStrictEqual(
-      getJSONBObjectSchemaValidationError(
-        schema.type,
-        { ...obj, address: { ...obj.address, t: 2 } },
-        "test"
-      ),
-      { 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,246 +0,0 @@
-import { getKeys, getObjectEntries, isDefined, isEmpty, isObject, JSONB } from "prostgles-types";
-
-export const getFieldTypeObj = (rawFieldType: JSONB.FieldType): JSONB.FieldTypeObj => {
-  if (typeof rawFieldType === "string") return { type: rawFieldType };
-
-  return rawFieldType;
-};
-
-type DataType = JSONB.FieldTypeObj["type"];
-type ElementType<T extends DataType> = T extends `${infer E}[]` ? E : never;
-type ArrayTypes = Extract<DataType, `${string}[]`>;
-type NonArrayTypes = Extract<Exclude<DataType, ArrayTypes>, string>;
-const PRIMITIVE_VALIDATORS: Record<NonArrayTypes, (val: any) => boolean> = {
-  string: (val) => typeof val === "string",
-  number: (val) => typeof val === "number" && Number.isFinite(val),
-  integer: (val) => typeof val === "number" && Number.isInteger(val),
-  boolean: (val) => typeof val === "boolean",
-  time: (val) => typeof val === "string",
-  timestamp: (val) => typeof val === "string",
-  any: (val) => typeof val !== "function" && typeof val !== "symbol",
-  Date: (val) => typeof val === "string",
-  Lookup: () => {
-    throw new Error("Lookup type is not supported for validation");
-  },
-};
-const PRIMITIVE_VALIDATORS_KEYS = getKeys(PRIMITIVE_VALIDATORS);
-const getElementType = <T extends DataType>(type: T): undefined | ElementType<T> => {
-  if (typeof type === "string" && type.endsWith("[]")) {
-    const elementType = type.slice(0, -2);
-    if (!PRIMITIVE_VALIDATORS_KEYS.includes(elementType as NonArrayTypes)) {
-      throw new Error(`Unknown array field type ${type}`);
-    }
-    return elementType as ElementType<T>;
-  }
-};
-
-const getValidator = (type: Extract<DataType, string>) => {
-  const elem = getElementType(type);
-  if (elem) {
-    const validator = PRIMITIVE_VALIDATORS[elem];
-    return {
-      isArray: true,
-      validator: (v: any) => Array.isArray(v) && v.every((v) => validator(v)),
-    };
-  }
-  const validator = PRIMITIVE_VALIDATORS[type as NonArrayTypes];
-  if (!(validator as any)) {
-    throw new Error(`Unknown field type ${type}`);
-  }
-  return { isArray: false, validator };
-};
-
-const getPropertyValidationError = (
-  value: any,
-  rawFieldType: JSONB.FieldType,
-  path: string[] = []
-): string | undefined => {
-  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 && 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(value)) {
-        return err;
-      }
-      for (const [subKey, subSchema] of getObjectEntries(type)) {
-        const error = getPropertyValidationError(value[subKey], subSchema, [...path, subKey]);
-        if (error !== undefined) {
-          return error;
-        }
-      }
-      return;
-    }
-
-    const { validator } = getValidator(type);
-    const isValid = validator(value);
-    if (!isValid) {
-      return err;
-    }
-    return;
-  }
-
-  if (fieldType.enum) {
-    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)}`;
-
-    if (!fieldType.enum.includes(value)) return err;
-    return;
-  }
-
-  const arrayOf =
-    fieldType.arrayOf ?? (fieldType.arrayOfType ? { type: fieldType.arrayOfType } : undefined);
-  if (arrayOf) {
-    if (!Array.isArray(value)) {
-      return err + " to be an array";
-    }
-    const error = value
-      .map((element, i) => {
-        return getPropertyValidationError(element, arrayOf, [...path, `${i}`]);
-      })
-      .filter(isDefined)[0];
-    if (error !== undefined) {
-      return `${err}. Error at index ${path.length > 0 ? path.join(".") + "." : ""}\n\n${error}`;
-    }
-    return;
-  }
-
-  const oneOf = fieldType.oneOf ?? fieldType.oneOfType?.map((type) => ({ type }));
-  if (oneOf) {
-    if (!oneOf.length) {
-      return err + "to not be empty";
-    }
-    let firstError: string | undefined;
-    const validMember = 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 = keysEnum && 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. Some logic might be missing: ${JSON.stringify(fieldType)}`;
-};
-
-const getTypeDescription = (schema: JSONB.FieldType): string => {
-  const schemaObj = getFieldTypeObj(schema);
-  const { type, nullable, optional, record } = schemaObj;
-  const oneOf = schemaObj.oneOf ?? schemaObj.oneOfType?.map((type) => ({ type }));
-  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,
-  objName: string,
-  optional = false
-): { error: string; data?: undefined } | { error?: undefined; data: JSONB.GetObjectType<S> } => {
-  if (obj === undefined && !optional) return { error: `Expecting ${objName} to be defined` };
-  if (!isObject(obj)) {
-    return { error: `Expecting ${objName} to be an object` };
-  }
-  for (const [k, objSchema] of Object.entries(schema)) {
-    const error = getPropertyValidationError(obj[k], objSchema, [k]);
-    if (error) {
-      return { error };
-    }
-  }
-  return { data: obj as JSONB.GetObjectType<S> };
-};
-export const validateJSONBObjectAgainstSchema = <S extends JSONB.ObjectType["type"]>(
-  schema: S,
-  obj: any,
-  objName: string,
-  optional = false
-): obj is JSONB.GetObjectType<S> => {
-  const { error } = getJSONBObjectSchemaValidationError(schema, obj, objName, optional);
-  return error === undefined;
-};
-export const assertJSONBObjectAgainstSchema = <S extends JSONB.ObjectType["type"]>(
-  schema: S,
-  obj: any,
-  objName: string,
-  optional = false
-): asserts obj is JSONB.GetObjectType<S> => {
-  const { error } = getJSONBObjectSchemaValidationError(schema, obj, objName, optional);
-  if (error) {
-    throw new Error(error);
-  }
-};

package/lib/JSONBValidation/getJSONBSchemaTSTypes.ts

@@ -1,139 +0,0 @@
-import { getKeys, isObject, type JSONB, type TableSchema } from "prostgles-types";
-import { postgresToTsType } from "../DboBuilder/DboBuilder";
-import { asValue } from "../PubSubManager/PubSubManagerUtils";
-import { getFieldTypeObj } from "./JSONBValidation";
-
-type ColOpts = { nullable?: boolean };
-
-export function getJSONBSchemaTSTypes(
-  schema: JSONB.JSONBSchema,
-  colOpts: ColOpts,
-  outerLeading = "",
-  tables: TableSchema[]
-): string {
-  return getJSONBTSTypes(
-    tables,
-    { ...(schema as JSONB.FieldTypeObj), nullable: colOpts.nullable },
-    undefined,
-    outerLeading
-  );
-}
-
-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.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: {} },
-        },
-      })}`;
-    }
-
-    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 if (typeof fieldType.type === "string") {
-    if (fieldType.type.toLowerCase().includes("lookup")) {
-      throw new Error(`getJSONBTSTypes: Lookup type not handled correctly`);
-    }
-
-    /** Primitives */
-    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(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 throw "Unexpected getSchemaTSTypes: " + JSON.stringify({ fieldType }, null, 2);
-};
-
-const isValidIdentifier = (str: string) => {
-  const identifierRegex = /^[A-Za-z$_][A-Za-z0-9$_]*$/;
-  return identifierRegex.test(str);
-};