prostgles-server 4.2.159 → 4.2.161

package/lib/TableConfig/TableConfig.ts

@@ -0,0 +1,468 @@
+import { asName as _asName, AnyObject, TableInfo,  ALLOWED_EXTENSION, ALLOWED_CONTENT_TYPE, isObject, JSONB, ColumnInfo } from "prostgles-types";
+import { isPlainObject, JoinInfo, LocalParams } from "../DboBuilder/DboBuilder";
+import { DB, DBHandlerServer, Prostgles } from "../Prostgles";
+import { InsertRule, ValidateRowArgs } from "../PublishParser/PublishParser";
+import { TableHandler } from "../DboBuilder/TableHandler/TableHandler";
+import { uploadFile } from "../DboBuilder/uploadFile";
+import { initTableConfig } from "./initTableConfig";
+
+type ColExtraInfo = {
+  min?: string | number;
+  max?: string | number;
+  hint?: string;
+};
+
+export type I18N_Config<LANG_IDS> = {
+  [lang_id in keyof LANG_IDS]: string;
+}
+
+export const parseI18N = <LANG_IDS, Def extends string | undefined>(params: {
+  config?: I18N_Config<LANG_IDS> | string; 
+  lang?: keyof LANG_IDS | string; 
+  defaultLang: keyof LANG_IDS | string;
+  defaultValue: Def;
+}): Def | string => {
+  const { config, lang, defaultLang, defaultValue } = params;
+  if(config){
+    if(isPlainObject(config)){
+      //@ts-ignore
+      return config[lang] ?? config[defaultLang];
+    } else if(typeof config === "string"){
+      return config;
+    }
+  }
+
+  return defaultValue;
+}
+
+type BaseTableDefinition<LANG_IDS = AnyObject> = {
+  info?: {
+    label?: string | I18N_Config<LANG_IDS>;
+  }
+  dropIfExistsCascade?: boolean;
+  dropIfExists?: boolean;
+  hooks?: {
+    /**
+     * Hook used to run custom logic before inserting a row. 
+     * The returned row must satisfy the table schema
+     */
+    getPreInsertRow?: (args: GetPreInsertRowArgs) => Promise<{ row: AnyObject; onInserted: Promise<void>; }>;
+  };
+  triggers?: {
+    [triggerName: string]: {
+      /**
+       * Use "before" when you need to change the data before the action
+       */
+      type: "before" | "after" | "instead of";
+      actions: ("insert" | "update" | "delete")[];
+      forEach: "statement" | "row";
+      /**
+       * @example
+       * DECLARE
+          x_rec record;
+        BEGIN
+            raise notice '=operation: % =', TG_OP;
+            IF (TG_OP = 'UPDATE' OR TG_OP = 'DELETE') THEN
+                FOR x_rec IN SELECT * FROM old_table LOOP
+                    raise notice 'OLD: %', x_rec;
+                END loop;
+            END IF;
+            IF (TG_OP = 'INSERT' OR TG_OP = 'UPDATE') THEN
+                FOR x_rec IN SELECT * FROM new_table LOOP
+                    raise notice 'NEW: %', x_rec;
+                END loop;
+            END IF;
+
+            RETURN NULL;
+        END;
+       */
+      query: string;
+    }
+  };
+}
+
+type LookupTableDefinition<LANG_IDS> = {
+  isLookupTable: {
+    values: {
+      [id_value: string]: {} | {
+        [lang_id in keyof LANG_IDS]: string
+      }
+    }
+  }
+}
+
+export type BaseColumn<LANG_IDS> = {
+  /**
+   * Will add these values to .getColumns() result
+   */
+  info?: ColExtraInfo;
+
+  label?: string | Partial<{ [lang_id in keyof LANG_IDS]: string; }>;
+}
+
+type SQLDefColumn = {
+
+  /**
+   * Raw sql statement used in creating/adding column
+   */
+  sqlDefinition?: string;
+}
+
+export type BaseColumnTypes = {
+  defaultValue?: any;
+  nullable?: boolean;
+}
+
+type TextColumn = BaseColumnTypes & {
+  isText: true;
+  /**
+   * Value will be trimmed before update/insert
+   */
+  trimmed?: boolean;
+
+  /**
+   * Value will be lower cased before update/insert
+   */
+  lowerCased?: boolean;
+}
+
+export type JSONBColumnDef = (BaseColumnTypes & {
+  /**
+   * If the new schema CHECK fails old rows the update old rows using this function
+   */
+  // onMigrationFail?: <T>(failedRow: T) => AnyObject | Promise<AnyObject>;
+}) & ({
+  jsonbSchema: JSONB.JSONBSchema;
+  jsonbSchemaType?: undefined;
+} | {
+  jsonbSchema?: undefined;
+  jsonbSchemaType: JSONB.ObjectType["type"];
+})
+
+/**
+ * Allows referencing media to this table.
+ * Requires this table to have a primary key AND a valid fileTable config
+ */
+type MediaColumn = ({
+
+  name: string;
+  label?: string;
+  files: "one" | "many";
+} & (
+    {
+
+      /**
+       * https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/accept
+       */
+      allowedContentType?: Record<Partial<("audio/*" | "video/*" | "image/*" | "text/*" | ALLOWED_CONTENT_TYPE)>, 1>
+    } |
+    {
+      allowedExtensions?: Record<Partial<ALLOWED_EXTENSION>, 1>
+    }
+  ));
+
+type ReferencedColumn = { 
+  /**
+   * Will create a lookup table that this column will reference
+   */
+  references?: BaseColumnTypes & {
+    tableName: string;
+    /**
+     * Defaults to id
+     */
+    columnName?: string;
+  }
+}
+
+type JoinDef = {
+  sourceTable: string;
+  targetTable: string;
+  on: JoinInfo["paths"][number]["on"];
+}
+
+/**
+ * Used in specifying a join path to a table. This column name can then be used in select
+ */
+type NamedJoinColumn = {
+  label?: string;
+  joinDef: JoinDef[];
+}
+
+type Enum<T extends string | number = any> = { 
+  enum: T[] | readonly T[];
+  nullable?: boolean; 
+  defaultValue?: T; 
+};
+
+export type ColumnConfig<LANG_IDS = { en: 1 }> = string | StrictUnion<NamedJoinColumn | MediaColumn | (BaseColumn<LANG_IDS> & (SQLDefColumn | ReferencedColumn | TextColumn | JSONBColumnDef | Enum))>;
+
+export type ColumnConfigs<LANG_IDS = { en: 1 }> = {
+  sql: string | BaseColumn<LANG_IDS> & SQLDefColumn;
+  join: BaseColumn<LANG_IDS> & NamedJoinColumn;
+  media: BaseColumn<LANG_IDS> & MediaColumn;
+  referenced: BaseColumn<LANG_IDS> & ReferencedColumn;
+  text: BaseColumn<LANG_IDS> & TextColumn;
+  jsonb: BaseColumn<LANG_IDS> & JSONBColumnDef;
+  enum: BaseColumn<LANG_IDS> & Enum;
+}
+
+type UnionKeys<T> = T extends T ? keyof T : never;
+type StrictUnionHelper<T, TAll> = T extends any ? T & Partial<Record<Exclude<UnionKeys<TAll>, keyof T>, never>> : never;
+export type StrictUnion<T> = StrictUnionHelper<T, T>
+
+export const CONSTRAINT_TYPES = ["PRIMARY KEY", "UNIQUE", "CHECK"] as const; 
+export type TableDefinition<LANG_IDS> = {
+  onMount?: (params: { dbo: DBHandlerServer; _db: DB }) => Promise<void | { onUnmount: () => void; }>;
+  columns?: {
+    [column_name: string]: ColumnConfig<LANG_IDS>
+  },
+  constraints?: 
+    | string[] 
+    | {
+      [constraint_name: string]: 
+        | string 
+        | { 
+            type: typeof CONSTRAINT_TYPES[number]; 
+            dropIfExists?: boolean; 
+            /**
+             * E.g.: 
+             * colname
+             * col1, col2
+             * col1 > col3
+             */
+            content: string;
+          } 
+        // & ({
+        // } 
+        // | {
+        //   type: "FOREIGN KEY",
+        //   columns: string[];
+        //   ftable: string;
+        //   fcols: string[];
+        // }
+        // )
+  },
+
+  /**
+   * Similar to unique constraints but expressions are allowed inside definition
+   */
+  replaceUniqueIndexes?: boolean;
+  indexes?: {
+    [index_name: string]: {
+
+      /**
+       * If true then will drop any existing index with this name
+       * Overrides replaceUniqueIndexes
+       */
+      replace?: boolean;
+
+      /**
+       * Causes the system to check for duplicate values in the table when the index is created (if data already exist) and each time data is added. 
+       * Attempts to insert or update data which would result in duplicate entries will generate an error.
+       */
+      unique?: boolean;
+
+      /**
+       * When this option is used, PostgreSQL will build the index without taking any locks that prevent 
+       * concurrent inserts, updates, or deletes on the table; whereas a standard index build locks out writes (but not reads) on the table until it's done. 
+       * There are several caveats to be aware of when using this option — see Building Indexes Concurrently.
+       */
+      concurrently?: boolean;
+
+      /**
+       * Table name
+       */
+      // on?: string;
+
+      /**
+       * Column list
+       * @example: col1, col2
+       */
+      columns: string;
+
+      /**
+       * Where clause without the "where"
+       * Used to create a partial index. A partial index is an index that contains entries for only a portion of a table
+       * Another possible application is to use WHERE with UNIQUE to enforce uniqueness over a subset of a table
+       */
+      where?: string;
+
+      /**
+       * The name of the index method to be used. 
+       * Choices are btree, hash, gist, and gin. The default method is btree.
+       */
+      using?: "btree" | "hash" | "gist" | "gin";
+    }
+  }
+}
+
+type GetPreInsertRowArgs = Omit<ValidateRowArgs, "localParams"> & {
+  // preValidate: InsertRule["preValidate"];
+  validate: InsertRule["validate"];
+  localParams: LocalParams | undefined;
+}
+
+/**
+ * Helper utility to create lookup tables for TEXT columns
+ */
+export type TableConfig<LANG_IDS = { en: 1 }> = {
+  [table_name: string]: BaseTableDefinition<LANG_IDS> & (TableDefinition<LANG_IDS> | LookupTableDefinition<LANG_IDS>);
+}
+
+/**
+ * Will be run between initSQL and fileTable
+ */
+export default class TableConfigurator<LANG_IDS = { en: 1 }> {
+
+  instanceId = Date.now() + Math.random();
+  
+  config: TableConfig<LANG_IDS> = {};
+  get dbo(): DBHandlerServer {
+    if (!this.prostgles.dbo) throw "this.prostgles.dbo missing"
+    return this.prostgles.dbo
+  } 
+  get db(): DB {
+    if (!this.prostgles.db) throw "this.prostgles.db missing"
+    return this.prostgles.db
+  }  
+  prostgles: Prostgles
+
+  constructor(prostgles: Prostgles) {
+    this.config = (prostgles.opts.tableConfig as any) ?? {};
+    this.prostgles = prostgles;
+  }
+
+  destroy = async () => {
+    for await(const { onUnmount } of Object.values(this.tableOnMounts)){
+      try {
+        await onUnmount();
+      } catch (error) {
+        console.error(error);
+      }
+    }
+  }
+
+  tableOnMounts: Record<string, { onUnmount: () => void; }> = {};
+  setTableOnMounts = async () => {
+    this.tableOnMounts = {};
+    for (const [tableName, tableConfig] of Object.entries(this.config)) {
+      if("onMount" in tableConfig && tableConfig.onMount){
+        const cleanup = await tableConfig.onMount({ dbo: this.dbo, _db: this.db });
+        if(cleanup){
+          this.tableOnMounts[tableName] = cleanup;
+        }
+      }
+    }
+  }
+
+  getColumnConfig = (tableName: string, colName: string): ColumnConfig | undefined => {
+    const tconf = this.config?.[tableName];
+    if (tconf && "columns" in tconf) {
+      return tconf.columns?.[colName];
+    }
+    return undefined;
+  }
+
+  getTableInfo = (params: { tableName: string; lang?: string }): TableInfo["info"] | undefined => {
+    const tconf = this.config?.[params.tableName];
+    
+    return {
+      label: parseI18N<LANG_IDS, string>({ config: tconf?.info?.label, lang: params.lang, defaultLang: "en", defaultValue: params.tableName })
+    }
+  }
+
+  getColInfo = (params: { col: string, table: string, lang?: string }): (ColExtraInfo & { label?: string; } & Pick<ColumnInfo, "jsonbSchema">) | undefined => {
+    const colConf = this.getColumnConfig(params.table, params.col);
+    let result: Partial<ReturnType<typeof this.getColInfo>> = undefined;
+    if (colConf) {
+
+      if (isObject(colConf)) {
+        const { jsonbSchema, jsonbSchemaType, info } = colConf;
+        result = {
+          ...(result ?? {}),
+          ...info,
+          ...((jsonbSchema || jsonbSchemaType) && { jsonbSchema: { nullable: colConf.nullable, ...(jsonbSchema || { type: jsonbSchemaType }) } })
+        }
+
+        /**
+         * Get labels from TableConfig if specified
+         */
+        if (colConf.label) {
+          const { lang } = params;
+          const lbl = colConf?.label;
+          if (["string", "object"].includes(typeof lbl)) {
+            if (typeof lbl === "string") {
+              result ??= {};
+              result.label = lbl
+            } else if (lang && (lbl?.[lang as "en"] || lbl?.en)) {
+              result ??= {};
+              result.label = (lbl?.[lang as "en"]) || lbl?.en;
+            }
+          }
+
+        }
+
+      }
+
+    }
+
+
+    return result;
+  }
+
+  checkColVal = (params: { col: string, table: string, value: any }): void => {
+    const conf = this.getColInfo(params);
+    if (conf) {
+      const { value } = params;
+      const { min, max } = conf;
+      if (min !== undefined && value !== undefined && value < min) throw `${params.col} must be greater than ${min}`
+      if (max !== undefined && value !== undefined && value > max) throw `${params.col} must be less than ${max}`
+    }
+  }
+
+  getJoinInfo = (sourceTable: string, targetTable: string): JoinInfo | undefined => {
+    if (
+      this.config &&
+      sourceTable in this.config &&
+      this.config[sourceTable] &&
+      "columns" in this.config[sourceTable]!
+    ) {
+      const td = this.config[sourceTable]!;
+      if ("columns" in td && td.columns?.[targetTable]) {
+        const cd = td.columns[targetTable];
+        if (isObject(cd) && "joinDef" in cd) {
+          if(!cd.joinDef) throw "cd.joinDef missing"
+          const { joinDef } = cd;
+          const res: JoinInfo = {
+            expectOne: false,
+            paths: joinDef.map(({ sourceTable, targetTable: table, on }) => ({
+              source: sourceTable,
+              target: targetTable,
+              table,
+              on
+            })),
+          }
+
+          return res;
+        }
+      }
+    }
+    return undefined;
+  }
+
+  getPreInsertRow = async (tableHandler: TableHandler, args: Pick<GetPreInsertRowArgs, "localParams" | "row" | "validate" | "dbx">): Promise<AnyObject> => {
+    const tableHook = this.config?.[tableHandler.name]?.hooks?.getPreInsertRow;
+    if(tableHandler.is_media){
+      return uploadFile.bind(tableHandler)(args) as Promise<AnyObject>;
+    } 
+    if(tableHook){
+      return tableHook(args)
+    }
+
+    return args.row;
+  }
+
+  prevInitQueryHistory?: string[];
+  initialising = false;
+  init = initTableConfig.bind(this);
+} 

package/lib/TableConfig/getColumnDefinitionQuery.ts

@@ -0,0 +1,111 @@
+import { asName, pickKeys } from "prostgles-types"; 
+import { DB } from "../Prostgles";
+import { asValue } from "../PubSubManager/PubSubManager";
+import { VALIDATE_SCHEMA_FUNCNAME } from "../JSONBValidation/validate_jsonb_schema_sql";
+import { BaseColumnTypes, ColumnConfig } from "./TableConfig";
+import pgPromise from "pg-promise"; 
+
+type Args = {
+  column: string; 
+  colConf: ColumnConfig;
+  db: DB; 
+  table: string;
+};
+
+/**
+ * Column create statement for a given config
+ */
+export const getColumnDefinitionQuery = async ({ colConf: colConfRaw, column, db, table }: Args): Promise<string | undefined> => {
+  const colConf = typeof colConfRaw === "string"? { sqlDefinition: colConfRaw } : colConfRaw;
+  const colNameEsc = asName(column);
+  const getColTypeDef = (colConf: BaseColumnTypes, pgType: "TEXT" | "JSONB") => {
+    const { nullable, defaultValue } = colConf;
+    return `${pgType} ${!nullable ? " NOT NULL " : ""} ${defaultValue ? ` DEFAULT ${asValue(defaultValue)} ` : ""}`
+  }
+
+  const jsonbSchema =
+      ("jsonbSchema" in colConf && colConf.jsonbSchema) ? { jsonbSchema: colConf.jsonbSchema, jsonbSchemaType: undefined } :
+        ("jsonbSchemaType" in colConf && colConf.jsonbSchemaType) ? { jsonbSchema: undefined, jsonbSchemaType: colConf.jsonbSchemaType } :
+          undefined; 
+  
+
+  if ("references" in colConf && colConf.references) {
+
+    const { tableName: lookupTable, columnName: lookupCol = "id" } = colConf.references;
+    return ` ${colNameEsc} ${getColTypeDef(colConf.references, "TEXT")} REFERENCES ${lookupTable} (${lookupCol}) `;
+
+  } else if ("sqlDefinition" in colConf && colConf.sqlDefinition) {
+
+    return ` ${colNameEsc} ${colConf.sqlDefinition} `;
+
+  } else if ("isText" in colConf && colConf.isText) {
+    let checks = "";
+    const colChecks: string[] = [];
+    if (colConf.lowerCased) {
+      colChecks.push(`${colNameEsc} = LOWER(${colNameEsc})`)
+    }
+    if (colConf.trimmed) {
+      colChecks.push(`${colNameEsc} = BTRIM(${colNameEsc})`)
+    }
+    if (colChecks.length) {
+      checks = `CHECK (${colChecks.join(" AND ")})`
+    }
+    return ` ${colNameEsc} ${getColTypeDef(colConf, "TEXT")} ${checks}`;
+
+  } else if (jsonbSchema) {
+
+    const jsonbSchemaStr = asValue({
+      ...pickKeys(colConf, ["enum", "nullable", "info"]),
+      ...(jsonbSchema.jsonbSchemaType ? { type: jsonbSchema.jsonbSchemaType } : jsonbSchema.jsonbSchema)
+    }) + "::TEXT";
+
+    /** Validate default value against jsonbSchema  */
+    const validationQuery = `SELECT ${VALIDATE_SCHEMA_FUNCNAME}(${jsonbSchemaStr}, ${asValue(colConf.defaultValue) + "::JSONB"}, ${asValue({ table, column })}) as v`;
+    if (colConf.defaultValue) {
+
+      const failedDefault = (err?: any) => {
+        return { msg: `Default value (${colConf.defaultValue}) for ${table}.${column} does not satisfy the jsonb constraint check: ${validationQuery}`, err };
+      }
+      try {
+        const row = await db.oneOrNone(validationQuery);
+        if (!row?.v) {
+          throw "Error";
+        }
+      } catch (e) {
+        throw failedDefault(e);
+      }
+    } 
+
+    return ` ${colNameEsc} ${getColTypeDef(colConf, "JSONB")} CHECK(${VALIDATE_SCHEMA_FUNCNAME}(${jsonbSchemaStr}, ${colNameEsc}, ${asValue({ table, column })} ))`;
+
+  } else if ("enum" in colConf) {
+    if (!colConf.enum?.length) throw new Error("colConf.enum Must not be empty");
+    const type = colConf.enum.every(v => Number.isFinite(v)) ? "NUMERIC" : "TEXT";
+    const checks = colConf.enum.map(v => `${colNameEsc} = ${asValue(v)}`).join(" OR ");
+    return ` ${colNameEsc} ${type} ${colConf.nullable ? "" : "NOT NULL"} ${"defaultValue" in colConf ? ` DEFAULT ${asValue(colConf.defaultValue)}` : ""} CHECK(${checks})`;
+
+  } else {
+    return undefined;
+    // throw "Unknown column config: " + JSON.stringify(colConf);
+  }
+}
+
+
+export type ColumnMinimalInfo = { 
+  table_name: string;
+  table_schema: string;
+  column_name: string;
+  column_default: string | null;
+  udt_name: string;
+  nullable: boolean; 
+};
+export const getTableColumns = ({ db, table }: { db: DB | pgPromise.ITask<{}>; table: string;}): Promise<ColumnMinimalInfo[]> => {
+  return db.manyOrNone(`
+    SELECT table_name, 
+      table_schema, column_name, 
+      column_default, udt_name,
+      is_nullable = 'YES' as nullable
+    FROM information_schema.columns
+    WHERE table_name = $1
+  `, [table]);
+}

package/lib/TableConfig/getConstraintDefinitionQueries.ts

@@ -0,0 +1,95 @@
+import pgPromise from "pg-promise";
+import { asName } from "prostgles-types";
+import { DB } from "../Prostgles";
+import { asValue } from "../PubSubManager/PubSubManager";
+import { TableConfig } from "./TableConfig";
+
+type Args = {
+  tableName: string;
+  tableConf: TableConfig[string]
+  // tableConf: BaseTableDefinition<LANG_IDS> & (TableDefinition<LANG_IDS> | LookupTableDefinition<LANG_IDS>)
+};
+
+export type ConstraintDef = {  
+  /**
+   * Named constraints are used to show a relevant error message
+   */
+  name?: string; 
+  content: string; 
+  alterQuery: string; 
+};
+export const getConstraintDefinitionQueries = ({ tableConf, tableName }: Args): ConstraintDef[] | undefined => {
+
+  if ("constraints" in tableConf && tableConf.constraints) {
+    const { constraints } = tableConf;
+    if(!constraints){
+      return undefined;
+    }
+    
+    if(Array.isArray(constraints)) {
+      return constraints.map(c => ({ content: c, alterQuery: `ALTER TABLE ${asName(tableName)} ADD ${c}`}));
+      
+    } else {
+      const constraintNames = Object.keys(constraints);
+      return constraintNames.map(constraintName => {
+        const _cnstr = constraints[constraintName]!;
+        const constraintDef = typeof _cnstr === "string"? _cnstr : `${_cnstr.type} (${_cnstr.content})`;
+        
+        /** Drop constraints with the same name */
+        // const existingConstraint = constraints.some(c => c.conname === constraintName);
+        // if(existingConstraint){
+        //   if(canDrop) queries.push(`ALTER TABLE ${asName(tableName)} DROP CONSTRAINT ${asName(constraintName)};`);
+        // }
+        
+        const alterQuery = `ALTER TABLE ${asName(tableName)} ADD CONSTRAINT ${asName(constraintName)} ${constraintDef};`;
+
+        return { name: constraintName, alterQuery, content: constraintDef };
+      });
+    }
+  }
+}
+
+export type ColConstraint = {
+  name: string;
+  table: string;
+  type: "c" | "p" | "u" | "f";
+  cols: Array<string>;
+  definition: string;
+  schema: string;
+}
+type ColConstraintsArgs = {
+  db: DB | pgPromise.ITask<{}>;
+  table?: string;
+  column?: string;
+  types?: ColConstraint["type"][];
+}
+export const getColConstraintsQuery = ({ column, table, types }: Omit<ColConstraintsArgs, "db">) => {
+  let query = `
+    SELECT *
+    FROM (             
+      SELECT distinct c.conname as name, c.contype as type,
+        pg_get_constraintdef(c.oid) as definition, 
+        nsp.nspname as schema,
+      (SELECT r.relname from pg_class r where r.oid = c.conrelid) as "table", 
+      (SELECT array_agg(attname::text) from pg_attribute 
+      where attrelid = c.conrelid and ARRAY[attnum] <@ c.conkey) as cols
+      -- (SELECT array_agg(attname::text) from pg_attribute 
+      -- where attrelid = c.confrelid and ARRAY[attnum] <@ c.confkey) as fcols, 
+      -- (SELECT r.relname from pg_class r where r.oid = c.confrelid) as ftable
+      FROM pg_catalog.pg_constraint c
+      INNER JOIN pg_catalog.pg_class rel
+      ON rel.oid = c.conrelid
+      INNER JOIN pg_catalog.pg_namespace nsp
+      ON nsp.oid = connamespace
+    ) t   
+    WHERE TRUE 
+  `;
+  if (table) query += `\nAND "table" = ${asValue(table)}`;
+  if (column) query += `\nAND cols @> ARRAY[${asValue(column)}]`;
+  if (types?.length) query += `\nAND type IN (${types.map(v => asValue(v)).join(", ")})`;
+  return query;
+}
+export const getColConstraints = ({ db, column, table, types }: ColConstraintsArgs ): Promise<ColConstraint[]>  => {
+  
+  return db.manyOrNone(getColConstraintsQuery({ column, table, types }));
+}