@snowtop/ent 0.1.0-alpha152 → 0.1.0-alpha153

package/core/privacy.d.ts

@@ -1,4 +1,4 @@
-import { Ent, ID, LoadEntOptions, PrivacyError, PrivacyPolicy, PrivacyPolicyRule, PrivacyResult, Viewer } from "./base";
+import { Ent, ID, LoadEntOptions, PrivacyError, PrivacyPolicy, PrivacyPolicyRule, PrivacyResult, Viewer, EdgeQueryableDataOptionsConfigureLoader } from "./base";
 export declare class EntPrivacyError extends Error implements PrivacyError {
     privacyPolicy: PrivacyPolicy;
     privacyRule: PrivacyPolicyRule;
@@ -115,51 +115,60 @@ export declare class AllowIfEdgeExistsRule implements PrivacyPolicyRule {
     private id1;
     private id2;
     private edgeType;
-    constructor(id1: ID, id2: ID, edgeType: string);
+    private options?;
+    constructor(id1: ID, id2: ID, edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class AllowIfViewerInboundEdgeExistsRule implements PrivacyPolicyRule {
     private edgeType;
-    constructor(edgeType: string);
+    private options?;
+    constructor(edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class AllowIfViewerOutboundEdgeExistsRule implements PrivacyPolicyRule {
     private edgeType;
-    constructor(edgeType: string);
+    private options?;
+    constructor(edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class DenyIfEdgeExistsRule implements PrivacyPolicyRule {
     private id1;
     private id2;
     private edgeType;
-    constructor(id1: ID, id2: ID, edgeType: string);
+    private options?;
+    constructor(id1: ID, id2: ID, edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class DenyIfViewerInboundEdgeExistsRule implements PrivacyPolicyRule {
     private edgeType;
-    constructor(edgeType: string);
+    private options?;
+    constructor(edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class DenyIfViewerOutboundEdgeExistsRule implements PrivacyPolicyRule {
     private edgeType;
-    constructor(edgeType: string);
+    private options?;
+    constructor(edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class DenyIfEdgeDoesNotExistRule implements PrivacyPolicyRule {
     private id1;
     private id2;
     private edgeType;
-    constructor(id1: ID, id2: ID, edgeType: string);
+    private options?;
+    constructor(id1: ID, id2: ID, edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class DenyIfViewerInboundEdgeDoesNotExistRule implements PrivacyPolicyRule {
     private edgeType;
-    constructor(edgeType: string);
+    private options?;
+    constructor(edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class DenyIfViewerOutboundEdgeDoesNotExistRule implements PrivacyPolicyRule {
     private edgeType;
-    constructor(edgeType: string);
+    private options?;
+    constructor(edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class AllowIfConditionAppliesRule implements PrivacyPolicyRule {

package/core/privacy.js

@@ -255,7 +255,7 @@ class DenyIfEntIsNotVisibleRule {
     }
 }
 exports.DenyIfEntIsNotVisibleRule = DenyIfEntIsNotVisibleRule;
-async function allowIfEdgeExistsRule(id1, id2, edgeType, context) {
+async function allowIfEdgeExistsRule(id1, id2, edgeType, context, options) {
     if (id1 && id2) {
         const edge = await (0, ent_1.loadEdgeForID2)({
             id1,
@@ -263,6 +263,7 @@ async function allowIfEdgeExistsRule(id1, id2, edgeType, context) {
             id2,
             context,
             ctr: ent_1.AssocEdge,
+            queryOptions: options,
         });
         if (edge) {
             return (0, base_1.Allow)();
@@ -271,35 +272,38 @@ async function allowIfEdgeExistsRule(id1, id2, edgeType, context) {
     return (0, base_1.Skip)();
 }
 class AllowIfEdgeExistsRule {
-    constructor(id1, id2, edgeType) {
+    constructor(id1, id2, edgeType, options) {
         this.id1 = id1;
         this.id2 = id2;
         this.edgeType = edgeType;
+        this.options = options;
     }
     async apply(v, _ent) {
-        return allowIfEdgeExistsRule(this.id1, this.id2, this.edgeType, v.context);
+        return allowIfEdgeExistsRule(this.id1, this.id2, this.edgeType, v.context, this.options);
     }
 }
 exports.AllowIfEdgeExistsRule = AllowIfEdgeExistsRule;
 class AllowIfViewerInboundEdgeExistsRule {
-    constructor(edgeType) {
+    constructor(edgeType, options) {
         this.edgeType = edgeType;
+        this.options = options;
     }
     async apply(v, ent) {
-        return allowIfEdgeExistsRule(v.viewerID, ent?.id, this.edgeType, v.context);
+        return allowIfEdgeExistsRule(v.viewerID, ent?.id, this.edgeType, v.context, this.options);
     }
 }
 exports.AllowIfViewerInboundEdgeExistsRule = AllowIfViewerInboundEdgeExistsRule;
 class AllowIfViewerOutboundEdgeExistsRule {
-    constructor(edgeType) {
+    constructor(edgeType, options) {
         this.edgeType = edgeType;
+        this.options = options;
     }
     async apply(v, ent) {
-        return allowIfEdgeExistsRule(ent?.id, v.viewerID, this.edgeType, v.context);
+        return allowIfEdgeExistsRule(ent?.id, v.viewerID, this.edgeType, v.context, this.options);
     }
 }
 exports.AllowIfViewerOutboundEdgeExistsRule = AllowIfViewerOutboundEdgeExistsRule;
-async function denyIfEdgeExistsRule(id1, id2, edgeType, context) {
+async function denyIfEdgeExistsRule(id1, id2, edgeType, context, options) {
     // edge doesn't exist if no viewer
     if (id1 && id2) {
         const edge = await (0, ent_1.loadEdgeForID2)({
@@ -308,6 +312,7 @@ async function denyIfEdgeExistsRule(id1, id2, edgeType, context) {
             id2,
             context,
             ctr: ent_1.AssocEdge,
+            queryOptions: options,
         });
         if (edge) {
             return (0, base_1.Deny)();
@@ -315,7 +320,7 @@ async function denyIfEdgeExistsRule(id1, id2, edgeType, context) {
     }
     return (0, base_1.Skip)();
 }
-async function denyIfEdgeDoesNotExistRule(id1, id2, edgeType, context) {
+async function denyIfEdgeDoesNotExistRule(id1, id2, edgeType, context, options) {
     // edge doesn't exist if no viewer
     if (!id1 || !id2) {
         return (0, base_1.Deny)();
@@ -326,6 +331,7 @@ async function denyIfEdgeDoesNotExistRule(id1, id2, edgeType, context) {
         id2,
         context,
         ctr: ent_1.AssocEdge,
+        queryOptions: options,
     });
     if (!edge) {
         return (0, base_1.Deny)();
@@ -333,60 +339,66 @@ async function denyIfEdgeDoesNotExistRule(id1, id2, edgeType, context) {
     return (0, base_1.Skip)();
 }
 class DenyIfEdgeExistsRule {
-    constructor(id1, id2, edgeType) {
+    constructor(id1, id2, edgeType, options) {
         this.id1 = id1;
         this.id2 = id2;
         this.edgeType = edgeType;
+        this.options = options;
     }
     async apply(v, _ent) {
-        return denyIfEdgeExistsRule(this.id1, this.id2, this.edgeType, v.context);
+        return denyIfEdgeExistsRule(this.id1, this.id2, this.edgeType, v.context, this.options);
     }
 }
 exports.DenyIfEdgeExistsRule = DenyIfEdgeExistsRule;
 class DenyIfViewerInboundEdgeExistsRule {
-    constructor(edgeType) {
+    constructor(edgeType, options) {
         this.edgeType = edgeType;
+        this.options = options;
     }
     async apply(v, ent) {
-        return denyIfEdgeExistsRule(v.viewerID, ent?.id, this.edgeType, v.context);
+        return denyIfEdgeExistsRule(v.viewerID, ent?.id, this.edgeType, v.context, this.options);
     }
 }
 exports.DenyIfViewerInboundEdgeExistsRule = DenyIfViewerInboundEdgeExistsRule;
 class DenyIfViewerOutboundEdgeExistsRule {
-    constructor(edgeType) {
+    constructor(edgeType, options) {
         this.edgeType = edgeType;
+        this.options = options;
     }
     async apply(v, ent) {
-        return denyIfEdgeExistsRule(ent?.id, v.viewerID, this.edgeType, v.context);
+        return denyIfEdgeExistsRule(ent?.id, v.viewerID, this.edgeType, v.context, this.options);
     }
 }
 exports.DenyIfViewerOutboundEdgeExistsRule = DenyIfViewerOutboundEdgeExistsRule;
 class DenyIfEdgeDoesNotExistRule {
-    constructor(id1, id2, edgeType) {
+    constructor(id1, id2, edgeType, options) {
         this.id1 = id1;
         this.id2 = id2;
         this.edgeType = edgeType;
+        this.options = options;
     }
     async apply(v, _ent) {
-        return denyIfEdgeDoesNotExistRule(this.id1, this.id2, this.edgeType, v.context);
+        return denyIfEdgeDoesNotExistRule(this.id1, this.id2, this.edgeType, v.context, this.options);
     }
 }
 exports.DenyIfEdgeDoesNotExistRule = DenyIfEdgeDoesNotExistRule;
 class DenyIfViewerInboundEdgeDoesNotExistRule {
-    constructor(edgeType) {
+    constructor(edgeType, options) {
         this.edgeType = edgeType;
+        this.options = options;
     }
     async apply(v, ent) {
-        return denyIfEdgeDoesNotExistRule(v.viewerID, ent?.id, this.edgeType, v.context);
+        return denyIfEdgeDoesNotExistRule(v.viewerID, ent?.id, this.edgeType, v.context, this.options);
     }
 }
 exports.DenyIfViewerInboundEdgeDoesNotExistRule = DenyIfViewerInboundEdgeDoesNotExistRule;
 class DenyIfViewerOutboundEdgeDoesNotExistRule {
-    constructor(edgeType) {
+    constructor(edgeType, options) {
         this.edgeType = edgeType;
+        this.options = options;
     }
     async apply(v, ent) {
-        return denyIfEdgeDoesNotExistRule(ent?.id, v.viewerID, this.edgeType, v.context);
+        return denyIfEdgeDoesNotExistRule(ent?.id, v.viewerID, this.edgeType, v.context, this.options);
     }
 }
 exports.DenyIfViewerOutboundEdgeDoesNotExistRule = DenyIfViewerOutboundEdgeDoesNotExistRule;

package/core/query/assoc_query.js

@@ -43,7 +43,7 @@ class AssocEdgeQueryBase extends query_1.BaseEdgeQuery {
             return 0;
         }
         return this.countLoaderFactory
-            .createLoader(this.viewer.context)
+            .createConfigurableLoader(this.getDefaultEdgeQueryOptions() ?? {}, this.viewer.context)
             .load(info.id);
     }
     async queryAllRawCount() {

package/core/query/custom_clause_query.d.ts

@@ -1,13 +1,15 @@
 import { Data, EdgeQueryableDataOptions, Ent, ID, LoadEntOptions, Viewer } from "../base";
 import { Clause } from "../clause";
+import { OrderBy } from "../query_impl";
 import { BaseEdgeQuery, IDInfo } from "./query";
 export interface CustomClauseQueryOptions<TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
     loadEntOptions: LoadEntOptions<TDest, TViewer>;
     clause: Clause;
     name: string;
+    primarySortColIsUnique?: boolean;
+    orderby?: OrderBy;
     sortColumn?: string;
-    sortColumnUnique?: boolean;
-    orderByDirection?: "asc" | "desc";
+    orderByDirection?: "ASC" | "DESC";
     nullsPlacement?: "first" | "last";
     disableTransformations?: boolean;
 }

package/core/query/custom_clause_query.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CustomClauseQuery = void 0;
 const clause_1 = require("../clause");
 const ent_1 = require("../ent");
-const query_loader_1 = require("../loaders/query_loader");
 const query_1 = require("./query");
 function getClause(opts) {
     let cls = opts.clause;
@@ -21,19 +20,32 @@ function getClause(opts) {
 }
 class CustomClauseQuery extends query_1.BaseEdgeQuery {
     constructor(viewer, options) {
-        let sortCol = options.sortColumn || "id";
-        let unique = options.sortColumnUnique
-            ? sortCol
-            : options.loadEntOptions.loaderFactory.options?.key || "id";
-        // pass direction to base class since it uses it
-        // this API needs to be cleaned up...
-        if (options.orderByDirection) {
-            sortCol = `${sortCol} ${options.orderByDirection}`;
+        let orderby;
+        let primarySortCol;
+        if (options.orderby &&
+            (options.sortColumn || options.orderByDirection || options.nullsPlacement)) {
+            throw new Error(`cannot pass orderby and sortColumn|orderByDirection|nullsPlacement`);
+        }
+        if (options.orderby) {
+            primarySortCol = options.orderby[0].column;
+            orderby = options.orderby;
         }
+        else {
+            primarySortCol = options.sortColumn || "id";
+            orderby = [
+                {
+                    column: primarySortCol,
+                    direction: options.orderByDirection ?? "DESC",
+                    nullsPlacement: options.nullsPlacement,
+                },
+            ];
+        }
+        let cursorCol = options.primarySortColIsUnique
+            ? primarySortCol
+            : options.loadEntOptions.loaderFactory.options?.key || "id";
         super(viewer, {
-            sortCol,
-            cursorCol: unique,
-            nullsPlacement: options.nullsPlacement,
+            orderby,
+            cursorCol,
         });
         this.viewer = viewer;
         this.options = options;
@@ -62,8 +74,13 @@ class CustomClauseQuery extends query_1.BaseEdgeQuery {
     async loadRawIDs(_addID) { }
     async loadRawData(_infos, options) {
         if (!options.orderby) {
-            const direction = this.options.orderByDirection ?? "desc";
-            options.orderby = `${this.options.sortColumn} ${direction}`;
+            options.orderby = [
+                {
+                    column: this.getSortCol(),
+                    direction: this.options.orderByDirection ?? "DESC",
+                    nullsPlacement: this.options.nullsPlacement,
+                },
+            ];
         }
         if (!options.limit) {
             options.limit = (0, ent_1.getDefaultLimit)();
@@ -72,7 +89,7 @@ class CustomClauseQuery extends query_1.BaseEdgeQuery {
             tableName: this.options.loadEntOptions.tableName,
             fields: this.options.loadEntOptions.fields,
             clause: (0, clause_1.AndOptional)(this.clause, options.clause),
-            orderby: (0, query_loader_1.getOrderBy)(this.getSortCol(), options?.orderby),
+            orderby: options.orderby,
             limit: options?.limit || (0, ent_1.getDefaultLimit)(),
             context: this.viewer.context,
         });

package/core/query/custom_query.d.ts

@@ -1,5 +1,6 @@
 import { Data, Ent, ID, EdgeQueryableDataOptions, LoadEntOptions, Viewer, LoaderFactory, ConfigurableLoaderFactory } from "../base";
 import { Clause } from "../clause";
+import { OrderBy } from "../query_impl";
 import { BaseEdgeQuery, IDInfo, EdgeQuery } from "./query";
 export interface CustomEdgeQueryOptionsDeprecated<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
     src: TSource | ID;
@@ -15,7 +16,8 @@ export interface CustomEdgeQueryOptions<TSource extends Ent<TViewer>, TDest exte
     clause?: Clause;
     name: string;
     sortColumn?: string;
-    sortColumnUnique?: boolean;
+    orderby?: OrderBy;
+    primarySortColIsUnique?: boolean;
     disableTransformations?: boolean;
 }
 export declare abstract class CustomEdgeQueryBase<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> extends BaseEdgeQuery<TSource, TDest, Data> implements EdgeQuery<TSource, TDest, Data> {

package/core/query/custom_query.js

@@ -54,21 +54,39 @@ class CustomEdgeQueryBase extends query_1.BaseEdgeQuery {
         let opts;
         let defaultSort = "id";
         let uniqueColIsSort = false;
+        let orderby;
+        let sortCol;
         if (isDeprecatedOptions(options)) {
             opts = options.options;
         }
         else {
             opts = options.loadEntOptions;
-            if (options.sortColumnUnique) {
+            if (options.primarySortColIsUnique) {
                 uniqueColIsSort = true;
             }
+            if (options.orderby) {
+                orderby = options.orderby;
+                sortCol = options.orderby[0].column;
+            }
         }
         let uniqueCol = opts.loaderFactory.options?.key || "id";
+        if (!orderby) {
+            options.sortColumn = options.sortColumn || defaultSort;
+            sortCol = options.sortColumn;
+            orderby = [
+                {
+                    column: options.sortColumn,
+                    direction: "DESC",
+                },
+            ];
+        }
         if (uniqueColIsSort) {
-            uniqueCol = options.sortColumn || defaultSort;
+            uniqueCol = sortCol || defaultSort;
         }
-        options.sortColumn = options.sortColumn || defaultSort;
-        super(viewer, options.sortColumn, uniqueCol);
+        super(viewer, {
+            cursorCol: uniqueCol,
+            orderby,
+        });
         this.viewer = viewer;
         this.options = options;
         if (typeof options.src === "object") {
@@ -124,7 +142,12 @@ class CustomEdgeQueryBase extends query_1.BaseEdgeQuery {
             throw new Error(`expected 1 info passed to loadRawData. ${infos.length} passed`);
         }
         if (!options.orderby) {
-            options.orderby = `${this.getSortCol()} DESC`;
+            options.orderby = [
+                {
+                    column: this.getSortCol(),
+                    direction: "DESC",
+                },
+            ];
         }
         if (!options.limit) {
             options.limit = (0, ent_1.getDefaultLimit)();

package/core/query/query.d.ts

@@ -1,4 +1,5 @@
-import { ID, Ent, Viewer, EdgeQueryableDataOptions, Data, PrivacyPolicy } from "../base";
+import { ID, Ent, Viewer, EdgeQueryableDataOptions, Data, PrivacyPolicy, EdgeQueryableDataOptionsConfigureLoader } from "../base";
+import { OrderBy } from "../query_impl";
 export interface EdgeQuery<TSource extends Ent, TDest extends Ent, TEdge extends Data> {
     queryEdges(): Promise<TEdge[]>;
     queryAllEdges(): Promise<Map<ID, TEdge[]>>;
@@ -31,8 +32,7 @@ export interface PaginationInfo {
 }
 interface EdgeQueryOptions {
     cursorCol: string;
-    sortCol: string;
-    nullsPlacement?: "first" | "last";
+    orderby: OrderBy;
 }
 export declare abstract class BaseEdgeQuery<TSource extends Ent, TDest extends Ent, TEdge extends Data> implements EdgeQuery<TSource, TDest, TEdge> {
     viewer: Viewer;
@@ -46,7 +46,6 @@ export declare abstract class BaseEdgeQuery<TSource extends Ent, TDest extends E
     private idsToFetch;
     private sortCol;
     private cursorCol;
-    private defaultDirection?;
     private edgeQueryOptions;
     constructor(viewer: Viewer, sortCol: string, cursorCol: string);
     constructor(viewer: Viewer, options: EdgeQueryOptions);
@@ -76,6 +75,9 @@ export declare abstract class BaseEdgeQuery<TSource extends Ent, TDest extends E
     private addID;
     abstract getTableName(): string | Promise<string>;
     protected genIDInfosToFetchImpl(): Promise<IDInfo[]>;
+    private _defaultEdgeQueryableOptions;
+    protected configureEdgeQueryableDataOptions(opts: EdgeQueryableDataOptionsConfigureLoader): void;
+    protected getDefaultEdgeQueryOptions(): Partial<Pick<import("../base").QueryableDataOptions, "clause" | "limit" | "orderby" | "disableTransformations">> | undefined;
     private loadEdges;
     getCursor(row: TEdge): string;
 }

package/core/query/query.js

@@ -33,6 +33,7 @@ const memoizee_1 = __importDefault(require("memoizee"));
 const privacy_1 = require("../privacy");
 const uuid_1 = require("uuid");
 const util_1 = require("util");
+const query_impl_1 = require("../query_impl");
 // TODO can we generalize EdgeQuery to support any clause
 function assertPositive(n) {
     if (n < 0) {
@@ -95,23 +96,16 @@ class FirstFilter {
         // we fetch an extra one to see if we're at the end
         const limit = this.options.limit + 1;
         options.limit = limit;
-        let orderby = this.options.defaultDirection || "DESC";
         // we sort by most recent first
         // so when paging, we fetch afterCursor X
-        const less = orderby === "DESC";
-        let nullsPlacement = "";
-        if (this.options.nullsPlacement) {
-            if (this.options.nullsPlacement === "first") {
-                nullsPlacement = " NULLS FIRST";
-            }
-            else {
-                nullsPlacement = " NULLS LAST";
-            }
-        }
+        const less = this.options.orderby[0].direction === "DESC";
+        const orderby = this.options.orderby;
         if (this.options.cursorCol !== this.sortCol) {
-            // we also sort unique col in same direction since it doesn't matter...
-            // nulls placement only affects sortCol. assumption is cursorCol will not be null and no need for that
-            options.orderby = `${this.sortCol} ${orderby}${nullsPlacement}, ${this.options.cursorCol} ${orderby}`;
+            // we also sort cursor col in same direction. (direction doesn't matter)
+            orderby.push({
+                column: this.options.cursorCol,
+                direction: orderby[0].direction,
+            });
             if (this.offset) {
                 const res = this.edgeQuery.getTableName();
                 const tableName = util_1.types.isPromise(res) ? await res : res;
@@ -120,7 +114,6 @@ class FirstFilter {
             }
         }
         else {
-            options.orderby = `${this.sortCol} ${orderby}${nullsPlacement}`;
             if (this.offset) {
                 let clauseFn = less ? clause.Less : clause.Greater;
                 let val = this.options.sortColTime
@@ -129,6 +122,7 @@ class FirstFilter {
                 options.clause = clauseFn(this.sortCol, val);
             }
         }
+        options.orderby = orderby;
         return options;
     }
     // TODO?
@@ -136,6 +130,7 @@ class FirstFilter {
         return this.pageMap.get(id);
     }
 }
+// TODO need some last tests to test all these cases. clearly don't have the tests
 class LastFilter {
     constructor(options) {
         this.options = options;
@@ -175,19 +170,10 @@ class LastFilter {
         return ret;
     }
     async query(options) {
-        // assume desc by default
-        // so last is reverse
-        let orderby = "ASC";
-        if (this.options.defaultDirection) {
-            // reverse sort col shown...
-            if (this.options.defaultDirection === "DESC") {
-                orderby = "ASC";
-            }
-            else {
-                orderby = "DESC";
-            }
-        }
-        const greater = orderby === "ASC";
+        const orderby = (0, query_impl_1.reverseOrderBy)(this.options.orderby);
+        const greater = orderby[0].direction === "ASC";
+        // TODO verify that this greater still makes sense. tests pass
+        // but wanna confirm
         options.limit = this.options.limit + 1; // fetch an extra so we know if previous pag
         if (this.options.cursorCol !== this.sortCol) {
             const res = this.edgeQuery.getTableName();
@@ -196,10 +182,13 @@ class LastFilter {
                 // inner col time
                 options.clause = clause.PaginationMultipleColsSubQuery(this.sortCol, greater ? ">" : "<", tableName, this.options.cursorCol, this.offset);
             }
-            options.orderby = `${this.sortCol} ${orderby}, ${this.options.cursorCol} ${orderby}`;
+            // we also sort cursor col in same direction. (direction doesn't matter)
+            orderby.push({
+                column: this.options.cursorCol,
+                direction: orderby[0].direction,
+            });
         }
         else {
-            options.orderby = `${this.sortCol} ${orderby}`;
             if (this.offset) {
                 let clauseFn = greater ? clause.Greater : clause.Less;
                 let val = this.options.sortColTime
@@ -208,6 +197,7 @@ class LastFilter {
                 options.clause = clauseFn(this.sortCol, val);
             }
         }
+        options.orderby = orderby;
         return options;
     }
     paginationInfo(id) {
@@ -227,7 +217,7 @@ class BaseEdgeQuery {
             return await this.querySingleEdge("queryEdges");
         };
         this.queryAllEdges = async () => {
-            return await this.memoizedloadEdges();
+            return this.memoizedloadEdges();
         };
         this.queryIDs = async () => {
             const edges = await this.querySingleEdge("queryIDs");
@@ -255,7 +245,7 @@ class BaseEdgeQuery {
         };
         this.queryEnts = async () => {
             const edges = await this.querySingleEdge("queryEnts");
-            return await this.loadEntsFromEdges("id", edges);
+            return this.loadEntsFromEdges("id", edges);
         };
         this.queryAllEnts = async () => {
             // applies filters and then gets things after
@@ -279,28 +269,35 @@ class BaseEdgeQuery {
             cursorCol = cursorColMaybe;
             this.edgeQueryOptions = {
                 cursorCol,
-                sortCol,
+                orderby: [
+                    {
+                        column: sortCol,
+                        direction: "DESC",
+                    },
+                ],
             };
         }
         else {
-            sortCol = sortColOrOptions.sortCol;
+            if (typeof sortColOrOptions.orderby === "string") {
+                sortCol = sortColOrOptions.orderby;
+            }
+            else {
+                // TODO this orderby isn't consistent and this logic needs to be changed anywhere that's using this and this.getSortCol()
+                sortCol = sortColOrOptions.orderby[0].column;
+            }
             cursorCol = sortColOrOptions.cursorCol;
             this.edgeQueryOptions = sortColOrOptions;
         }
+        this.sortCol = sortCol;
         let m = orderbyRegex.exec(sortCol);
         if (!m) {
             throw new Error(`invalid sort column ${sortCol}`);
         }
         this.sortCol = m[1];
         if (m[2]) {
-            // @ts-ignore
-            this.defaultDirection = m[2].toUpperCase();
-        }
-        let m2 = orderbyRegex.exec(cursorCol);
-        if (!m2) {
-            throw new Error(`invalid sort column ${cursorCol}`);
+            throw new Error(`passing direction in sort column is not supproted. use orderby`);
         }
-        this.cursorCol = m2[1];
+        this.cursorCol = cursorCol;
         this.memoizedloadEdges = (0, memoizee_1.default)(this.loadEdges.bind(this));
         this.genIDInfosToFetch = (0, memoizee_1.default)(this.genIDInfosToFetchImpl.bind(this));
     }
@@ -318,8 +315,7 @@ class BaseEdgeQuery {
             after,
             sortCol: this.sortCol,
             cursorCol: this.cursorCol,
-            defaultDirection: this.defaultDirection,
-            nullsPlacement: this.edgeQueryOptions.nullsPlacement,
+            orderby: this.edgeQueryOptions.orderby,
             query: this,
         }));
         return this;
@@ -331,8 +327,7 @@ class BaseEdgeQuery {
             before,
             sortCol: this.sortCol,
             cursorCol: this.cursorCol,
-            defaultDirection: this.defaultDirection,
-            nullsPlacement: this.edgeQueryOptions.nullsPlacement,
+            orderby: this.edgeQueryOptions.orderby,
             query: this,
         }));
         return this;
@@ -374,13 +369,23 @@ class BaseEdgeQuery {
         await this.loadRawIDs(this.addID.bind(this));
         return applyPrivacyPolicyForEdgeQ(this.viewer, this, this.idsToFetch, this.idMap);
     }
+    // FYI: this should be used sparingly.
+    // currently only exists so that disableTransformations can be configured by the developer
+    // so we're only exposing a partial API for now but maybe in the future we can expose
+    // the full API if there's a reason to use this that's not via filters
+    configureEdgeQueryableDataOptions(opts) {
+        this._defaultEdgeQueryableOptions = opts;
+    }
+    getDefaultEdgeQueryOptions() {
+        return this._defaultEdgeQueryableOptions;
+    }
     async loadEdges() {
         const idsInfo = await this.genIDInfosToFetch();
         if (!this.filters.length) {
             // if no filter, we add the firstN filter to ensure we get pagination info
             this.first((0, ent_1.getDefaultLimit)());
         }
-        let options = {};
+        let options = this._defaultEdgeQueryableOptions ?? {};
         // TODO once we add a lot of complex filters, this needs to be more complicated
         // e.g. commutative filters. what can be done in sql or combined together etc
         // may need to bring sql mode or something back