@snowtop/ent 0.1.0-alpha16 → 0.1.0-alpha160-test1

package/core/clause.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -19,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sensitiveValue = exports.TsVectorWebsearchToTsQuery = exports.TsVectorPhraseToTsQuery = exports.TsVectorPlainToTsQuery = exports.TsVectorColTsQuery = exports.WebsearchToTsQuery = exports.PhraseToTsQuery = exports.PlainToTsQuery = exports.TsQuery = exports.In = exports.Or = exports.AndOptional = exports.And = exports.LessEq = exports.GreaterEq = exports.Less = exports.Greater = exports.NotEq = exports.Eq = exports.ArrayLessEq = exports.ArrayGreaterEq = exports.ArrayLess = exports.ArrayGreater = exports.ArrayNotEq = exports.ArrayEq = void 0;
+exports.getCombinedClause = exports.Modulo = exports.Divide = exports.Multiply = exports.Subtract = exports.Add = exports.PaginationMultipleColsSubQuery = exports.JSONPathValuePredicate = exports.JSONObjectFieldKeyAsText = exports.JSONObjectFieldKeyASJSON = exports.sensitiveValue = exports.TsVectorWebsearchToTsQuery = exports.TsVectorPhraseToTsQuery = exports.TsVectorPlainToTsQuery = exports.TsVectorColTsQuery = exports.WebsearchToTsQuery = exports.PhraseToTsQuery = exports.PlainToTsQuery = exports.TsQuery = exports.DBTypeNotIn = exports.TextNotIn = exports.IntegerNotIn = exports.UuidNotIn = exports.DBTypeIn = exports.TextIn = exports.IntegerIn = exports.UuidIn = exports.In = exports.OrOptional = exports.Or = exports.AndOptional = exports.And = exports.LessEq = exports.GreaterEq = exports.Less = exports.Greater = exports.NotEq = exports.Eq = exports.ArrayNotEq = exports.ArrayEq = exports.PostgresArrayNotOverlaps = exports.PostgresArrayOverlaps = exports.PostgresArrayNotContains = exports.PostgresArrayNotContainsValue = exports.PostgresArrayContains = exports.PostgresArrayContainsValue = exports.notInClause = exports.inClause = void 0;
 const db_1 = __importStar(require("./db"));
 function isSensitive(val) {
     return (val !== null &&
@@ -33,35 +37,35 @@ function rawValue(val) {
     return val;
 }
 class simpleClause {
-    constructor(col, value, op, handleSqliteNull) {
+    constructor(col, value, op, handleNull) {
         this.col = col;
         this.value = value;
         this.op = op;
-        this.handleSqliteNull = handleSqliteNull;
+        this.handleNull = handleNull;
     }
     clause(idx) {
-        const sqliteClause = this.sqliteNull();
-        if (sqliteClause) {
-            return sqliteClause.clause(idx);
+        const nullClause = this.nullClause();
+        if (nullClause) {
+            return nullClause.clause(idx);
         }
         if (db_1.default.getDialect() === db_1.Dialect.Postgres) {
             return `${this.col} ${this.op} $${idx}`;
         }
         return `${this.col} ${this.op} ?`;
     }
-    sqliteNull() {
-        if (!this.handleSqliteNull || this.value !== null) {
-            return;
-        }
-        if (db_1.default.getDialect() !== db_1.Dialect.SQLite) {
+    nullClause() {
+        if (!this.handleNull || this.value !== null) {
             return;
         }
-        return this.handleSqliteNull;
+        return this.handleNull;
+    }
+    columns() {
+        return [this.col];
     }
     values() {
-        const sqliteClause = this.sqliteNull();
-        if (sqliteClause) {
-            return sqliteClause.values();
+        const nullClause = this.nullClause();
+        if (nullClause) {
+            return nullClause.values();
         }
         if (isSensitive(this.value)) {
             return [this.value.value()];
@@ -69,9 +73,9 @@ class simpleClause {
         return [this.value];
     }
     logValues() {
-        const sqliteClause = this.sqliteNull();
-        if (sqliteClause) {
-            return sqliteClause.logValues();
+        const nullClause = this.nullClause();
+        if (nullClause) {
+            return nullClause.logValues();
         }
         if (isSensitive(this.value)) {
             return [this.value.logValue()];
@@ -79,9 +83,9 @@ class simpleClause {
         return [this.value];
     }
     instanceKey() {
-        const sqliteClause = this.sqliteNull();
-        if (sqliteClause) {
-            return sqliteClause.instanceKey();
+        const nullClause = this.nullClause();
+        if (nullClause) {
+            return nullClause.instanceKey();
         }
         return `${this.col}${this.op}${rawValue(this.value)}`;
     }
@@ -90,9 +94,12 @@ class isNullClause {
     constructor(col) {
         this.col = col;
     }
-    clause(idx) {
+    clause(_idx) {
         return `${this.col} IS NULL`;
     }
+    columns() {
+        return [];
+    }
     values() {
         return [];
     }
@@ -110,6 +117,9 @@ class isNotNullClause {
     clause(idx) {
         return `${this.col} IS NOT NULL`;
     }
+    columns() {
+        return [];
+    }
     values() {
         return [];
     }
@@ -132,6 +142,9 @@ class arraySimpleClause {
         }
         return `${this.col} ${this.op} ?`;
     }
+    columns() {
+        return [this.col];
+    }
     values() {
         if (isSensitive(this.value)) {
             return [this.value.value()];
@@ -148,18 +161,111 @@ class arraySimpleClause {
         return `${this.col}${this.op}${rawValue(this.value)}`;
     }
 }
+class postgresArrayOperator {
+    constructor(col, value, op, not) {
+        this.col = col;
+        this.value = value;
+        this.op = op;
+        this.not = not;
+    }
+    clause(idx) {
+        if (db_1.default.getDialect() === db_1.Dialect.Postgres) {
+            if (this.not) {
+                return `NOT ${this.col} ${this.op} $${idx}`;
+            }
+            return `${this.col} ${this.op} $${idx}`;
+        }
+        throw new Error(`not supported`);
+    }
+    columns() {
+        return [this.col];
+    }
+    values() {
+        if (isSensitive(this.value)) {
+            return [`{${this.value.value()}}`];
+        }
+        return [`{${this.value}}`];
+    }
+    logValues() {
+        if (isSensitive(this.value)) {
+            return [`{${this.value.logValue()}}`];
+        }
+        return [`{${this.value}}`];
+    }
+    instanceKey() {
+        if (this.not) {
+            return `NOT:${this.col}${this.op}${rawValue(this.value)}`;
+        }
+        return `${this.col}${this.op}${rawValue(this.value)}`;
+    }
+}
+class postgresArrayOperatorList extends postgresArrayOperator {
+    constructor(col, value, op, not) {
+        super(col, value, op, not);
+    }
+    values() {
+        return [
+            `{${this.value
+                .map((v) => {
+                if (isSensitive(v)) {
+                    return v.value();
+                }
+                return v;
+            })
+                .join(", ")}}`,
+        ];
+    }
+    logValues() {
+        return [
+            `{${this.value
+                .map((v) => {
+                if (isSensitive(v)) {
+                    return v.logValue();
+                }
+                return v;
+            })
+                .join(", ")}}`,
+        ];
+    }
+}
 class inClause {
-    constructor(col, value) {
+    static getPostgresInClauseValuesThreshold() {
+        return 70;
+    }
+    constructor(col, value, type = "uuid") {
         this.col = col;
         this.value = value;
+        this.type = type;
+        this.op = "IN";
     }
     clause(idx) {
-        const dialect = db_1.default.getDialect();
+        // do a simple = when only one item
+        if (this.value.length === 1) {
+            if (this.op === "IN") {
+                return new simpleClause(this.col, this.value[0], "=").clause(idx);
+            }
+            else {
+                return new simpleClause(this.col, this.value[0], "!=").clause(idx);
+            }
+        }
+        const postgres = db_1.default.getDialect() === db_1.Dialect.Postgres;
+        const postgresValuesList = postgres &&
+            this.value.length >= inClause.getPostgresInClauseValuesThreshold();
         let indices;
-        if (dialect === db_1.Dialect.Postgres) {
+        if (postgres) {
             indices = [];
             for (let i = 0; i < this.value.length; i++) {
-                indices.push(`$${idx}`);
+                if (postgresValuesList) {
+                    if (i === 0) {
+                        indices.push(`($${idx}::${this.type})`);
+                    }
+                    else {
+                        indices.push(`($${idx})`);
+                    }
+                }
+                else {
+                    indices.push(`$${idx}`);
+                }
                 idx++;
             }
         }
@@ -167,54 +273,72 @@ class inClause {
             indices = new Array(this.value.length);
             indices.fill("?", 0);
         }
-        const inValue = indices.join(", ");
-        return `${this.col} IN (${inValue})`;
+        let inValue = indices.join(", ");
+        // wrap in VALUES list for postgres...
+        if (postgresValuesList) {
+            inValue = `VALUES${inValue}`;
+        }
+        return `${this.col} ${this.op} (${inValue})`;
         // TODO we need to return idx at end to query builder...
         // or anything that's doing a composite query so next clause knows where to start
         // or change to a sqlx.Rebind format
         // here's what sqlx does: https://play.golang.org/p/vPzvYqeAcP0
     }
+    columns() {
+        return [this.col];
+    }
     values() {
         const result = [];
-        for (const value of this.value) {
-            if (isSensitive(value)) {
-                result.push(value.value());
-            }
-            else {
-                result.push(value);
-            }
+        for (let value of this.value) {
+            result.push(rawValue(value));
         }
         return result;
     }
     logValues() {
         const result = [];
-        for (const value of this.value) {
-            if (isSensitive(value)) {
-                result.push(value.logValue());
-            }
-            else {
-                result.push(value);
-            }
+        for (let value of this.value) {
+            result.push(isSensitive(value) ? value.logValue() : value);
         }
         return result;
     }
     instanceKey() {
-        return `in:${this.col}:${this.values().join(",")}`;
+        return `${this.op.toLowerCase()}:${this.col}:${this.values().join(",")}`;
     }
 }
+exports.inClause = inClause;
+class notInClause extends inClause {
+    constructor() {
+        super(...arguments);
+        this.op = "NOT IN";
+    }
+}
+exports.notInClause = notInClause;
 class compositeClause {
     constructor(clauses, sep) {
         this.clauses = clauses;
         this.sep = sep;
+        this.compositeOp = this.sep;
     }
     clause(idx) {
         let clauses = [];
         for (const clause of this.clauses) {
-            clauses.push(clause.clause(idx));
+            let cls = clause.clause(idx);
+            // if composite clause and a different op, add parens so that we enforce order of precedence
+            if (clause.compositeOp && clause.compositeOp !== this.sep) {
+                cls = `(${cls})`;
+            }
+            clauses.push(cls);
             idx = idx + clause.values().length;
         }
         return clauses.join(this.sep);
     }
+    columns() {
+        const ret = [];
+        for (const cls of this.clauses) {
+            ret.push(...cls.columns());
+        }
+        return ret;
+    }
     values() {
         let result = [];
         for (const clause of this.clauses) {
@@ -231,7 +355,14 @@ class compositeClause {
     }
     instanceKey() {
         let keys = [];
-        this.clauses.forEach((clause) => keys.push(clause.instanceKey()));
+        this.clauses.forEach((clause) => {
+            if (clause.compositeOp && clause.compositeOp != this.sep) {
+                keys.push(`(${clause.instanceKey()})`);
+            }
+            else {
+                keys.push(clause.instanceKey());
+            }
+        });
         return keys.join(this.sep);
     }
 }
@@ -264,6 +395,9 @@ class tsQueryClause {
         // FYI this doesn't actually work for sqlite since different
         return `${this.col} @@ ${this.getFunction()}('${language}', ?)`;
     }
+    columns() {
+        return [this.col];
+    }
     values() {
         const { value } = this.getInfo();
         return [value];
@@ -298,31 +432,76 @@ class websearchTosQueryClause extends tsQueryClause {
         return "websearch_to_tsquery";
     }
 }
-// TODO we need to check sqlite version...
+// postgres array operators
+// https://www.postgresql.org/docs/current/functions-array.html
+/**
+ * creates a clause to determine if the given value is contained in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+function PostgresArrayContainsValue(col, value) {
+    return new postgresArrayOperator(col, value, "@>");
+}
+exports.PostgresArrayContainsValue = PostgresArrayContainsValue;
+/**
+ * creates a clause to determine if every item in the list is stored in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+function PostgresArrayContains(col, value) {
+    return new postgresArrayOperatorList(col, value, "@>");
+}
+exports.PostgresArrayContains = PostgresArrayContains;
+/**
+ * creates a clause to determine if the given value is NOT contained in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+function PostgresArrayNotContainsValue(col, value) {
+    return new postgresArrayOperator(col, value, "@>", true);
+}
+exports.PostgresArrayNotContainsValue = PostgresArrayNotContainsValue;
+/**
+ * creates a clause to determine if every item in the list is NOT stored in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+function PostgresArrayNotContains(col, value) {
+    return new postgresArrayOperatorList(col, value, "@>", true);
+}
+exports.PostgresArrayNotContains = PostgresArrayNotContains;
+/**
+ * creates a clause to determine if the arrays overlap, that is, do they have any elements in common
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+function PostgresArrayOverlaps(col, value) {
+    return new postgresArrayOperatorList(col, value, "&&");
+}
+exports.PostgresArrayOverlaps = PostgresArrayOverlaps;
+/**
+ * creates a clause to determine if the arrays do not overlap, that is, do they have any elements in common
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+function PostgresArrayNotOverlaps(col, value) {
+    return new postgresArrayOperatorList(col, value, "&&", true);
+}
+exports.PostgresArrayNotOverlaps = PostgresArrayNotOverlaps;
+/**
+ * @deprecated use PostgresArrayContainsValue
+ */
 function ArrayEq(col, value) {
     return new arraySimpleClause(col, value, "=");
 }
 exports.ArrayEq = ArrayEq;
+/**
+ * @deprecated use PostgresNotArrayContains
+ */
 function ArrayNotEq(col, value) {
     return new arraySimpleClause(col, value, "!=");
 }
 exports.ArrayNotEq = ArrayNotEq;
-function ArrayGreater(col, value) {
-    return new arraySimpleClause(col, value, ">");
-}
-exports.ArrayGreater = ArrayGreater;
-function ArrayLess(col, value) {
-    return new arraySimpleClause(col, value, "<");
-}
-exports.ArrayLess = ArrayLess;
-function ArrayGreaterEq(col, value) {
-    return new arraySimpleClause(col, value, ">=");
-}
-exports.ArrayGreaterEq = ArrayGreaterEq;
-function ArrayLessEq(col, value) {
-    return new arraySimpleClause(col, value, "<=");
-}
-exports.ArrayLessEq = ArrayLessEq;
 function Eq(col, value) {
     return new simpleClause(col, value, "=", new isNullClause(col));
 }
@@ -364,11 +543,66 @@ function Or(...args) {
     return new compositeClause(args, " OR ");
 }
 exports.Or = Or;
-// TODO this breaks if values.length ===1 and array. todo fix
-function In(col, ...values) {
-    return new inClause(col, values);
+function OrOptional(...args) {
+    // @ts-ignore
+    let filtered = args.filter((v) => v !== undefined);
+    if (filtered.length === 1) {
+        return filtered[0];
+    }
+    return Or(...filtered);
+}
+exports.OrOptional = OrOptional;
+function In(...args) {
+    if (args.length < 2) {
+        throw new Error(`invalid args passed to In`);
+    }
+    // 2nd overload
+    if (Array.isArray(args[1])) {
+        return new inClause(args[0], args[1], args[2]);
+    }
+    return new inClause(args[0], args.slice(1));
 }
 exports.In = In;
+function UuidIn(col, values) {
+    return new inClause(col, values, "uuid");
+}
+exports.UuidIn = UuidIn;
+function IntegerIn(col, values) {
+    return new inClause(col, values, "integer");
+}
+exports.IntegerIn = IntegerIn;
+function TextIn(col, values) {
+    return new inClause(col, values, "text");
+}
+exports.TextIn = TextIn;
+/*
+ * if not uuid or text, pass the db type that can be used to cast this query
+ * if we end up with a large list of ids
+ */
+function DBTypeIn(col, values, typ) {
+    return new inClause(col, values, typ);
+}
+exports.DBTypeIn = DBTypeIn;
+function UuidNotIn(col, values) {
+    return new notInClause(col, values, "uuid");
+}
+exports.UuidNotIn = UuidNotIn;
+function IntegerNotIn(col, values) {
+    return new notInClause(col, values, "integer");
+}
+exports.IntegerNotIn = IntegerNotIn;
+function TextNotIn(col, values) {
+    return new notInClause(col, values, "text");
+}
+exports.TextNotIn = TextNotIn;
+/*
+ * if not uuid or text, pass the db type that can be used to cast this query
+ * if we end up with a large list of ids
+ */
+function DBTypeNotIn(col, values, typ) {
+    return new notInClause(col, values, typ);
+}
+exports.DBTypeNotIn = DBTypeNotIn;
 // if string defaults to english
 // https://www.postgresql.org/docs/current/textsearch-controls.html#TEXTSEARCH-PARSING-QUERIES
 // to_tsquery
@@ -437,3 +671,133 @@ function sensitiveValue(val) {
     };
 }
 exports.sensitiveValue = sensitiveValue;
+// These don't return Clauses but return helpful things that can be passed to clauses
+// https://www.postgresql.org/docs/12/functions-json.html#FUNCTIONS-JSON-OP-TABLE
+// see test in db_clause.test.ts
+// unclear best time to use this...
+function JSONObjectFieldKeyASJSON(col, field) {
+    // type as keyof T to make it easier to use in other queries
+    return `${col}->'${field}'`;
+}
+exports.JSONObjectFieldKeyASJSON = JSONObjectFieldKeyASJSON;
+function JSONObjectFieldKeyAsText(col, field) {
+    // type as keyof T to make it easier to use in other queries
+    return `${col}->>'${field}'`;
+}
+exports.JSONObjectFieldKeyAsText = JSONObjectFieldKeyAsText;
+class jSONPathValuePredicateClause {
+    constructor(col, path, value, pred) {
+        this.col = col;
+        this.path = path;
+        this.value = value;
+        this.pred = pred;
+    }
+    clause(idx) {
+        if (db_1.default.getDialect() !== db_1.Dialect.Postgres) {
+            throw new Error(`not supported`);
+        }
+        return `${this.col} @@ $${idx}`;
+    }
+    columns() {
+        return [this.col];
+    }
+    wrap(val) {
+        return `${this.path} ${this.pred} ${JSON.stringify(val)}`;
+    }
+    values() {
+        if (isSensitive(this.value)) {
+            return [this.wrap(this.value.value())];
+        }
+        return [this.wrap(this.value)];
+    }
+    logValues() {
+        if (isSensitive(this.value)) {
+            return [this.wrap(this.value.logValue())];
+        }
+        return [this.wrap(this.value)];
+    }
+    instanceKey() {
+        return `${this.col}${this.path}${rawValue(this.value)}${this.pred}`;
+    }
+}
+// https://www.postgresql.org/docs/12/functions-json.html#FUNCTIONS-JSON-OP-TABLE
+function JSONPathValuePredicate(dbCol, path, val, pred) {
+    return new jSONPathValuePredicateClause(dbCol, path, val, pred);
+}
+exports.JSONPathValuePredicate = JSONPathValuePredicate;
+// TODO need a better name for this lol
+// this assumes we're doing the same direction twice which isn't necessarily accurate in the future...
+class paginationMultipleColumnsSubQueryClause {
+    constructor(col, op, tableName, uniqueCol, val) {
+        this.col = col;
+        this.op = op;
+        this.tableName = tableName;
+        this.uniqueCol = uniqueCol;
+        this.val = val;
+    }
+    buildSimpleQuery(clause, idx) {
+        return `SELECT ${this.col} FROM ${this.tableName} WHERE ${clause.clause(idx)}`;
+    }
+    clause(idx) {
+        const eq1 = this.buildSimpleQuery(Eq(this.uniqueCol, this.val), idx);
+        const eq2 = this.buildSimpleQuery(Eq(this.uniqueCol, this.val), idx + 1);
+        const op = new simpleClause(this.uniqueCol, this.val, this.op).clause(idx + 2);
+        // nest in () to make sure it's scoped correctly
+        return `(${this.col} ${this.op} (${eq1}) OR (${this.col} = (${eq2}) AND ${op}))`;
+    }
+    columns() {
+        return [this.col];
+    }
+    values() {
+        return [this.val, this.val, this.val];
+    }
+    logValues() {
+        const log = isSensitive(this.val) ? this.val.logValue() : this.val;
+        return [log, log, log];
+    }
+    instanceKey() {
+        return `${this.col}-${this.op}-${this.tableName}-${this.uniqueCol}-${this.val}`;
+    }
+}
+function PaginationMultipleColsSubQuery(col, op, tableName, uniqueCol, val) {
+    return new paginationMultipleColumnsSubQueryClause(col, op, tableName, uniqueCol, val);
+}
+exports.PaginationMultipleColsSubQuery = PaginationMultipleColsSubQuery;
+// These 5 are used on the RHS of an expression
+function Add(col, value) {
+    return new simpleClause(col, value, "+", new isNullClause(col));
+}
+exports.Add = Add;
+function Subtract(col, value) {
+    return new simpleClause(col, value, "-", new isNullClause(col));
+}
+exports.Subtract = Subtract;
+function Multiply(col, value) {
+    return new simpleClause(col, value, "*", new isNullClause(col));
+}
+exports.Multiply = Multiply;
+function Divide(col, value) {
+    return new simpleClause(col, value, "/", new isNullClause(col));
+}
+exports.Divide = Divide;
+function Modulo(col, value) {
+    return new simpleClause(col, value, "%", new isNullClause(col));
+}
+exports.Modulo = Modulo;
+function getCombinedClause(options, cls) {
+    if (options.clause) {
+        let optionClause;
+        if (typeof options.clause === "function") {
+            optionClause = options.clause();
+        }
+        else {
+            optionClause = options.clause;
+        }
+        if (optionClause) {
+            // @ts-expect-error different types
+            cls = And(cls, optionClause);
+        }
+    }
+    return cls;
+}
+exports.getCombinedClause = getCombinedClause;

package/core/config.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { Database, DBDict } from "./db";
-declare type logType = "query" | "warn" | "info" | "error" | "debug";
+type logType = "query" | "warn" | "info" | "error" | "debug";
 declare enum graphqlMutationName {
     NOUN_VERB = "NounVerb",
     VERB_NOUN = "VerbNoun"
@@ -18,8 +18,14 @@ export interface Config {
     dbFile?: string;
     db?: Database | DBDict;
     log?: logType | logType[];
+    logQueryWithError?: boolean;
+    defaultConnectionLimit?: number;
+}
+export interface ConfigWithCodegen extends Config {
     codegen?: CodegenConfig;
     customGraphQLJSONPath?: string;
+    dynamicScriptCustomGraphQLJSONPath?: string;
+    globalSchemaPath?: string;
 }
 interface CodegenConfig {
     defaultEntPolicy?: PrivacyConfig;
@@ -35,7 +41,10 @@ interface CodegenConfig {
     schemaSQLFilePath?: boolean;
     databaseToCompareTo?: string;
     fieldPrivacyEvaluated?: fieldPrivacyEvaluated;
-    templatizedViewer?: templatizedViewer;
+    templatizedViewer?: importedObject;
+    customAssocEdgePath?: importedObject;
+    globalImportPath?: string;
+    userOveriddenFiles?: string[];
 }
 interface PrettierConfig {
     custom?: boolean;
@@ -46,9 +55,10 @@ interface PrivacyConfig {
     policyName: string;
     class?: boolean;
 }
-interface templatizedViewer {
+interface importedObject {
     path: string;
     name: string;
+    alias?: string;
 }
 export declare function loadConfig(file?: string | Buffer | Config): void;
 export {};