@snowtop/ent 0.2.0-alpha.1 → 0.2.0-alpha.10-test1

package/action/orchestrator.js

@@ -621,17 +621,23 @@ class Orchestrator {
             }
             if (transformed.data) {
                 updateInput = true;
-                for (const k in transformed.data) {
-                    let field = schemaFields.get(k);
-                    if (!field) {
-                        throw new Error(`tried to transform field with unknown field ${k}`);
+                for (const [k, field] of schemaFields) {
+                    const inputKey = this.getInputKey(k);
+                    const storageKey = this.getStorageKey(k);
+                    let val = transformed.data[inputKey];
+                    if (val === undefined) {
+                        val = transformed.data[storageKey];
+                    }
+                    if (val === undefined) {
+                        continue;
                     }
-                    let val = transformed.data[k];
                     if (field.format) {
-                        val = field.format(transformed.data[k]);
+                        val = field.format(transformed.data[k], true);
                     }
                     data[this.getStorageKey(k)] = val;
-                    this.defaultFieldsByTSName[this.getInputKey(k)] = val;
+                    if (!field.immutable) {
+                        this.defaultFieldsByTSName[this.getInputKey(k)] = val;
+                    }
                     // hmm do we need this?
                     // TODO how to do this for local tests?
                     // this.defaultFieldsByFieldName[k] = val;

package/core/base.d.ts

@@ -86,6 +86,7 @@ interface JoinOptions<T2 extends Data = Data, K2 = keyof T2> {
     tableName: string;
     alias?: string;
     clause: clause.Clause<T2, K2>;
+    type?: "inner" | "outer" | "left" | "right";
 }
 export interface QueryDataOptions<T extends Data = Data, K = keyof T> {
     distinct?: boolean;

package/core/clause.d.ts

@@ -126,6 +126,50 @@ export declare function JSONKeyExists<T extends Data, K = keyof T>(dbCol: K, val
 export declare function JSONBKeyInList<T extends Data, K = keyof T>(dbCol: K, jsonCol: string, val: any, overrideAlias?: string): Clause<T, K>;
 export declare function JSONKeyInList<T extends Data, K = keyof T>(dbCol: K, jsonCol: string, val: any, overrideAlias?: string): Clause<T, K>;
 export declare function PaginationMultipleColsSubQuery<T extends Data, K = keyof T>(col: K, op: string, tableName: string, uniqueCol: K, val: any, overrideAlias?: string): Clause<T, K>;
+export type PaginationUnboundColsQueryOrdering<T extends Data, K = keyof T> = {
+    sortCol: K;
+    direction: "ASC" | "DESC";
+    sortValue: string | number | null;
+    nullsPlacement?: "first" | "last";
+    overrideAlias?: string;
+};
+/**
+ * When paginating over multiple ordered columns, we need to construct a nested
+ * set of clauses to correctly filter. The resulting query will be structured as
+ * a group of nested ANDs and ORs.
+ *
+ * The four cases for each ordering entry are:
+ *
+ * 1) When sorting in ASC order with null placement LAST (e.g., [1,2,3,null,null])
+ *    a) If the sort value is not null, then it needs to check for values greater than the
+ *       sort value OR null values.
+ *    b) If the sort value is null, then it needs to check for null values only.
+ * 2) When sorting in ASC order with null placement FIRST (e.g., [null,null,1,2,3])
+ *    a) If the sort value is not null, then it needs to check for values greater than the
+ *       sort value.
+ *    b) If the sort value is null, then there will be no check for this value since all
+ *       possible values are greater than or equal to null.
+ * 3) When sorting in DESC order with null placement LAST (e.g., [1,2,3,null,null])
+ *    a) If the sort value is not null, then it needs to check for values less than the
+ *       sort value OR null values.
+ *    b) If the sort value is null, then it needs to check for null values only.
+ * 4) When sorting in DESC order with null placement FIRST (e.g., [null,null,1,2,3])
+ *    a) If the sort value is not null, then it needs to check for values less than the
+ *       sort value.
+ *    b) If the sort value is null, then there will be no check for this value since all
+ *       possible values are less than or equal to null.
+ *
+ * Each ordering entry will do the above check OR'ed with the following ordering entry and
+ * an equals check. For instance, given a set of ordering [{col1, less1}, {col2, greater2}],
+ * the function will construct a query that looks like:
+ *
+ * col1 < $1 OR (col1 = $1 AND col2 > $2)
+ *
+ * In english: each ordering entry will check for values lesser/greater than the supplied value,
+ * OR equal to the supplied value AND matching the next ordering entry. For the last ordering entry,
+ * it will not check for values equal to the supplied value.
+ */
+export declare function PaginationUnboundColsQuery<T extends Data, K = keyof T>(ordering: PaginationUnboundColsQueryOrdering<T, K>[]): Clause<T, K> | undefined;
 export declare function PaginationMultipleColsQuery<T extends Data, K = keyof T>(sortCol: K, cursorCol: K, less: boolean, // if true, <, if false, >
 sortValue: any, cursorValue: any, overrideAlias?: string): Clause<T, K>;
 export declare function Add<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string): Clause<T, K>;

package/core/clause.js

@@ -24,7 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 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.ContainsIgnoreCase = exports.EndsWithIgnoreCase = exports.StartsWithIgnoreCase = exports.Contains = exports.EndsWith = exports.StartsWith = 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.Expression = exports.getCombinedClause = exports.Modulo = exports.Divide = exports.Multiply = exports.Subtract = exports.Add = exports.PaginationMultipleColsQuery = exports.PaginationMultipleColsSubQuery = void 0;
+exports.Expression = exports.getCombinedClause = exports.Modulo = exports.Divide = exports.Multiply = exports.Subtract = exports.Add = exports.PaginationMultipleColsQuery = exports.PaginationUnboundColsQuery = exports.PaginationMultipleColsSubQuery = void 0;
 const db_1 = __importStar(require("./db"));
 const query_impl_1 = require("./query_impl");
 function isSensitive(val) {
@@ -632,7 +632,7 @@ function ContainsIgnoreCase(col, value, overrideAlias) {
 exports.ContainsIgnoreCase = ContainsIgnoreCase;
 function NotEq(col, value, overrideAlias) {
     return new simpleClause(col, value, "!=", {
-        handleNull: new isNotNullClause(col),
+        handleNull: new isNotNullClause(col, overrideAlias),
         overrideAlias,
     });
 }
@@ -943,6 +943,79 @@ function PaginationMultipleColsSubQuery(col, op, tableName, uniqueCol, val, over
     return new paginationMultipleColumnsSubQueryClause(col, op, tableName, uniqueCol, val, overrideAlias);
 }
 exports.PaginationMultipleColsSubQuery = PaginationMultipleColsSubQuery;
+/**
+ * When paginating over multiple ordered columns, we need to construct a nested
+ * set of clauses to correctly filter. The resulting query will be structured as
+ * a group of nested ANDs and ORs.
+ *
+ * The four cases for each ordering entry are:
+ *
+ * 1) When sorting in ASC order with null placement LAST (e.g., [1,2,3,null,null])
+ *    a) If the sort value is not null, then it needs to check for values greater than the
+ *       sort value OR null values.
+ *    b) If the sort value is null, then it needs to check for null values only.
+ * 2) When sorting in ASC order with null placement FIRST (e.g., [null,null,1,2,3])
+ *    a) If the sort value is not null, then it needs to check for values greater than the
+ *       sort value.
+ *    b) If the sort value is null, then there will be no check for this value since all
+ *       possible values are greater than or equal to null.
+ * 3) When sorting in DESC order with null placement LAST (e.g., [1,2,3,null,null])
+ *    a) If the sort value is not null, then it needs to check for values less than the
+ *       sort value OR null values.
+ *    b) If the sort value is null, then it needs to check for null values only.
+ * 4) When sorting in DESC order with null placement FIRST (e.g., [null,null,1,2,3])
+ *    a) If the sort value is not null, then it needs to check for values less than the
+ *       sort value.
+ *    b) If the sort value is null, then there will be no check for this value since all
+ *       possible values are less than or equal to null.
+ *
+ * Each ordering entry will do the above check OR'ed with the following ordering entry and
+ * an equals check. For instance, given a set of ordering [{col1, less1}, {col2, greater2}],
+ * the function will construct a query that looks like:
+ *
+ * col1 < $1 OR (col1 = $1 AND col2 > $2)
+ *
+ * In english: each ordering entry will check for values lesser/greater than the supplied value,
+ * OR equal to the supplied value AND matching the next ordering entry. For the last ordering entry,
+ * it will not check for values equal to the supplied value.
+ */
+function PaginationUnboundColsQuery(ordering) {
+    if (ordering.length === 0) {
+        throw new Error("Must provide at least one ordering.");
+    }
+    let nesting;
+    // We reverse the order of the ordering array so that we can build the query from the inner-most
+    // clause and work our way outwards
+    ordering
+        .reverse()
+        .forEach(({ sortCol, direction, sortValue, nullsPlacement, overrideAlias }) => {
+        const nullsOrder = nullsPlacement ?? (direction === "DESC" ? "first" : "last");
+        const clauseFn = direction === "DESC" ? Less : Greater;
+        const baseClause = clauseFn(sortCol, sortValue, overrideAlias);
+        const compoundClause = sortValue !== null
+            ? nullsOrder === "last" // There is a non-null value to compare against
+                ? Or(baseClause, Eq(sortCol, null, overrideAlias)) // If nulls are last, then we need to compare the value and accept nulls
+                : And(baseClause, NotEq(sortCol, null, overrideAlias)) // If nulls are first, then we need to compare the value and reject nulls
+            : nullsOrder === "last" // The value to compare against is null
+                ? Eq(sortCol, null, overrideAlias) // If nulls are last, then we only accept nulls
+                : undefined; // If nulls first then any all values are accepted
+        // This will connect the compound clause to the previous clause for when the matching DB value equals the sort value
+        // E.g. if compoundClause is `col1 < $1` and nesting is `col2 < $2`, then the result will be
+        // `col1 < $1 OR (col1 = $1 AND col2 < $2)`
+        if (compoundClause) {
+            if (sortValue !== null) {
+                nesting = nesting
+                    ? Or(compoundClause, And(Eq(sortCol, sortValue, overrideAlias), nesting))
+                    : compoundClause;
+            }
+            else {
+                nesting = nesting ? And(compoundClause, nesting) : compoundClause;
+            }
+        }
+    });
+    return nesting;
+}
+exports.PaginationUnboundColsQuery = PaginationUnboundColsQuery;
 function PaginationMultipleColsQuery(sortCol, cursorCol, less, // if true, <, if false, >
 sortValue, cursorValue, overrideAlias) {
     const clauseFn = less ? Less : Greater;

package/core/db.d.ts

@@ -41,7 +41,7 @@ export default class DB {
     static getDialect(): Dialect;
     static initDB(args?: clientConfigArgs): void;
 }
-export declare const defaultTimestampParser: any;
+export declare const defaultTimestampParser: (value: string) => string;
 export interface Queryer {
     query(query: string, values?: any[]): Promise<QueryResult<QueryResultRow>>;
     queryAll(query: string, values?: any[]): Promise<QueryResult<QueryResultRow>>;

package/core/db.js

@@ -24,11 +24,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresClient = exports.Postgres = exports.Sqlite = exports.defaultTimestampParser = exports.Dialect = void 0;
-const pg_1 = __importStar(require("pg"));
 const fs = __importStar(require("fs"));
 const js_yaml_1 = require("js-yaml");
-const logger_1 = require("./logger");
 const luxon_1 = require("luxon");
+const pg_1 = __importStar(require("pg"));
+const logger_1 = require("./logger");
 function isDbDict(v) {
     return (v["production"] !== undefined ||
         v["development"] !== undefined ||

package/core/ent.d.ts

@@ -135,8 +135,16 @@ export declare class AssocEdge {
 }
 export interface cursorOptions {
     row: Data;
-    keys: string[];
-    cursorKeys?: string[];
+    /**
+     * The keys that will be stored in the cursor. This should be the DB columns.
+     */
+    cursorKeys: string[];
+    /**
+     * The keys that will be used to get the values from the row. This should be
+     * the row object keys. If not provided, the cursorKeys will be used. This is
+     * only used for tests internally.
+     */
+    rowKeys?: string[];
 }
 export declare function getCursor(opts: cursorOptions): string;
 export declare class AssocEdgeData {

package/core/ent.js

@@ -869,36 +869,29 @@ class AssocEdge {
     getCursor() {
         return getCursor({
             row: this,
-            keys: ["id2"],
+            cursorKeys: ["time", "id2"],
         });
     }
 }
 exports.AssocEdge = AssocEdge;
 // TODO eventually update this for sortCol time unique keys
 function getCursor(opts) {
-    const { row, keys, cursorKeys } = opts;
+    const { row, cursorKeys, rowKeys } = opts;
     //  row: Data, col: string, conv?: (any) => any) {
     if (!row) {
         throw new Error(`no row passed to getCursor`);
     }
-    if (cursorKeys?.length && cursorKeys.length !== keys.length) {
-        throw new Error("length of cursorKeys should match keys");
+    if (rowKeys?.length && rowKeys.length !== cursorKeys.length) {
+        throw new Error("length of cursorKeys should match rowKeys");
     }
-    const convert = (d) => {
-        if (d instanceof Date) {
-            return d.getTime();
-        }
-        return d;
-    };
+    const convert = (d) => (d instanceof Date ? d.toISOString() : d);
     const parts = [];
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        const cursorKey = cursorKeys?.[i] || key;
-        parts.push(key);
-        parts.push(convert(row[cursorKey]));
-    }
-    const str = parts.join(":");
-    return Buffer.from(str, "ascii").toString("base64");
+    for (let i = 0; i < cursorKeys.length; i++) {
+        const cursorKey = cursorKeys[i];
+        const rowKey = rowKeys?.[i] || cursorKey;
+        parts.push([cursorKey, convert(row[rowKey])]);
+    }
+    return btoa(JSON.stringify(parts));
 }
 exports.getCursor = getCursor;
 class AssocEdgeData {

package/core/loaders/assoc_edge_loader.d.ts

@@ -1,4 +1,4 @@
-import { Context, ID, EdgeQueryableDataOptions, Loader, LoaderFactory } from "../base";
+import { Context, EdgeQueryableDataOptions, ID, Loader, LoaderFactory } from "../base";
 import { AssocEdge, AssocEdgeConstructor } from "../ent";
 export interface AssocLoader<T extends AssocEdge> extends Loader<ID, T[]> {
     loadEdgeForID2(id: ID, id2: ID): Promise<T | undefined>;

package/core/loaders/assoc_edge_loader.js

@@ -28,11 +28,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssocEdgeLoaderFactory = exports.AssocDirectEdgeLoader = exports.AssocEdgeLoader = void 0;
 const dataloader_1 = __importDefault(require("dataloader"));
-const ent_1 = require("../ent");
+const memoizee_1 = __importDefault(require("memoizee"));
 const clause = __importStar(require("../clause"));
+const ent_1 = require("../ent");
 const logger_1 = require("../logger");
 const loader_1 = require("./loader");
-const memoizee_1 = __importDefault(require("memoizee"));
 function createLoader(options, edgeType, edgeCtr, edgeData) {
     const loaderOptions = {};
     if ((0, logger_1.logEnabled)("query")) {
@@ -208,7 +208,7 @@ class AssocEdgeLoaderFactory {
             return new AssocDirectEdgeLoader(this.edgeType, edgeCtr, options, context);
         }
         // we create a loader which can combine first X queries in the same fetch
-        const key = `${this.name}:limit:${options.limit}:orderby:${options.orderby}:disableTransformations:${options.disableTransformations}`;
+        const key = `${this.name}:limit:${options.limit}:orderby:${options.orderby?.map((orderBy) => JSON.stringify(orderBy))}:disableTransformations:${options.disableTransformations}`;
         return (0, loader_1.getCustomLoader)(key, () => new AssocEdgeLoader(this.edgeType, ctr, options, context), context);
     }
 }

package/core/query/assoc_query.d.ts

@@ -1,8 +1,8 @@
-import { ID, Ent, Viewer, LoadEntOptions, EdgeQueryableDataOptions } from "../base";
+import { EdgeQueryableDataOptions, Ent, ID, LoadEntOptions, Viewer } from "../base";
 import { AssocEdge } from "../ent";
 import { AssocEdgeCountLoaderFactory } from "../loaders/assoc_count_loader";
 import { AssocEdgeLoaderFactory } from "../loaders/assoc_edge_loader";
-import { EdgeQuery, BaseEdgeQuery, IDInfo } from "./query";
+import { BaseEdgeQuery, EdgeQuery, IDInfo } from "./query";
 export type EdgeQuerySource<TSource extends Ent<TViewer>, TDest extends Ent<TViewer> = Ent<any>, TViewer extends Viewer = Viewer> = TSource | TSource[] | ID | ID[] | EdgeQuery<TDest, Ent, AssocEdge>;
 type loaderOptionsFunc<TViewer extends Viewer> = (type: string) => LoadEntOptions<Ent, TViewer>;
 export declare abstract class AssocEdgeQueryBase<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TEdge extends AssocEdge, TViewer extends Viewer = Viewer> extends BaseEdgeQuery<TSource, TDest, TEdge> implements EdgeQuery<TSource, TDest, TEdge> {

package/core/query/assoc_query.js

@@ -24,16 +24,28 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssocEdgeQueryBase = void 0;
+const clause = __importStar(require("../clause"));
 const ent_1 = require("../ent");
 const query_1 = require("./query");
-const clause = __importStar(require("../clause"));
 // would be nice to someday have an API for assoc asc
 class AssocEdgeQueryBase extends query_1.BaseEdgeQuery {
     constructor(viewer, src, countLoaderFactory, dataLoaderFactory, 
     // if function, it's a polymorphic edge and need to provide
     // a function that goes from edgeType to LoadEntOptions
     options) {
-        super(viewer, "time", "id2");
+        super(viewer, {
+            cursorCol: "id2",
+            orderby: [
+                {
+                    column: "time",
+                    direction: "DESC",
+                },
+                {
+                    column: "id2",
+                    direction: "DESC",
+                },
+            ],
+        });
         this.viewer = viewer;
         this.src = src;
         this.countLoaderFactory = countLoaderFactory;

package/core/query/custom_clause_query.d.ts

@@ -1,9 +1,10 @@
 import { Data, EdgeQueryableDataOptions, Ent, ID, LoadEntOptions, QueryDataOptions, Viewer } from "../base";
 import { Clause } from "../clause";
 import { OrderBy } from "../query_impl";
-import { BaseEdgeQuery, EdgeQueryOptions, IDInfo } from "./query";
-export interface CustomClauseQueryOptions<TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
+import { BaseEdgeQuery, IDInfo } from "./query";
+export interface CustomClauseQueryOptions<TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer, TSource extends Ent<TViewer> | undefined = undefined> {
     loadEntOptions: LoadEntOptions<TDest, TViewer>;
+    source?: TSource;
     clause: Clause;
     name: string;
     primarySortColIsUnique?: boolean;
@@ -14,19 +15,20 @@ export interface CustomClauseQueryOptions<TDest extends Ent<TViewer>, TViewer ex
     disableTransformations?: boolean;
     joinBETA?: QueryDataOptions["join"];
 }
-export declare class CustomClauseQuery<TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> extends BaseEdgeQuery<any, TDest, Data> {
+export declare class CustomClauseQuery<TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer, TSource extends Ent<TViewer> | undefined = undefined> extends BaseEdgeQuery<any, TDest, Data> {
     viewer: TViewer;
     private options;
     private clause;
+    private source?;
     constructor(viewer: TViewer, options: CustomClauseQueryOptions<TDest, TViewer>);
-    sourceEnt(_id: ID): Promise<null>;
+    __maybeSetSource(src: TSource): void;
+    sourceEnt(_id: ID): Promise<NonNullable<TSource> | null>;
     getTableName(): string;
-    protected includeSortColInCursor(options: EdgeQueryOptions): boolean;
     queryRawCount(): Promise<number>;
     queryAllRawCount(): Promise<Map<ID, number>>;
     protected loadRawIDs(_addID: (src: ID) => void): Promise<void>;
     protected loadRawData(_infos: IDInfo[], options: EdgeQueryableDataOptions): Promise<void>;
     dataToID(edge: Data): ID;
     protected loadEntsFromEdges(id: ID, rows: Data[]): Promise<TDest[]>;
-    __getOptions(): CustomClauseQueryOptions<TDest, TViewer>;
+    __getOptions(): CustomClauseQueryOptions<TDest, TViewer, undefined>;
 }

package/core/query/custom_clause_query.js

@@ -52,17 +52,27 @@ class CustomClauseQuery extends query_1.BaseEdgeQuery {
         this.viewer = viewer;
         this.options = options;
         this.clause = getClause(options);
+        this.source = options.source;
+    }
+    __maybeSetSource(src) {
+        if (this.source && this.source !== src) {
+            console.warn("source already set to something else");
+        }
+        else {
+            this.source = src;
+        }
     }
     async sourceEnt(_id) {
-        return null;
+        // The sourceEnt is used for privacy checks and if we have the source we already know
+        // the privacy checks have been done or will be done
+        // This is being set for completeness but we don't really care about this.
+        // See https://github.com/lolopinto/ent/blob/15af0165f83458acc1d1c9f934f4534dca6154ff/ts/src/core/query/query.ts#L729-L739 for how sourceEnt is
+        // used in the codebase
+        return this.source ?? null;
     }
     getTableName() {
         return this.options.loadEntOptions.tableName;
     }
-    includeSortColInCursor(options) {
-        // TODO maybe we should just always do this?
-        return options.joinBETA !== undefined && this.sortCol !== this.cursorCol;
-    }
     async queryRawCount() {
         // sqlite needs as count otherwise it returns count(1)
         let fields = ["count(1) as count"];
@@ -97,7 +107,7 @@ class CustomClauseQuery extends query_1.BaseEdgeQuery {
         if (!options.orderby) {
             options.orderby = [
                 {
-                    column: this.getSortCol(),
+                    column: this.getCursorCol(),
                     direction: this.options.orderByDirection ?? "DESC",
                     nullsPlacement: this.options.nullsPlacement,
                 },
@@ -116,7 +126,12 @@ class CustomClauseQuery extends query_1.BaseEdgeQuery {
             // if doing a join, select distinct rows
             distinct: this.options.joinBETA !== undefined,
         });
-        this.edges.set(1, rows);
+        if (this.source) {
+            this.edges.set(this.source.id, rows);
+        }
+        else {
+            this.edges.set(1, rows);
+        }
     }
     dataToID(edge) {
         return edge.id;

package/core/query/custom_query.d.ts

@@ -1,7 +1,7 @@
-import { Data, Ent, ID, EdgeQueryableDataOptions, LoadEntOptions, Viewer, LoaderFactory, ConfigurableLoaderFactory } from "../base";
+import { ConfigurableLoaderFactory, Data, EdgeQueryableDataOptions, Ent, ID, LoadEntOptions, LoaderFactory, Viewer } from "../base";
 import { Clause } from "../clause";
 import { OrderBy } from "../query_impl";
-import { BaseEdgeQuery, IDInfo, EdgeQuery } from "./query";
+import { BaseEdgeQuery, EdgeQuery, IDInfo } from "./query";
 export interface CustomEdgeQueryOptionsDeprecated<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
     src: TSource | ID;
     countLoaderFactory: LoaderFactory<ID, number>;

package/core/query/custom_query.js

@@ -139,7 +139,7 @@ class CustomEdgeQueryBase extends query_1.BaseEdgeQuery {
         if (!options.orderby) {
             options.orderby = [
                 {
-                    column: this.getSortCol(),
+                    column: this.getCursorCol(),
                     direction: "DESC",
                 },
             ];

package/core/query/query.d.ts

@@ -1,4 +1,4 @@
-import { ID, Ent, Viewer, EdgeQueryableDataOptions, Data, PrivacyPolicy, EdgeQueryableDataOptionsConfigureLoader, QueryableDataOptions, SelectBaseDataOptions } from "../base";
+import { Data, EdgeQueryableDataOptions, EdgeQueryableDataOptionsConfigureLoader, Ent, ID, PrivacyPolicy, QueryableDataOptions, SelectBaseDataOptions, Viewer } from "../base";
 import { OrderBy } from "../query_impl";
 export interface EdgeQuery<TSource extends Ent, TDest extends Ent, TEdge extends Data> {
     queryEdges(): Promise<TEdge[]>;
@@ -31,6 +31,7 @@ export interface PaginationInfo {
     startCursor: string;
     endCursor: string;
 }
+export type CursorKeyValues = [key: string, value: string | number | null][];
 export interface EdgeQueryOptions {
     cursorCol: string;
     cursorColIsDate?: boolean;
@@ -48,16 +49,12 @@ export declare abstract class BaseEdgeQuery<TSource extends Ent, TDest extends E
     protected genIDInfosToFetch: () => Promise<IDInfo[]>;
     private idMap;
     private idsToFetch;
-    protected sortCol: string;
     protected cursorCol: string;
-    protected cursorColIsDate: boolean;
-    protected sortColIsDate: boolean;
     private edgeQueryOptions;
     private limitAdded;
     private cursorKeys;
-    constructor(viewer: Viewer, sortCol: string, cursorCol: string);
     constructor(viewer: Viewer, options: EdgeQueryOptions);
-    protected getSortCol(): string;
+    protected getCursorCol(): string;
     getPrivacyPolicy(): PrivacyPolicy<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>>;
     abstract sourceEnt(id: ID): Promise<Ent | null>;
     first(n: number, after?: string): this;
@@ -89,7 +86,6 @@ export declare abstract class BaseEdgeQuery<TSource extends Ent, TDest extends E
     protected configureEdgeQueryableDataOptions(opts: EdgeQueryableDataOptionsConfigureLoader): void;
     protected getDefaultEdgeQueryOptions(): Partial<Pick<QueryableDataOptions, "clause" | "limit" | "orderby" | "disableTransformations">> | undefined;
     private loadEdges;
-    protected includeSortColInCursor(options: EdgeQueryOptions): boolean;
     getCursor(row: TEdge): string;
 }
 export interface IDInfo {