@snowtop/ent 0.1.12 → 0.1.13

package/action/experimental_action.js

@@ -64,11 +64,11 @@ class BaseAction {
     }
     async save() {
         await this.builder.save();
-        return await this.builder.editedEnt();
+        return this.builder.editedEnt();
     }
     async saveX() {
         await this.builder.saveX();
-        return await this.builder.editedEntX();
+        return this.builder.editedEntX();
     }
     getInput() {
         return this.input;

package/action/operations.js

@@ -358,7 +358,7 @@ class EdgeOperation {
     async performDeleteWrite(q, edgeData, edge, context) {
         const params = this.getDeleteRowParams(edgeData, edge, context);
         if (params.op === schema_1.SQLStatementOperation.Delete) {
-            return (0, ent_1.deleteRows)(q, params.options, params.clause);
+            return (0, ent_1.deleteRows)(q, { ...params.options, context }, params.clause);
         }
         else {
             if (params.op !== schema_1.SQLStatementOperation.Update) {
@@ -369,13 +369,14 @@ class EdgeOperation {
                 whereClause: params.clause,
                 fields: params.updateData,
                 fieldsToLog: params.updateData,
+                context,
             });
         }
     }
     performDeleteWriteSync(q, edgeData, edge, context) {
         const params = this.getDeleteRowParams(edgeData, edge, context);
         if (params.op === schema_1.SQLStatementOperation.Delete) {
-            return (0, ent_1.deleteRowsSync)(q, params.options, params.clause);
+            return (0, ent_1.deleteRowsSync)(q, { ...params.options, context }, params.clause);
         }
         else {
             if (params.op !== schema_1.SQLStatementOperation.Update) {
@@ -385,6 +386,7 @@ class EdgeOperation {
                 tableName: params.options.tableName,
                 whereClause: params.clause,
                 fields: params.updateData,
+                context,
             });
         }
     }

package/core/base.d.ts

@@ -26,21 +26,16 @@ export interface PrimableLoader<K, V> extends Loader<K, V> {
     prime(d: V): void;
     primeAll?(d: V): void;
 }
+export type QueryOptions = Required<Pick<LoadRowsOptions, "clause" | "fields" | "tableName">> & Pick<LoadRowsOptions, "orderby" | "join">;
 interface cache {
     getLoader<K, V>(name: string, create: () => Loader<K, V>): Loader<K, V>;
     getLoaderWithLoadMany<K, V>(name: string, create: () => LoaderWithLoadMany<K, V>): LoaderWithLoadMany<K, V>;
-    getCachedRows(options: queryOptions): Data[] | null;
-    getCachedRow(options: queryOptions): Data | null;
-    primeCache(options: queryOptions, rows: Data[]): void;
-    primeCache(options: queryOptions, rows: Data): void;
+    getCachedRows(options: QueryOptions): Data[] | null;
+    getCachedRow(options: QueryOptions): Data | null;
+    primeCache(options: QueryOptions, rows: Data[]): void;
+    primeCache(options: QueryOptions, rows: Data): void;
     clearCache(): void;
 }
-interface queryOptions {
-    fields: string[];
-    tableName: string;
-    clause: clause.Clause;
-    orderby?: OrderBy;
-}
 export interface Context<TViewer extends Viewer = Viewer> {
     getViewer(): TViewer;
     cache?: cache;
@@ -67,6 +62,7 @@ export interface EntConstructor<TEnt extends Ent, TViewer extends Viewer = Viewe
 export type ID = string | number;
 export interface DataOptions {
     tableName: string;
+    alias?: string;
     context?: Context;
 }
 export interface SelectBaseDataOptions extends DataOptions {
@@ -79,6 +75,11 @@ export interface SelectDataOptions extends SelectBaseDataOptions {
 }
 export interface QueryableDataOptions extends SelectBaseDataOptions, QueryDataOptions {
 }
+interface JoinOptions<T2 extends Data = Data, K2 = keyof T2> {
+    tableName: string;
+    alias?: string;
+    clause: clause.Clause<T2, K2>;
+}
 export interface QueryDataOptions<T extends Data = Data, K = keyof T> {
     distinct?: boolean;
     clause: clause.Clause<T, K>;
@@ -86,6 +87,7 @@ export interface QueryDataOptions<T extends Data = Data, K = keyof T> {
     groupby?: K;
     limit?: number;
     disableTransformations?: boolean;
+    join?: JoinOptions;
 }
 export interface LoadRowOptions extends QueryableDataOptions {
 }

package/core/clause.d.ts

@@ -1,6 +1,6 @@
 import { Data, ID, SelectDataOptions } from "./base";
 export interface Clause<T extends Data = Data, K = keyof T> {
-    clause(idx: number): string;
+    clause(idx: number, alias?: string): string;
     columns(): K[];
     values(): any[];
     instanceKey(): string;
@@ -19,7 +19,7 @@ export declare class inClause<T extends Data, K = keyof T> implements Clause<T,
     protected op: InClauseOperator;
     static getPostgresInClauseValuesThreshold(): number;
     constructor(col: K, value: any[], type?: string);
-    clause(idx: number): string;
+    clause(idx: number, alias?: string): string;
     columns(): K[];
     values(): any[];
     logValues(): any[];
@@ -124,5 +124,6 @@ export declare function Subtract<T extends Data, K = keyof T>(col: K, value: any
 export declare function Multiply<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
 export declare function Divide<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
 export declare function Modulo<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
-export declare function getCombinedClause<V extends Data = Data, K = keyof V>(options: Omit<SelectDataOptions, "key">, cls: Clause<V, K>): Clause<V, K>;
+export declare function getCombinedClause<V extends Data = Data, K = keyof V>(options: Pick<SelectDataOptions, "clause">, cls: Clause<V, K>, checkIntersection?: boolean): Clause<V, K>;
+export declare function Expression<T extends Data, K = keyof T>(expression: string): Clause<T, K>;
 export {};

package/core/clause.js

@@ -24,7 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Modulo = exports.Divide = exports.Multiply = exports.Subtract = exports.Add = exports.PaginationMultipleColsSubQuery = exports.JSONKeyInList = exports.JSONBKeyInList = exports.JSONKeyExists = 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;
-exports.getCombinedClause = void 0;
+exports.Expression = exports.getCombinedClause = void 0;
 const db_1 = __importStar(require("./db"));
 const query_impl_1 = require("./query_impl");
 function isSensitive(val) {
@@ -38,6 +38,12 @@ function rawValue(val) {
     }
     return val;
 }
+function renderCol(col, alias) {
+    if (alias) {
+        return `${alias}.${col}`;
+    }
+    return col;
+}
 class simpleClause {
     constructor(col, value, op, handleNull) {
         this.col = col;
@@ -45,15 +51,15 @@ class simpleClause {
         this.op = op;
         this.handleNull = handleNull;
     }
-    clause(idx) {
+    clause(idx, alias) {
         const nullClause = this.nullClause();
         if (nullClause) {
-            return nullClause.clause(idx);
+            return nullClause.clause(idx, alias);
         }
         if (db_1.default.getDialect() === db_1.Dialect.Postgres) {
-            return `${this.col} ${this.op} $${idx}`;
+            return `${renderCol(this.col, alias)} ${this.op} $${idx}`;
         }
-        return `${this.col} ${this.op} ?`;
+        return `${renderCol(this.col, alias)} ${this.op} ?`;
     }
     nullClause() {
         if (!this.handleNull || this.value !== null) {
@@ -92,13 +98,17 @@ class simpleClause {
         return `${this.col}${this.op}${rawValue(this.value)}`;
     }
 }
+// NB: we're not using alias in this class in clause method
+// if we end up with a subclass that does, we need to handle it
 class queryClause {
-    constructor(dependentQueryOptions) {
+    constructor(dependentQueryOptions, // private value: any, // private op: string, // private handleNull?: Clause<T, K>,
+    prefix) {
         this.dependentQueryOptions = dependentQueryOptions;
+        this.prefix = prefix;
     }
-    clause(idx) {
+    clause(idx, alias) {
         const q = (0, query_impl_1.buildQuery)(this.dependentQueryOptions);
-        return `EXISTS (${q})`;
+        return `${this.prefix} (${q})`;
     }
     columns() {
         // @ts-ignore
@@ -111,15 +121,21 @@ class queryClause {
         return this.dependentQueryOptions.clause.logValues();
     }
     instanceKey() {
-        return `exists:${this.dependentQueryOptions.tableName}:${this.dependentQueryOptions.clause.instanceKey()}`;
+        return `${this.prefix.toLowerCase()}:${this.dependentQueryOptions.tableName}:${this.dependentQueryOptions.clause.instanceKey()}`;
+    }
+}
+class existsQueryClause extends queryClause {
+    constructor(dependentQueryOptions) {
+        super(dependentQueryOptions, "EXISTS");
+        this.dependentQueryOptions = dependentQueryOptions;
     }
 }
 class isNullClause {
     constructor(col) {
         this.col = col;
     }
-    clause(_idx) {
-        return `${this.col} IS NULL`;
+    clause(_idx, alias) {
+        return `${renderCol(this.col, alias)} IS NULL`;
     }
     columns() {
         return [];
@@ -138,8 +154,8 @@ class isNotNullClause {
     constructor(col) {
         this.col = col;
     }
-    clause(idx) {
-        return `${this.col} IS NOT NULL`;
+    clause(idx, alias) {
+        return `${renderCol(this.col, alias)} IS NOT NULL`;
     }
     columns() {
         return [];
@@ -154,17 +170,37 @@ class isNotNullClause {
         return `${this.col} IS NOT NULL`;
     }
 }
+class simpleExpression {
+    constructor(expression) {
+        this.expression = expression;
+    }
+    clause(idx, alias) {
+        return this.expression;
+    }
+    columns() {
+        return [];
+    }
+    values() {
+        return [];
+    }
+    logValues() {
+        return [];
+    }
+    instanceKey() {
+        return `${this.expression}`;
+    }
+}
 class arraySimpleClause {
     constructor(col, value, op) {
         this.col = col;
         this.value = value;
         this.op = op;
     }
-    clause(idx) {
+    clause(idx, alias) {
         if (db_1.default.getDialect() === db_1.Dialect.Postgres) {
-            return `$${idx} ${this.op} ANY(${this.col})`;
+            return `$${idx} ${this.op} ANY(${renderCol(this.col, alias)})`;
         }
-        return `${this.col} ${this.op} ?`;
+        return `${renderCol(this.col, alias)} ${this.op} ?`;
     }
     columns() {
         return [this.col];
@@ -192,12 +228,12 @@ class postgresArrayOperator {
         this.op = op;
         this.not = not;
     }
-    clause(idx) {
+    clause(idx, alias) {
         if (db_1.default.getDialect() === db_1.Dialect.Postgres) {
             if (this.not) {
-                return `NOT ${this.col} ${this.op} $${idx}`;
+                return `NOT ${renderCol(this.col, alias)} ${this.op} $${idx}`;
             }
-            return `${this.col} ${this.op} $${idx}`;
+            return `${renderCol(this.col, alias)} ${this.op} $${idx}`;
         }
         throw new Error(`not supported`);
     }
@@ -262,14 +298,14 @@ class inClause {
         this.type = type;
         this.op = "IN";
     }
-    clause(idx) {
+    clause(idx, alias) {
         // 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);
+                return new simpleClause(this.col, this.value[0], "=").clause(idx, alias);
             }
             else {
-                return new simpleClause(this.col, this.value[0], "!=").clause(idx);
+                return new simpleClause(this.col, this.value[0], "!=").clause(idx, alias);
             }
         }
         const postgres = db_1.default.getDialect() === db_1.Dialect.Postgres;
@@ -302,7 +338,7 @@ class inClause {
         if (postgresValuesList) {
             inValue = `VALUES${inValue}`;
         }
-        return `${this.col} ${this.op} (${inValue})`;
+        return `${renderCol(this.col, alias)} ${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
@@ -343,10 +379,10 @@ class compositeClause {
         this.sep = sep;
         this.compositeOp = this.sep;
     }
-    clause(idx) {
+    clause(idx, alias) {
         let clauses = [];
         for (const clause of this.clauses) {
-            let cls = clause.clause(idx);
+            let cls = clause.clause(idx, alias);
             // 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})`;
@@ -408,16 +444,16 @@ class tsQueryClause {
             value: this.val,
         };
     }
-    clause(idx) {
+    clause(idx, alias) {
         const { language } = this.getInfo();
         if (db_1.Dialect.Postgres === db_1.default.getDialect()) {
             if (this.tsVectorCol) {
-                return `to_tsvector(${this.col}) @@ ${this.getFunction()}('${language}', $${idx})`;
+                return `to_tsvector(${renderCol(this.col, alias)}) @@ ${this.getFunction()}('${language}', $${idx})`;
             }
-            return `${this.col} @@ ${this.getFunction()}('${language}', $${idx})`;
+            return `${renderCol(this.col, alias)} @@ ${this.getFunction()}('${language}', $${idx})`;
         }
         // FYI this doesn't actually work for sqlite since different
-        return `${this.col} @@ ${this.getFunction()}('${language}', ?)`;
+        return `${renderCol(this.col, alias)} @@ ${this.getFunction()}('${language}', ?)`;
     }
     columns() {
         return [this.col];
@@ -716,11 +752,11 @@ class jSONPathValuePredicateClause {
         this.value = value;
         this.pred = pred;
     }
-    clause(idx) {
+    clause(idx, alias) {
         if (db_1.default.getDialect() !== db_1.Dialect.Postgres) {
             throw new Error(`not supported`);
         }
-        return `${this.col} @@ $${idx}`;
+        return `${renderCol(this.col, alias)} @@ $${idx}`;
     }
     columns() {
         return [this.col];
@@ -762,7 +798,7 @@ function JSONBKeyInList(dbCol, jsonCol, val) {
         // @ts-ignore
         Eq(JSONObjectFieldKeyAsText("json_element", jsonCol), val)),
     };
-    return new queryClause(opts);
+    return new existsQueryClause(opts);
 }
 exports.JSONBKeyInList = JSONBKeyInList;
 function JSONKeyInList(dbCol, jsonCol, val) {
@@ -774,7 +810,7 @@ function JSONKeyInList(dbCol, jsonCol, val) {
         // @ts-ignore
         Eq(JSONObjectFieldKeyAsText("json_element", jsonCol), val)),
     };
-    return new queryClause(opts);
+    return new existsQueryClause(opts);
 }
 exports.JSONKeyInList = JSONKeyInList;
 // TODO need a better name for this lol
@@ -787,15 +823,15 @@ class paginationMultipleColumnsSubQueryClause {
         this.uniqueCol = uniqueCol;
         this.val = val;
     }
-    buildSimpleQuery(clause, idx) {
-        return `SELECT ${this.col} FROM ${this.tableName} WHERE ${clause.clause(idx)}`;
+    buildSimpleQuery(clause, idx, alias) {
+        return `SELECT ${renderCol(this.col, alias)} FROM ${this.tableName} WHERE ${clause.clause(idx, alias)}`;
     }
-    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);
+    clause(idx, alias) {
+        const eq1 = this.buildSimpleQuery(Eq(this.uniqueCol, this.val), idx, alias);
+        const eq2 = this.buildSimpleQuery(Eq(this.uniqueCol, this.val), idx + 1, alias);
+        const op = new simpleClause(this.uniqueCol, this.val, this.op).clause(idx + 2, alias);
         // nest in () to make sure it's scoped correctly
-        return `(${this.col} ${this.op} (${eq1}) OR (${this.col} = (${eq2}) AND ${op}))`;
+        return `(${renderCol(this.col, alias)} ${this.op} (${eq1}) OR (${renderCol(this.col, alias)} = (${eq2}) AND ${op}))`;
     }
     columns() {
         return [this.col];
@@ -836,7 +872,7 @@ function Modulo(col, value) {
     return new simpleClause(col, value, "%", new isNullClause(col));
 }
 exports.Modulo = Modulo;
-function getCombinedClause(options, cls) {
+function getCombinedClause(options, cls, checkIntersection = false) {
     if (options.clause) {
         let optionClause;
         if (typeof options.clause === "function") {
@@ -846,10 +882,29 @@ function getCombinedClause(options, cls) {
             optionClause = options.clause;
         }
         if (optionClause) {
-            // @ts-expect-error different types
-            cls = And(cls, optionClause);
+            let and = true;
+            if (checkIntersection) {
+                // this should be the smaller one
+                const transformedCols = new Set(optionClause.columns());
+                const queriedCols = cls.columns();
+                const has = new Set();
+                for (const col of queriedCols) {
+                    if (transformedCols.has(col)) {
+                        has.add(col);
+                    }
+                }
+                and = transformedCols.size > 0 && has.size !== transformedCols.size;
+            }
+            if (and) {
+                // @ts-expect-error different types
+                cls = And(cls, optionClause);
+            }
         }
     }
     return cls;
 }
 exports.getCombinedClause = getCombinedClause;
+function Expression(expression) {
+    return new simpleExpression(expression);
+}
+exports.Expression = Expression;

package/core/config.d.ts

@@ -23,10 +23,15 @@ export interface Config {
 }
 export interface ConfigWithCodegen extends Config {
     codegen?: CodegenConfig;
+    databaseMigration?: DatabaseMigrationConfig;
     customGraphQLJSONPath?: string;
     dynamicScriptCustomGraphQLJSONPath?: string;
     globalSchemaPath?: string;
 }
+interface DatabaseMigrationConfig {
+    custom_sql_include?: string[];
+    custom_sql_exclude?: string[];
+}
 interface CodegenConfig {
     defaultEntPolicy?: PrivacyConfig;
     defaultActionPolicy?: PrivacyConfig;
@@ -45,6 +50,7 @@ interface CodegenConfig {
     customAssocEdgePath?: importedObject;
     globalImportPath?: string;
     userOveriddenFiles?: string[];
+    transformLoadMethod?: string;
     transformDeleteMethod?: string;
 }
 interface PrettierConfig {

package/core/context.d.ts

@@ -1,9 +1,7 @@
 /// <reference types="node" />
-import { Viewer, Data, Loader, LoaderWithLoadMany } from "./base";
+import { Viewer, Data, Loader, LoaderWithLoadMany, QueryOptions } from "./base";
 import { IncomingMessage, ServerResponse } from "http";
-import * as clause from "./clause";
 import { Context } from "./base";
-import { OrderBy } from "./query_impl";
 export interface RequestContext<TViewer extends Viewer = Viewer> extends Context<TViewer> {
     authViewer(viewer: TViewer): Promise<void>;
     logout(): Promise<void>;
@@ -13,21 +11,15 @@ export interface RequestContext<TViewer extends Viewer = Viewer> extends Context
 export declare class ContextCache {
     loaders: Map<string, Loader<any, any>>;
     loaderWithLoadMany: Map<string, LoaderWithLoadMany<any, any>>;
+    discardedLoaders: Loader<any, any>[];
     getLoader<K, V>(name: string, create: () => Loader<K, V>): Loader<K, V>;
     getLoaderWithLoadMany<K, V>(name: string, create: () => LoaderWithLoadMany<K, V>): LoaderWithLoadMany<K, V>;
     private itemMap;
     private listMap;
     private getkey;
-    getCachedRows(options: queryOptions): Data[] | null;
-    getCachedRow(options: queryOptions): Data | null;
-    primeCache(options: queryOptions, rows: Data[]): void;
-    primeCache(options: queryOptions, rows: Data): void;
+    getCachedRows(options: QueryOptions): Data[] | null;
+    getCachedRow(options: QueryOptions): Data | null;
+    primeCache(options: QueryOptions, rows: Data[]): void;
+    primeCache(options: QueryOptions, rows: Data): void;
     clearCache(): void;
 }
-interface queryOptions {
-    fields: string[];
-    tableName: string;
-    clause: clause.Clause;
-    orderby?: OrderBy;
-}
-export {};

package/core/context.js

@@ -8,6 +8,9 @@ class ContextCache {
         this.loaders = new Map();
         // we should eventually combine the two but better for typing to be separate for now
         this.loaderWithLoadMany = new Map();
+        // keep track of discarded loaders in case someone ends up holding onto a reference
+        // so that we can call clearAll() on them
+        this.discardedLoaders = [];
         // we have a per-table map to make it easier to purge and have less things to compare with
         this.itemMap = new Map();
         this.listMap = new Map();
@@ -42,6 +45,9 @@ class ContextCache {
         if (options.orderby) {
             parts.push((0, query_impl_1.getOrderByPhrase)(options.orderby));
         }
+        if (options.join) {
+            parts.push((0, query_impl_1.getJoinPhrase)(options.join));
+        }
         return parts.join(",");
     }
     getCachedRows(options) {
@@ -87,15 +93,14 @@ class ContextCache {
         }
     }
     clearCache() {
+        this.discardedLoaders.forEach((l) => l.clearAll());
         for (const [_key, loader] of this.loaders) {
-            // may not need this since we're clearing the loaders themselves...
-            // but may have some benefits by explicitily doing so?
             loader.clearAll();
+            this.discardedLoaders.push(loader);
         }
         for (const [_key, loader] of this.loaderWithLoadMany) {
-            // may not need this since we're clearing the loaders themselves...
-            // but may have some benefits by explicitily doing so?
             loader.clearAll();
+            this.discardedLoaders.push(loader);
         }
         this.loaders.clear();
         this.loaderWithLoadMany.clear();

package/core/db.js

@@ -324,7 +324,7 @@ class Postgres {
         };
     }
     async close() {
-        return await this.pool.end();
+        return this.pool.end();
     }
 }
 exports.Postgres = Postgres;

package/core/ent.d.ts

@@ -175,6 +175,7 @@ interface loadEdgeForIDOptions<T extends AssocEdge> extends loadCustomEdgesOptio
     id2: ID;
 }
 export declare function loadEdgeForID2<T extends AssocEdge>(options: loadEdgeForIDOptions<T>): Promise<T | undefined>;
+export declare function loadTwoWayEdges<T extends AssocEdge>(opts: loadCustomEdgesOptions<T>): Promise<T[]>;
 export declare function loadNodesByEdge<T extends Ent>(viewer: Viewer, id1: ID, edgeType: string, options: LoadEntOptions<T>): Promise<T[]>;
 export declare function applyPrivacyPolicyForRow<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, options: LoadEntOptions<TEnt, TViewer>, row: Data): Promise<TEnt | null>;
 export declare function applyPrivacyPolicyForRows<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, rows: Data[], options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt[]>;

package/core/ent.js

@@ -26,8 +26,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyPrivacyPolicyForRows = exports.applyPrivacyPolicyForRow = exports.loadNodesByEdge = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadCustomEdges = exports.getEdgeClauseAndFields = exports.loadEdges = exports.getDefaultLimit = exports.setDefaultLimit = exports.loadEdgeDatas = exports.loadEdgeData = exports.assocEdgeLoader = exports.AssocEdgeData = exports.getCursor = exports.AssocEdge = exports.deleteRowsSync = exports.deleteRows = exports.editRowSync = exports.editRow = exports.buildUpdateQuery = exports.createRowSync = exports.createRow = exports.buildInsertQuery = exports.buildGroupQuery = exports.loadRows = exports.performRawQuery = exports.___setLogQueryErrorWithError = exports.loadRow = exports.loadRowX = exports.logQuery = exports.loadDerivedEntX = exports.loadDerivedEnt = exports.loadCustomCount = exports.loadCustomData = exports.loadCustomEnts = exports.loadEntsFromClause = exports.loadEntsList = exports.loadEnts = exports.loadEntXFromClause = exports.loadEntFromClause = exports.loadEntXViaKey = exports.loadEntX = exports.loadEntViaKey = exports.loadEnt = exports.getEntKey = exports.getEntLoader = exports.rowIsError = void 0;
-exports.getEdgeTypeInGroup = void 0;
+exports.applyPrivacyPolicyForRow = exports.loadNodesByEdge = exports.loadTwoWayEdges = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadCustomEdges = exports.getEdgeClauseAndFields = exports.loadEdges = exports.getDefaultLimit = exports.setDefaultLimit = exports.loadEdgeDatas = exports.loadEdgeData = exports.assocEdgeLoader = exports.AssocEdgeData = exports.getCursor = exports.AssocEdge = exports.deleteRowsSync = exports.deleteRows = exports.editRowSync = exports.editRow = exports.buildUpdateQuery = exports.createRowSync = exports.createRow = exports.buildInsertQuery = exports.buildGroupQuery = exports.loadRows = exports.performRawQuery = exports.___setLogQueryErrorWithError = exports.loadRow = exports.loadRowX = exports.logQuery = exports.loadDerivedEntX = exports.loadDerivedEnt = exports.loadCustomCount = exports.loadCustomData = exports.loadCustomEnts = exports.loadEntsFromClause = exports.loadEntsList = exports.loadEnts = exports.loadEntXFromClause = exports.loadEntFromClause = exports.loadEntXViaKey = exports.loadEntX = exports.loadEntViaKey = exports.loadEnt = exports.getEntKey = exports.getEntLoader = exports.rowIsError = void 0;
+exports.getEdgeTypeInGroup = exports.applyPrivacyPolicyForRows = void 0;
 const db_1 = __importStar(require("./db"));
 const privacy_1 = require("./privacy");
 const clause = __importStar(require("./clause"));
@@ -301,7 +301,7 @@ async function loadEntXFromClause(viewer, options, clause) {
         context: viewer.context,
     };
     const row = await loadRowX(rowOptions);
-    return await applyPrivacyPolicyForRowX(viewer, options, row);
+    return applyPrivacyPolicyForRowX(viewer, options, row);
 }
 exports.loadEntXFromClause = loadEntXFromClause;
 async function loadEnts(viewer, options, ...ids) {
@@ -447,7 +447,7 @@ async function loadCustomDataImpl(options, query, context) {
         // this will have rudimentary caching but nothing crazy
         let cls = query.clause;
         if (!query.disableTransformations) {
-            cls = clause.getCombinedClause(options.loaderFactory.options, query.clause);
+            cls = clause.getCombinedClause(options.loaderFactory.options, query.clause, true);
         }
         return loadRows({
             ...query,
@@ -474,7 +474,7 @@ exports.loadDerivedEnt = loadDerivedEnt;
 // won't have caching yet either
 async function loadDerivedEntX(viewer, data, loader) {
     const ent = new loader(viewer, data);
-    return await applyPrivacyPolicyForEntX(viewer, ent, data, { ent: loader });
+    return applyPrivacyPolicyForEntX(viewer, ent, data, { ent: loader });
 }
 exports.loadDerivedEntX = loadDerivedEntX;
 // everything calls into this two so should be fine
@@ -978,7 +978,7 @@ function getEdgeClauseAndFields(cls, options) {
 }
 exports.getEdgeClauseAndFields = getEdgeClauseAndFields;
 async function loadCustomEdges(options) {
-    const { cls: actualClause, fields, defaultOptions, tableName, } = await loadEgesInfo(options);
+    const { cls: actualClause, fields, defaultOptions, tableName, } = await loadEdgesInfo(options);
     const rows = await loadRows({
         tableName,
         fields: fields,
@@ -992,7 +992,7 @@ async function loadCustomEdges(options) {
     });
 }
 exports.loadCustomEdges = loadCustomEdges;
-async function loadEgesInfo(options, id2) {
+async function loadEdgesInfo(options, id2) {
     const { id1, edgeType } = options;
     const edgeData = await loadEdgeData(edgeType);
     if (!edgeData) {
@@ -1037,7 +1037,7 @@ async function loadUniqueNode(viewer, id1, edgeType, options) {
     if (!edge) {
         return null;
     }
-    return await loadEnt(viewer, edge.id2, options);
+    return loadEnt(viewer, edge.id2, options);
 }
 exports.loadUniqueNode = loadUniqueNode;
 async function loadRawEdgeCountX(options) {
@@ -1058,10 +1058,10 @@ async function loadRawEdgeCountX(options) {
 }
 exports.loadRawEdgeCountX = loadRawEdgeCountX;
 async function loadEdgeForID2(options) {
-    const { cls: actualClause, fields, tableName, } = await loadEgesInfo(options, options.id2);
+    const { cls: actualClause, fields, tableName, } = await loadEdgesInfo(options, options.id2);
     const row = await loadRow({
         tableName,
-        fields: fields,
+        fields,
         clause: actualClause,
         context: options.context,
     });
@@ -1070,6 +1070,25 @@ async function loadEdgeForID2(options) {
     }
 }
 exports.loadEdgeForID2 = loadEdgeForID2;
+async function loadTwoWayEdges(opts) {
+    const { cls: actualClause, fields, tableName } = await loadEdgesInfo(opts);
+    const rows = await loadRows({
+        tableName,
+        alias: "t1",
+        fields,
+        clause: actualClause,
+        context: opts.context,
+        join: {
+            tableName,
+            alias: "t2",
+            clause: clause.And(
+            // these are not values so need this to not think they're values...
+            clause.Expression("t1.id1 = t2.id2"), clause.Expression("t1.id2 = t2.id1")),
+        },
+    });
+    return rows;
+}
+exports.loadTwoWayEdges = loadTwoWayEdges;
 async function loadNodesByEdge(viewer, id1, edgeType, options) {
     // load edges
     const rows = await loadEdges({
@@ -1093,7 +1112,7 @@ async function applyPrivacyPolicyForRowImpl(viewer, options, row) {
 }
 async function applyPrivacyPolicyForRowX(viewer, options, row) {
     const ent = new options.ent(viewer, row);
-    return await applyPrivacyPolicyForEntX(viewer, ent, row, options);
+    return applyPrivacyPolicyForEntX(viewer, ent, row, options);
 }
 // deprecated. doesn't use entcache
 async function applyPrivacyPolicyForRowsDeprecated(viewer, rows, options) {