prostgles-types 4.0.274 → 4.0.277

package/lib/JSONBSchemaValidation/JSONBSchemaValidation.ts

@@ -1,19 +1,26 @@
-import type { JSONB, PrimitiveTypeMap } from "./JSONBSchema";
+import type { DBHandler } from "lib";
 import { getKeys, isDefined, isEmpty, isObject } from "../util";
-import { safeGetKeys, safeGetProperty, safeHasOwn } from "./utils";
 import { includes } from "../utilFuncs/includes";
+import type { JSONB, PrimitiveTypeMap } from "./JSONBSchema";
+import { safeGetKeys, safeGetProperty, safeHasOwn } from "./utils";
 
 type ValidationOptions = {
   allowExtraProperties?: boolean;
 };
 
+type PendingLookupValidation = {
+  schema: JSONB.Lookup;
+  value: unknown;
+  path: string[];
+};
+
 export const getFieldTypeObj = (rawFieldType: JSONB.FieldType): JSONB.FieldTypeObj => {
   if (typeof rawFieldType === "string") return { type: rawFieldType };
 
   return rawFieldType;
 };
 
-const isBlob = (val: unknown): val is Blob => {
+const isUint8ArrayOrBuffer = (val: unknown): val is Uint8Array => {
   return (
     val instanceof Blob ||
     //@ts-ignore
@@ -23,7 +30,7 @@ const isBlob = (val: unknown): val is Blob => {
   );
 };
 
-type DataType = JSONB.FieldTypeObj["type"];
+type DataType = JSONB.BasicType["type"];
 type ElementType<T extends DataType> = T extends `${infer E}[]` ? E : never;
 type ArrayTypes = Extract<DataType, `${string}[]`>;
 type NonArrayTypes = Extract<Exclude<DataType, ArrayTypes>, string>;
@@ -47,10 +54,8 @@ const PRIMITIVE_VALIDATORS: {
   any: (val): val is any => typeof val !== "function" && typeof val !== "symbol",
   unknown: (val): val is unknown => typeof val !== "function" && typeof val !== "symbol",
   Date: (val) => typeof val === "string",
-  Lookup: (val): val is unknown => {
-    throw new Error("Lookup type is not supported for validation");
-  },
-  Blob: isBlob,
+  Uint8Array: isUint8ArrayOrBuffer,
+  Blob: isUint8ArrayOrBuffer,
   FileLike: (val, s): val is PrimitiveTypeMap["FileLike"] => {
     if (s.type !== "FileLike") {
       throw new Error("FileLike type must have type 'FileLike'");
@@ -59,7 +64,7 @@ const PRIMITIVE_VALIDATORS: {
       isObject(val) &&
       typeof val.name === "string" &&
       typeof val.type === "string" &&
-      isBlob(val.data);
+      isUint8ArrayOrBuffer(val.data);
     if (validStructure && s.mimeTypes) {
       const validMime = Object.keys(s.mimeTypes).some((mime) => val.type === mime);
       if (!validMime) {
@@ -107,6 +112,7 @@ const getPropertyValidationError = (
   rawFieldType: JSONB.FieldType,
   path: string[] = [],
   opts: ValidationOptions | undefined,
+  pendingLookupValidations?: PendingLookupValidation[],
 ): string | undefined => {
   const err = `${path.join(".")} is of invalid type. Expecting ${getTypeDescription(rawFieldType).replaceAll("\n", "")}`;
   const fieldDefinition = getFieldTypeObj(rawFieldType);
@@ -147,6 +153,7 @@ const getPropertyValidationError = (
           subSchema,
           [...path, subKey],
           opts,
+          pendingLookupValidations,
         );
         if (error !== undefined) {
           return error;
@@ -166,7 +173,38 @@ const getPropertyValidationError = (
       return;
     }
 
-    const { validator } = getValidator(type, fieldDefinition);
+    if (type.includes("Lookup")) {
+      if (!pendingLookupValidations) {
+        throw new Error("Lookup types are not supported for validation");
+      }
+      const isArray = type.endsWith("[]");
+      if (isArray !== Array.isArray(value)) return err;
+
+      const lookupType = type.replace("[]", "");
+      const values = isArray ? value : [value];
+      const isValid = values.every((item: unknown) => {
+        if (lookupType === "RowLookup") return isObject(item);
+        if (lookupType === "ValueLookup") {
+          return typeof item !== "function" && typeof item !== "symbol";
+        }
+        if (lookupType === "TableLookup") return typeof item === "string";
+        return (
+          isObject(item) &&
+          typeof safeGetProperty(item, "table") === "string" &&
+          typeof safeGetProperty(item, "column") === "string" &&
+          safeGetKeys(item).every((key) => key === "table" || key === "column")
+        );
+      });
+      if (!isValid) return err;
+
+      pendingLookupValidations.push({
+        schema: fieldDefinition as JSONB.Lookup,
+        value,
+        path,
+      });
+      return;
+    }
+    const { validator } = getValidator(type as DataType, fieldDefinition);
     const isValid = validator(value, fieldDefinition);
     if (!isValid) {
       return err;
@@ -192,6 +230,7 @@ const getPropertyValidationError = (
         tuple[index]!,
         [...path, `${index}`],
         opts,
+        pendingLookupValidations,
       );
 
       if (elementError !== undefined) {
@@ -221,7 +260,13 @@ const getPropertyValidationError = (
     }
     const error = value
       .map((element, i) => {
-        return getPropertyValidationError(element, arrayOf, [...path, `${i}`], opts);
+        return getPropertyValidationError(
+          element,
+          arrayOf,
+          [...path, `${i}`],
+          opts,
+          pendingLookupValidations,
+        );
       })
       .filter(isDefined)[0];
     if (error !== undefined) {
@@ -237,7 +282,11 @@ const getPropertyValidationError = (
     }
     let firstError: string | undefined;
     const validMember = oneOf.find((member) => {
-      const error = getPropertyValidationError(value, member, path, opts);
+      const pendingLookupCount = pendingLookupValidations?.length;
+      const error = getPropertyValidationError(value, member, path, opts, pendingLookupValidations);
+      if (error !== undefined && pendingLookupCount !== undefined) {
+        pendingLookupValidations!.length = pendingLookupCount;
+      }
       firstError ??= error;
       return error === undefined;
     });
@@ -271,6 +320,7 @@ const getPropertyValidationError = (
           valuesSchema,
           [...path, propKey],
           opts,
+          pendingLookupValidations,
         );
         if (valError !== undefined) {
           return `${valError}`;
@@ -358,6 +408,107 @@ export const getJSONBSchemaValidationError = <S extends JSONB.FieldType>(
   }
   return { data: obj as JSONB.GetType<S> };
 };
+
+const getLookupValuePath = (path: string[], index?: number): string => {
+  const result = [...path, ...(index === undefined ? [] : [String(index)])].join(".");
+  return result || "value";
+};
+
+const getLookupTableHandler = (db: DBHandler, table: string): DBHandler[string] | undefined => {
+  if (!safeHasOwn(db, table)) return;
+  const handler = safeGetProperty(db, table);
+  return isObject(handler) ? (handler as DBHandler[string]) : undefined;
+};
+
+const getLookupValidationError = async (
+  lookup: PendingLookupValidation,
+  db: DBHandler,
+): Promise<string | undefined> => {
+  const { schema, path } = lookup;
+  const isArray = schema.type.endsWith("[]");
+  const values = isArray ? (lookup.value as unknown[]) : [lookup.value];
+
+  for (const [index, value] of values.entries()) {
+    const valuePath = getLookupValuePath(path, isArray ? index : undefined);
+
+    if (schema.type === "TableLookup" || schema.type === "TableLookup[]") {
+      if (!getLookupTableHandler(db, value as string)) {
+        return `${valuePath} references an unknown table ${JSON.stringify(value)}`;
+      }
+      continue;
+    }
+
+    if (schema.type === "ColumnLookup" || schema.type === "ColumnLookup[]") {
+      const reference = value as { table: string; column: string };
+      if (schema.filter?.table && reference.table !== schema.filter.table) {
+        return `${valuePath} references a column that does not match the lookup filter`;
+      }
+
+      const tableHandler = getLookupTableHandler(db, reference.table);
+      if (!tableHandler) {
+        return `${valuePath} references an unknown table ${JSON.stringify(reference.table)}`;
+      }
+      if (typeof tableHandler.getColumns !== "function") {
+        throw new Error(
+          `Cannot validate ColumnLookup: table ${JSON.stringify(reference.table)} does not expose getColumns`,
+        );
+      }
+      const columns = await tableHandler.getColumns();
+      const column = columns.find(({ name }) => name === reference.column);
+      if (
+        !column ||
+        (schema.filter?.tsDataType && column.tsDataType !== schema.filter.tsDataType) ||
+        (schema.filter?.udt_name && column.udt_name !== schema.filter.udt_name)
+      ) {
+        return `${valuePath} references an unknown or disallowed column ${JSON.stringify(`${reference.table}.${reference.column}`)}`;
+      }
+      continue;
+    }
+
+    const dataLookup = schema as JSONB.RowLookup | JSONB.ValueLookup;
+    const tableHandler = getLookupTableHandler(db, dataLookup.table);
+
+    if (!tableHandler) {
+      throw new Error(
+        `Cannot validate ${dataLookup.type}: table ${JSON.stringify(dataLookup.table)} does not expose findOne`,
+      );
+    }
+
+    const valueFilter =
+      dataLookup.type === "RowLookup" || dataLookup.type === "RowLookup[]" ?
+        (value as Record<string, unknown>)
+      : { [(dataLookup as JSONB.ValueLookup).column]: value };
+    const filter = dataLookup.filter ? { $and: [dataLookup.filter, valueFilter] } : valueFilter;
+    const row = await tableHandler?.findOne?.(filter);
+    if (row === undefined) {
+      return `${valuePath} does not reference an existing row in ${JSON.stringify(dataLookup.table)}`;
+    }
+  }
+};
+
+/**
+ * Validates lookup values as well as the synchronous JSONB schema rules.
+ * A prostgles DB handler validates every lookup kind. A fetch-row callback
+ * validates RowLookup and ValueLookup records, while table/column lookups are
+ * structurally validated.
+ */
+export const getJSONBSchemaValidationErrorAsync = async <S extends JSONB.FieldType>(
+  schema: S,
+  obj: any,
+  source: DBHandler,
+  opts?: ValidationOptions,
+): Promise<{ error: string; data?: undefined } | { error?: undefined; data: JSONB.GetType<S> }> => {
+  const pendingLookupValidations: PendingLookupValidation[] = [];
+  const error = getPropertyValidationError(obj, schema, undefined, opts, pendingLookupValidations);
+  if (error) return { error };
+
+  for (const lookup of pendingLookupValidations) {
+    const lookupError = await getLookupValidationError(lookup, source);
+    if (lookupError) return { error: lookupError };
+  }
+  return { data: obj as JSONB.GetType<S> };
+};
+
 export const validateJSONBObjectAgainstSchema = <S extends JSONB.ObjectType["type"]>(
   schema: S,
   obj: any,

package/lib/JSONBSchemaValidation/getJSONBSchemaAsJSONSchema.ts

@@ -1,5 +1,5 @@
 import type { JSONSchema7, JSONSchema7Definition, JSONSchema7TypeName } from "json-schema";
-import type { JSONB, PrimitiveTypes } from "./JSONBSchema";
+import type { JSONB } from "./JSONBSchema";
 import { getObjectEntries, isObject } from "../util";
 import { safeGetKeys } from "./utils";
 
@@ -7,8 +7,7 @@ const getJSONSchemaType = (
   rawType: JSONB.BasicType["type"] | JSONB.Lookup["type"] | undefined,
 ): { type: JSONSchema7TypeName | undefined; isArray: boolean } | undefined => {
   if (!rawType) return;
-  const type: (typeof PrimitiveTypes)[number] | "Lookup" =
-    rawType.endsWith("[]") ? (rawType.slice(0, -2) as any) : rawType;
+  const type = rawType.endsWith("[]") ? rawType.slice(0, -2) : rawType;
 
   return {
     type:
@@ -17,7 +16,8 @@ const getJSONSchemaType = (
       : type === "number" ? "number"
       : type === "any" ? undefined
       : type === "unknown" ? undefined
-      : type === "Lookup" ? undefined
+      : type.endsWith("Lookup") ? undefined
+      : type === "Uint8Array" ? undefined
       : type === "Blob" ? undefined
       : type === "FileLike" ? undefined
       : "string",

package/lib/JSONBSchemaValidation/getJSONBSchemaTSTypes.ts

@@ -24,6 +24,33 @@ const valueToString = (v: any): string => {
   return String(v);
 };
 
+const getLookupTSType = (tables: TableSchema[], fieldType: JSONB.Lookup): string => {
+  const nullType = fieldType.nullable ? "null | " : "";
+  const arrayType = fieldType.type.endsWith("[]") ? "[]" : "";
+
+  if (fieldType.type === "TableLookup" || fieldType.type === "TableLookup[]") {
+    return `${nullType}string${arrayType}`;
+  }
+
+  if (fieldType.type === "ColumnLookup" || fieldType.type === "ColumnLookup[]") {
+    return `${nullType}{ "table": string; "column": string; }${arrayType}`;
+  }
+
+  const dataLookup = fieldType as JSONB.RowLookup | JSONB.ValueLookup;
+  const cols = tables.find((table) => table.name === dataLookup.table)?.columns;
+  if (fieldType.type === "ValueLookup" || fieldType.type === "ValueLookup[]") {
+    const valueLookup = fieldType as JSONB.ValueLookup;
+    const udtName = cols?.find((column) => column.name === valueLookup.column)?.udt_name;
+    return `${nullType}${postgresToTsType(udtName ?? "text")}${arrayType}`;
+  }
+
+  const rowType =
+    !cols ? "any" : (
+      `{ ${cols.map((column) => `${JSON.stringify(column.name)}: ${column.is_nullable ? "null | " : ""} ${postgresToTsType(column.udt_name)}; `).join(" ")} }`
+    );
+  return `${nullType}${rowType}${arrayType}`;
+};
+
 export const getJSONBTSTypes = (
   tables: TableSchema[],
   rawFieldType: JSONB.FieldType,
@@ -33,51 +60,9 @@ export const getJSONBTSTypes = (
 ): 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 ? "[]" : ""}`;
+  if (typeof fieldType.type === "string" && fieldType.type.includes("Lookup")) {
+    return getLookupTSType(tables, fieldType as JSONB.Lookup);
   } 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")

package/lib/index.ts

@@ -48,7 +48,7 @@ export type PG_COLUMN_UDT_DATA_TYPE =
   | (typeof _PG_bytes)[number];
 
 const TS_PG_PRIMITIVES = {
-  "ArrayBuffer | Uint8Array": _PG_bytes,
+  Uint8Array: _PG_bytes,
   string: [
     ..._PG_strings,
     ..._PG_numbers_str,
@@ -74,7 +74,6 @@ export const TS_PG_Types = {
   "string[]": TS_PG_PRIMITIVES.string.map((s) => `_${s}` as const),
   "any[]": TS_PG_PRIMITIVES.any.map((s) => `_${s}` as const),
   // "Date[]": _PG_date.map(s => `_${s}` as const),
-  // "any": [],
 } as const;
 export type TS_COLUMN_DATA_TYPES = keyof typeof TS_PG_Types;
 
@@ -113,7 +112,7 @@ export type DBTableSchema = {
   update?: boolean;
   delete?: boolean;
   /**
-   * Used in update, insertm select and filters
+   * Used in update, insert, select and filters
    * fields that are nullable or with a default value are be optional
    */
   columns: AnyObject;
@@ -138,7 +137,7 @@ export type ColumnInfo = {
   name: string;
 
   /**
-   * Column display name. Will be first non empty value from i18n data, comment, name
+   * Column display name. Will be first non empty value from i18n data, or prettified name
    */
   label: string;
 
@@ -230,7 +229,7 @@ export type ColumnInfo = {
 
   /**
    * JSONB schema (a simplified version of json schema) for the column (if defined in the tableConfig)
-   * A check constraint will use this schema for runtime data validation and apropriate TS types will be generated
+   * A check constraint will use this schema for runtime data validation and appropriate TS types will be generated
    */
   jsonbSchema?: JSONB.JSONBSchema;
 
@@ -741,9 +740,7 @@ export type InsertParams<T extends AnyObject | void = void, S extends DBSchema |
    * - DoUpdate: will update all non primary key columns of the conflicting row
    */
   onConflict?:
-    | "DoNothing"
-    | "DoUpdate"
-    | { action: "DoNothing" | "DoUpdate"; conflictColumns: string[] };
+    "DoNothing" | "DoUpdate" | { action: "DoNothing" | "DoUpdate"; conflictColumns: string[] };
 
   /**
    * Used for sync.
@@ -918,7 +915,7 @@ export type InsertDataWithNested<
 export type TableHandler<
   TD extends AnyObject = AnyObject,
   S extends DBSchema | void = void,
-  TName extends S extends DBSchema ? keyof S : never = never,
+  TName extends (S extends DBSchema ? keyof S : never) = never,
 > = {
   /**
    * Retrieves the table/view info
@@ -1210,11 +1207,7 @@ type DeleteMethods<T extends DBTableSchema> =
   T["delete"] extends true ? keyof Pick<TableHandler, "delete"> : never;
 
 export type ValidatedMethods<T extends DBTableSchema> =
-  | SelectMethods<T>
-  | UpdateMethods<T>
-  | InsertMethods<T>
-  | UpsertMethods<T>
-  | DeleteMethods<T>;
+  SelectMethods<T> | UpdateMethods<T> | InsertMethods<T> | UpsertMethods<T> | DeleteMethods<T>;
 // | SyncMethods<T>
 
 export type DBHandler<S = void> =

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "prostgles-types",
-  "version": "4.0.274",
+  "version": "4.0.277",
   "description": "",
   "main": "dist/index_umd.js",
   "types": "dist/index.d.ts",
   "directories": {},
   "scripts": {
     "start": "tsc --watch",
-    "test": "npm run build && node --test dist/*.spec.js dist/**/*.spec.js",
+    "test": "npm run build && npm run test:type-instantiations && node --test dist/*.spec.js dist/**/*.spec.js",
+    "test:type-instantiations": "node scripts/check-type-instantiations.mjs",
     "build": "npm i && rm -rf ./dist/* && tsc && webpack --config webpack.prod.js",
     "prebuild": "tsc --noEmit -p tsconfig.browser.json",
     "perf": "tsc --extendedDiagnostics 2>&1 | grep -E \"Instantiations|Check time\"",

package/scripts/check-type-instantiations.mjs

@@ -0,0 +1,40 @@
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+// Baseline: 108,997. The small margin avoids hiding meaningful inference regressions.
+const MAX_INSTANTIATIONS = 105_000;
+const tscPath = fileURLToPath(new URL("../node_modules/typescript/bin/tsc", import.meta.url));
+const result = spawnSync(
+  process.execPath,
+  [tscPath, "--noEmit", "--extendedDiagnostics", "--pretty", "false"],
+  { encoding: "utf8" },
+);
+
+if (result.error) {
+  throw result.error;
+}
+
+if (result.status !== 0) {
+  process.stdout.write(result.stdout);
+  process.stderr.write(result.stderr);
+  process.exit(result.status ?? 1);
+}
+
+const output = result.stdout + result.stderr;
+const label = "Instantiations:";
+const line = output.split("\n").find((outputLine) => outputLine.startsWith(label));
+const instantiations = Number(line?.slice(label.length).trim());
+
+if (!Number.isFinite(instantiations)) {
+  throw new Error(`Could not read type instantiations from tsc output:\n${output}`);
+}
+
+if (instantiations > MAX_INSTANTIATIONS) {
+  throw new Error(
+    `Type instantiations increased to ${instantiations.toLocaleString()} (maximum: ${MAX_INSTANTIATIONS.toLocaleString()}).`,
+  );
+}
+
+console.log(
+  `Type instantiations: ${instantiations.toLocaleString()} / ${MAX_INSTANTIATIONS.toLocaleString()}`,
+);