@snowtop/ent 0.1.0-alpha99 → 0.1.0

package/core/privacy.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AllowIfViewerHasIdentityPrivacyPolicy = exports.AllowIfViewerPrivacyPolicy = exports.AlwaysDenyPrivacyPolicy = exports.AlwaysAllowPrivacyPolicy = exports.applyPrivacyPolicyImpl = exports.applyPrivacyPolicyX = exports.applyPrivacyPolicy = exports.AllowIfSubPolicyAllowsRule = exports.DelayedResultRule = exports.AllowIfConditionAppliesRule = exports.DenyIfViewerOutboundEdgeDoesNotExistRule = exports.DenyIfViewerInboundEdgeDoesNotExistRule = exports.DenyIfEdgeDoesNotExistRule = exports.DenyIfViewerOutboundEdgeExistsRule = exports.DenyIfViewerInboundEdgeExistsRule = exports.DenyIfEdgeExistsRule = exports.AllowIfViewerOutboundEdgeExistsRule = exports.AllowIfViewerInboundEdgeExistsRule = exports.AllowIfEdgeExistsRule = exports.DenyIfEntIsNotVisibleRule = exports.DenyIfEntIsVisibleRule = exports.DenyIfEntIsVisiblePolicy = exports.AllowIfEntIsVisiblePolicy = exports.AllowIfEntIsNotVisibleRule = exports.AllowIfEntIsVisibleRule = exports.DenyIfEntPropertyIsRule = exports.AllowIfEntPropertyIsRule = exports.AllowIfViewerIsEntPropertyRule = exports.AllowIfViewerIsRule = exports.DenyIfFuncRule = exports.AllowIfFuncRule = exports.DenyIfViewerEqualsRule = exports.AllowIfViewerEqualsRule = exports.AllowIfViewerRule = exports.AllowIfHasIdentity = exports.DenyIfLoggedInRule = exports.DenyIfLoggedOutRule = exports.AlwaysDenyRule = exports.AlwaysAllowRule = exports.EntPrivacyError = void 0;
+const types_1 = require("util/types");
 const base_1 = require("./base");
 const ent_1 = require("./ent");
 // copied from ./base
@@ -102,7 +103,10 @@ class AllowIfFuncRule {
         this.fn = fn;
     }
     async apply(v, ent) {
-        const result = await this.fn(v, ent);
+        let result = this.fn(v, ent);
+        if ((0, types_1.isPromise)(result)) {
+            result = await result;
+        }
         if (result) {
             return (0, base_1.Allow)();
         }
@@ -115,7 +119,10 @@ class DenyIfFuncRule {
         this.fn = fn;
     }
     async apply(v, ent) {
-        const result = await this.fn(v, ent);
+        let result = this.fn(v, ent);
+        if ((0, types_1.isPromise)(result)) {
+            result = await result;
+        }
         if (result) {
             return (0, base_1.Deny)();
         }
@@ -255,7 +262,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 +270,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 +279,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 +319,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 +327,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 +338,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 +346,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;
@@ -412,12 +431,14 @@ class DelayedResultRule {
         this.fn = fn;
     }
     async apply(v, ent) {
-        const rule = await this.fn(v, ent);
+        let rule = this.fn(v, ent);
+        if ((0, types_1.isPromise)(rule)) {
+            rule = await rule;
+        }
         if (!rule) {
             return (0, base_1.Skip)();
         }
-        const res = await rule.apply(v, ent);
-        return res;
+        return rule.apply(v, ent);
     }
 }
 exports.DelayedResultRule = DelayedResultRule;

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,12 +1,16 @@
 import { Data, EdgeQueryableDataOptions, Ent, ID, LoadEntOptions, Viewer } from "../base";
 import { Clause } from "../clause";
+import { OrderBy } from "../query_impl";
 import { BaseEdgeQuery, IDInfo } from "./query";
-interface CustomClauseQueryOptions<TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
+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";
+    nullsPlacement?: "first" | "last";
     disableTransformations?: boolean;
 }
 export declare class CustomClauseQuery<TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> extends BaseEdgeQuery<any, TDest, Data> {
@@ -23,4 +27,3 @@ export declare class CustomClauseQuery<TDest extends Ent<TViewer>, TViewer exten
     dataToID(edge: Data): ID;
     protected loadEntsFromEdges(id: ID, rows: Data[]): Promise<TDest[]>;
 }
-export {};

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,11 +20,33 @@ function getClause(opts) {
 }
 class CustomClauseQuery extends query_1.BaseEdgeQuery {
     constructor(viewer, options) {
-        const sortCol = options.sortColumn || "id";
-        let unique = options.sortColumnUnique
-            ? sortCol
+        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, options.sortColumn || sortCol, unique);
+        super(viewer, {
+            orderby,
+            cursorCol,
+        });
         this.viewer = viewer;
         this.options = options;
         this.clause = getClause(options);
@@ -53,17 +74,23 @@ class CustomClauseQuery extends query_1.BaseEdgeQuery {
     async loadRawIDs(_addID) { }
     async loadRawData(_infos, options) {
         if (!options.orderby) {
-            options.orderby = `${this.options.sortColumn} DESC`;
+            options.orderby = [
+                {
+                    column: this.getSortCol(),
+                    direction: this.options.orderByDirection ?? "DESC",
+                    nullsPlacement: this.options.nullsPlacement,
+                },
+            ];
         }
         if (!options.limit) {
-            options.limit = ent_1.DefaultLimit;
+            options.limit = (0, ent_1.getDefaultLimit)();
         }
         const rows = await (0, ent_1.loadRows)({
             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),
-            limit: options?.limit || ent_1.DefaultLimit,
+            orderby: options.orderby,
+            limit: options?.limit || (0, ent_1.getDefaultLimit)(),
             context: this.viewer.context,
         });
         this.edges.set(1, rows);

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,10 +142,15 @@ 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 = ent_1.DefaultLimit;
+            options.limit = (0, ent_1.getDefaultLimit)();
         }
         const loader = this.getQueryLoader(options);
         const info = infos[0];

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[]>>;
@@ -29,6 +30,10 @@ export interface PaginationInfo {
     startCursor: string;
     endCursor: string;
 }
+interface EdgeQueryOptions {
+    cursorCol: string;
+    orderby: OrderBy;
+}
 export declare abstract class BaseEdgeQuery<TSource extends Ent, TDest extends Ent, TEdge extends Data> implements EdgeQuery<TSource, TDest, TEdge> {
     viewer: Viewer;
     private filters;
@@ -41,8 +46,9 @@ 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);
     protected getSortCol(): string;
     getPrivacyPolicy(): PrivacyPolicy<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>>;
     abstract sourceEnt(id: ID): Promise<Ent | null>;
@@ -69,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;
 }
@@ -76,3 +85,4 @@ export interface IDInfo {
     id: ID;
     invalidated?: boolean;
 }
+export {};

package/core/query/query.js

@@ -32,7 +32,8 @@ const clause = __importStar(require("../clause"));
 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");
+const types_1 = require("util/types");
 // TODO can we generalize EdgeQuery to support any clause
 function assertPositive(n) {
     if (n < 0) {
@@ -95,22 +96,24 @@ 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";
+        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...
-            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,
+            });
             if (this.offset) {
                 const res = this.edgeQuery.getTableName();
-                const tableName = util_1.types.isPromise(res) ? await res : res;
+                const tableName = (0, types_1.isPromise)(res) ? await res : res;
                 // inner col time
                 options.clause = clause.PaginationMultipleColsSubQuery(this.sortCol, less ? "<" : ">", tableName, this.options.cursorCol, this.offset);
             }
         }
         else {
-            options.orderby = `${this.sortCol} ${orderby}`;
             if (this.offset) {
                 let clauseFn = less ? clause.Less : clause.Greater;
                 let val = this.options.sortColTime
@@ -119,6 +122,7 @@ class FirstFilter {
                 options.clause = clauseFn(this.sortCol, val);
             }
         }
+        options.orderby = orderby;
         return options;
     }
     // TODO?
@@ -165,31 +169,23 @@ 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";
         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();
-            const tableName = util_1.types.isPromise(res) ? await res : res;
+            const tableName = (0, types_1.isPromise)(res) ? await res : res;
             if (this.offset) {
                 // 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
@@ -198,6 +194,7 @@ class LastFilter {
                 options.clause = clauseFn(this.sortCol, val);
             }
         }
+        options.orderby = orderby;
         return options;
     }
     paginationInfo(id) {
@@ -205,7 +202,7 @@ class LastFilter {
     }
 }
 class BaseEdgeQuery {
-    constructor(viewer, sortCol, cursorCol) {
+    constructor(viewer, sortColOrOptions, cursorColMaybe) {
         this.viewer = viewer;
         this.filters = [];
         this.edges = new Map();
@@ -217,7 +214,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");
@@ -245,7 +242,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
@@ -262,20 +259,42 @@ class BaseEdgeQuery {
             await Promise.all(promises);
             return results;
         };
+        let sortCol;
+        let cursorCol;
+        if (typeof sortColOrOptions === "string") {
+            sortCol = sortColOrOptions;
+            cursorCol = cursorColMaybe;
+            this.edgeQueryOptions = {
+                cursorCol,
+                orderby: [
+                    {
+                        column: sortCol,
+                        direction: "DESC",
+                    },
+                ],
+            };
+        }
+        else {
+            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));
     }
@@ -293,7 +312,7 @@ class BaseEdgeQuery {
             after,
             sortCol: this.sortCol,
             cursorCol: this.cursorCol,
-            defaultDirection: this.defaultDirection,
+            orderby: this.edgeQueryOptions.orderby,
             query: this,
         }));
         return this;
@@ -305,7 +324,7 @@ class BaseEdgeQuery {
             before,
             sortCol: this.sortCol,
             cursorCol: this.cursorCol,
-            defaultDirection: this.defaultDirection,
+            orderby: this.edgeQueryOptions.orderby,
             query: this,
         }));
         return this;
@@ -347,20 +366,30 @@ 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(ent_1.DefaultLimit);
+            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
         for (const filter of this.filters) {
             if (filter.query) {
                 let res = filter.query(options);
-                options = util_1.types.isPromise(res) ? await res : res;
+                options = (0, types_1.isPromise)(res) ? await res : res;
             }
         }
         await this.loadRawData(idsInfo, options);