prostgles-server 4.2.158 → 4.2.159

package/lib/TableConfig/TableConfig.ts

@@ -1,468 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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 }));
-}