@snowtop/ent 0.1.19-test2 → 0.1.20

package/core/context.js

@@ -46,7 +46,7 @@ class ContextCache {
             parts.push((0, query_impl_1.getOrderByPhrase)(options.orderby));
         }
         if (options.join) {
-            parts.push((0, query_impl_1.getJoinPhrase)(options.join));
+            parts.push((0, query_impl_1.getJoinInfo)(options.join).phrase);
         }
         return parts.join(",");
     }

package/core/ent.d.ts

@@ -132,9 +132,8 @@ export declare class AssocEdge {
 }
 export interface cursorOptions {
     row: Data;
-    col: string;
-    cursorKey?: string;
-    conv?: (any: any) => any;
+    keys: string[];
+    cursorKeys?: string[];
 }
 export declare function getCursor(opts: cursorOptions): string;
 export declare class AssocEdgeData {

package/core/ent.js

@@ -848,27 +848,35 @@ class AssocEdge {
     getCursor() {
         return getCursor({
             row: this,
-            col: "id2",
+            keys: ["id2"],
         });
     }
 }
 exports.AssocEdge = AssocEdge;
 // TODO eventually update this for sortCol time unique keys
 function getCursor(opts) {
-    const { row, col, conv } = opts;
+    const { row, keys, cursorKeys } = opts;
     //  row: Data, col: string, conv?: (any) => any) {
     if (!row) {
         throw new Error(`no row passed to getCursor`);
     }
-    let datum = row[col];
-    if (!datum) {
-        return "";
+    if (cursorKeys?.length && cursorKeys.length !== keys.length) {
+        throw new Error("length of cursorKeys should match keys");
     }
-    if (conv) {
-        datum = conv(datum);
-    }
-    const cursorKey = opts.cursorKey || col;
-    const str = `${cursorKey}:${datum}`;
+    const convert = (d) => {
+        if (d instanceof Date) {
+            return d.getTime();
+        }
+        return 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");
 }
 exports.getCursor = getCursor;
@@ -1078,13 +1086,15 @@ async function loadTwoWayEdges(opts) {
         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")),
-        },
+        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;
 }

package/core/query/custom_clause_query.d.ts

@@ -1,7 +1,7 @@
-import { Data, EdgeQueryableDataOptions, Ent, ID, LoadEntOptions, Viewer } from "../base";
+import { Data, EdgeQueryableDataOptions, Ent, ID, LoadEntOptions, QueryDataOptions, Viewer } from "../base";
 import { Clause } from "../clause";
 import { OrderBy } from "../query_impl";
-import { BaseEdgeQuery, IDInfo } from "./query";
+import { BaseEdgeQuery, EdgeQueryOptions, IDInfo } from "./query";
 export interface CustomClauseQueryOptions<TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
     loadEntOptions: LoadEntOptions<TDest, TViewer>;
     clause: Clause;
@@ -12,6 +12,7 @@ export interface CustomClauseQueryOptions<TDest extends Ent<TViewer>, TViewer ex
     orderByDirection?: "ASC" | "DESC";
     nullsPlacement?: "first" | "last";
     disableTransformations?: boolean;
+    joinBETA?: QueryDataOptions["join"];
 }
 export declare class CustomClauseQuery<TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> extends BaseEdgeQuery<any, TDest, Data> {
     viewer: TViewer;
@@ -20,10 +21,12 @@ export declare class CustomClauseQuery<TDest extends Ent<TViewer>, TViewer exten
     constructor(viewer: TViewer, options: CustomClauseQueryOptions<TDest, TViewer>);
     sourceEnt(_id: ID): Promise<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>;
 }

package/core/query/custom_clause_query.js

@@ -46,6 +46,8 @@ class CustomClauseQuery extends query_1.BaseEdgeQuery {
         super(viewer, {
             orderby,
             cursorCol,
+            joinBETA: options.joinBETA,
+            fieldOptions: options.loadEntOptions,
         });
         this.viewer = viewer;
         this.options = options;
@@ -57,13 +59,32 @@ class CustomClauseQuery extends query_1.BaseEdgeQuery {
     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"];
+        if (this.options.joinBETA) {
+            const requestedFields = this.options.loadEntOptions.fields;
+            const alias = this.options.loadEntOptions.fieldsAlias ??
+                this.options.loadEntOptions.alias;
+            if (alias) {
+                fields = [`count(distinct ${alias}.${requestedFields[0]}) as count`];
+            }
+            else {
+                fields = [`count(distinct ${requestedFields[0]}) as count`];
+            }
+        }
         const row = await (0, ent_1.loadRow)({
+            ...this.options.loadEntOptions,
             tableName: this.options.loadEntOptions.tableName,
-            // sqlite needs as count otherwise it returns count(1)
-            fields: ["count(1) as count"],
+            fields,
             clause: this.clause,
             context: this.viewer.context,
+            join: this.options.joinBETA,
+            disableFieldsAlias: true,
         });
         return parseInt(row?.count, 10) || 0;
     }
@@ -86,12 +107,14 @@ class CustomClauseQuery extends query_1.BaseEdgeQuery {
             options.limit = (0, ent_1.getDefaultLimit)();
         }
         const rows = await (0, ent_1.loadRows)({
-            tableName: this.options.loadEntOptions.tableName,
-            fields: this.options.loadEntOptions.fields,
+            ...this.options.loadEntOptions,
             clause: (0, clause_1.AndOptional)(this.clause, options.clause),
             orderby: options.orderby,
             limit: options?.limit || (0, ent_1.getDefaultLimit)(),
             context: this.viewer.context,
+            join: this.options.joinBETA,
+            // if doing a join, select distinct rows
+            distinct: this.options.joinBETA !== undefined,
         });
         this.edges.set(1, rows);
     }
@@ -101,5 +124,8 @@ class CustomClauseQuery extends query_1.BaseEdgeQuery {
     async loadEntsFromEdges(id, rows) {
         return (0, ent_1.applyPrivacyPolicyForRows)(this.viewer, rows, this.options.loadEntOptions);
     }
+    __getOptions() {
+        return this.options;
+    }
 }
 exports.CustomClauseQuery = CustomClauseQuery;

package/core/query/custom_query.js

@@ -80,6 +80,7 @@ class CustomEdgeQueryBase extends query_1.BaseEdgeQuery {
         super(viewer, {
             cursorCol: uniqueCol,
             orderby,
+            fieldOptions: opts.loaderFactory.options,
         });
         this.viewer = viewer;
         this.options = options;

package/core/query/query.d.ts

@@ -1,4 +1,4 @@
-import { ID, Ent, Viewer, EdgeQueryableDataOptions, Data, PrivacyPolicy, EdgeQueryableDataOptionsConfigureLoader } from "../base";
+import { ID, Ent, Viewer, EdgeQueryableDataOptions, Data, PrivacyPolicy, EdgeQueryableDataOptionsConfigureLoader, QueryableDataOptions, SelectBaseDataOptions } from "../base";
 import { OrderBy } from "../query_impl";
 export interface EdgeQuery<TSource extends Ent, TDest extends Ent, TEdge extends Data> {
     queryEdges(): Promise<TEdge[]>;
@@ -31,9 +31,12 @@ export interface PaginationInfo {
     startCursor: string;
     endCursor: string;
 }
-interface EdgeQueryOptions {
+export interface EdgeQueryOptions {
     cursorCol: string;
+    cursorColIsDate?: boolean;
     orderby: OrderBy;
+    joinBETA?: NonNullable<QueryableDataOptions["join"]>;
+    fieldOptions?: SelectBaseDataOptions;
 }
 export declare abstract class BaseEdgeQuery<TSource extends Ent, TDest extends Ent, TEdge extends Data> implements EdgeQuery<TSource, TDest, TEdge> {
     viewer: Viewer;
@@ -45,10 +48,13 @@ export declare abstract class BaseEdgeQuery<TSource extends Ent, TDest extends E
     protected genIDInfosToFetch: () => Promise<IDInfo[]>;
     private idMap;
     private idsToFetch;
-    private sortCol;
-    private cursorCol;
+    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;
@@ -81,12 +87,12 @@ export declare abstract class BaseEdgeQuery<TSource extends Ent, TDest extends E
     protected genIDInfosToFetchImpl(): Promise<IDInfo[]>;
     private _defaultEdgeQueryableOptions;
     protected configureEdgeQueryableDataOptions(opts: EdgeQueryableDataOptionsConfigureLoader): void;
-    protected getDefaultEdgeQueryOptions(): Partial<Pick<import("../base").QueryableDataOptions, "clause" | "limit" | "orderby" | "disableTransformations">> | undefined;
+    protected getDefaultEdgeQueryOptions(): Partial<Pick<QueryableDataOptions, "clause" | "limit" | "orderby" | "disableTransformations">> | undefined;
     private loadEdges;
+    protected includeSortColInCursor(options: EdgeQueryOptions): boolean;
     getCursor(row: TEdge): string;
 }
 export interface IDInfo {
     id: ID;
     invalidated?: boolean;
 }
-export {};

package/core/query/query.js

@@ -40,36 +40,61 @@ function assertPositive(n) {
         throw new Error("cannot use a negative number");
     }
 }
-function assertValidCursor(cursor, col) {
-    let decoded = Buffer.from(cursor, "base64").toString("ascii");
-    let parts = decoded.split(":");
-    // uuid, don't parse int since it tries to validate just first part
-    if ((0, uuid_1.validate)(parts[1])) {
-        return parts[1];
-    }
-    // invalid or unknown cursor. nothing to do here.
-    if (parts.length !== 2 || parts[0] !== col) {
-        throw new Error(`invalid cursor ${cursor} passed`);
-    }
+function convertToIntMaybe(val) {
     // TODO handle both cases... (time vs not) better
     // TODO change this to only do the parseInt part if time...
     // pass flag indicating if time?
-    const time = parseInt(parts[1], 10);
+    // handle non-integers for which the first part is an int
+    // @ts-ignore
+    if (isNaN(val)) {
+        return val;
+    }
+    const time = parseInt(val, 10);
     if (isNaN(time)) {
-        return parts[1];
+        return val;
     }
     return time;
 }
+function assertValidCursor(cursor, opts) {
+    let decoded = Buffer.from(cursor, "base64").toString("ascii");
+    let parts = decoded.split(":");
+    const { keys } = opts;
+    // invalid or unknown cursor. nothing to do here.
+    // we should have the same number of parts as keys * 2
+    if (parts.length !== keys.length * 2) {
+        throw new Error(`invalid cursor ${cursor} passed`);
+    }
+    const values = [];
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const keyPart = parts[i * 2];
+        if (key !== keyPart) {
+            throw new Error(`invalid cursor ${cursor} passed. expected ${key}. got ${keyPart} as key of field`);
+        }
+        const val = parts[i * 2 + 1];
+        // uuid, don't parse int since it tries to validate just first part
+        if ((0, uuid_1.validate)(val)) {
+            values.push(val);
+            continue;
+        }
+        values.push(convertToIntMaybe(val));
+    }
+    return values;
+}
 const orderbyRegex = new RegExp(/([0-9a-z_]+)[ ]?([0-9a-z_]+)?/i);
 class FirstFilter {
     constructor(options) {
         this.options = options;
         this.pageMap = new Map();
         this.usedQuery = false;
+        this.cursorValues = [];
         assertPositive(options.limit);
         this.sortCol = options.sortCol;
         if (options.after) {
-            this.offset = assertValidCursor(options.after, options.cursorCol);
+            this.cursorValues = assertValidCursor(options.after, {
+                keys: options.cursorKeys,
+            });
+            this.offset = this.cursorValues[0];
         }
         this.edgeQuery = options.query;
     }
@@ -133,6 +158,18 @@ class FirstFilter {
         // so we'd need a way to indicate whether this is done in sql or not
         return edges;
     }
+    getOffsetForQuery() {
+        // cursorCol maps to offset which we get from the cursor in assertValidCursor
+        return this.options.cursorColIsDate
+            ? new Date(this.offset).toISOString()
+            : this.offset;
+    }
+    getSortValueForQuery() {
+        // sortCol maps to the value we're comparing against
+        return this.options.sortColIsDate
+            ? new Date(this.cursorValues[1]).toISOString()
+            : this.cursorValues[1];
+    }
     async query(options) {
         this.usedQuery = true;
         // we fetch an extra one to see if we're at the end
@@ -150,17 +187,25 @@ class FirstFilter {
             });
             if (this.offset) {
                 const res = this.edgeQuery.getTableName();
-                const tableName = (0, types_1.isPromise)(res) ? await res : res;
-                // inner col time
-                options.clause = clause.AndOptional(options.clause, clause.PaginationMultipleColsSubQuery(this.sortCol, less ? "<" : ">", tableName, this.options.cursorCol, this.offset));
+                let tableName = (0, types_1.isPromise)(res) ? await res : res;
+                // using a join, we already know sortCol and cursorCol are different
+                // we have encoded both values in the cursor
+                // includeSortColInCursor() is true in this case
+                if (this.cursorValues.length === 2 &&
+                    this.options.cursorKeys.length === 2) {
+                    options.clause = clause.AndOptional(options.clause, clause.PaginationMultipleColsQuery(this.sortCol, this.options.cursorCol, less, this.getSortValueForQuery(), this.getOffsetForQuery(), this.options.fieldOptions?.fieldsAlias ??
+                        this.options.fieldOptions?.alias));
+                }
+                else {
+                    // inner col time
+                    options.clause = clause.AndOptional(options.clause, clause.PaginationMultipleColsSubQuery(this.sortCol, less ? "<" : ">", tableName, this.options.cursorCol, this.getOffsetForQuery()));
+                }
             }
         }
         else {
             if (this.offset) {
-                let clauseFn = less ? clause.Less : clause.Greater;
-                let val = this.options.sortColTime
-                    ? new Date(this.offset).toISOString()
-                    : this.offset;
+                const clauseFn = less ? clause.Less : clause.Greater;
+                const val = this.getOffsetForQuery();
                 options.clause = clause.AndOptional(options.clause, clauseFn(this.sortCol, val));
             }
         }
@@ -172,14 +217,20 @@ class FirstFilter {
         return this.pageMap.get(id);
     }
 }
+// TODO LastFilter same behavior as FirstFilter
+// TODO can we share so we don't keep needing to change in both
 class LastFilter {
     constructor(options) {
         this.options = options;
         this.pageMap = new Map();
+        this.cursorValues = [];
         assertPositive(options.limit);
         this.sortCol = options.sortCol;
         if (options.before) {
-            this.offset = assertValidCursor(options.before, options.cursorCol);
+            this.cursorValues = assertValidCursor(options.before, {
+                keys: options.cursorKeys,
+            });
+            this.offset = this.cursorValues[0];
         }
         this.edgeQuery = options.query;
     }
@@ -210,6 +261,19 @@ class LastFilter {
         }
         return ret;
     }
+    // copied from FirstFilter
+    getOffsetForQuery() {
+        // cursorCol maps to offset which we get from the cursor in assertValidCursor
+        return this.options.cursorColIsDate
+            ? new Date(this.offset).toISOString()
+            : this.offset;
+    }
+    getSortValueForQuery() {
+        // sortCol maps to the value we're comparing against
+        return this.options.sortColIsDate
+            ? new Date(this.cursorValues[1]).toISOString()
+            : this.cursorValues[1];
+    }
     async query(options) {
         const orderby = (0, query_impl_1.reverseOrderBy)(this.options.orderby);
         const greater = orderby[0].direction === "ASC";
@@ -218,8 +282,20 @@ class LastFilter {
             const res = this.edgeQuery.getTableName();
             const tableName = (0, types_1.isPromise)(res) ? await res : res;
             if (this.offset) {
-                // inner col time
-                options.clause = clause.AndOptional(options.clause, clause.PaginationMultipleColsSubQuery(this.sortCol, greater ? ">" : "<", tableName, this.options.cursorCol, this.offset));
+                // using a join, we already know sortCol and cursorCol are different
+                // we have encoded both values in the cursor
+                // includeSortColInCursor() is true in this case
+                if (this.cursorValues.length === 2 &&
+                    this.options.cursorKeys.length === 2) {
+                    options.clause = clause.AndOptional(options.clause, clause.PaginationMultipleColsQuery(this.sortCol, this.options.cursorCol, 
+                    // flipped here since we're going in the opposite direction
+                    !greater, this.getSortValueForQuery(), this.getOffsetForQuery(), this.options.fieldOptions?.fieldsAlias ??
+                        this.options.fieldOptions?.alias));
+                }
+                else {
+                    // inner col time
+                    options.clause = clause.AndOptional(options.clause, clause.PaginationMultipleColsSubQuery(this.sortCol, greater ? ">" : "<", tableName, this.options.cursorCol, this.getOffsetForQuery()));
+                }
             }
             // we also sort cursor col in same direction. (direction doesn't matter)
             orderby.push({
@@ -229,10 +305,8 @@ class LastFilter {
         }
         else {
             if (this.offset) {
-                let clauseFn = greater ? clause.Greater : clause.Less;
-                let val = this.options.sortColTime
-                    ? new Date(this.offset).toISOString()
-                    : this.offset;
+                const clauseFn = greater ? clause.Greater : clause.Less;
+                const val = this.getOffsetForQuery();
                 options.clause = clause.AndOptional(options.clause, clauseFn(this.sortCol, val));
             }
         }
@@ -252,6 +326,7 @@ class BaseEdgeQuery {
         this.idMap = new Map();
         this.idsToFetch = [];
         this.limitAdded = false;
+        this.cursorKeys = [];
         // this is basically just raw rows
         this.queryEdges = async () => {
             return this.querySingleEdge("queryEdges");
@@ -304,6 +379,8 @@ class BaseEdgeQuery {
         };
         let sortCol;
         let cursorCol;
+        let sortColIsDate = false;
+        let cursorColIsDate = false;
         if (typeof sortColOrOptions === "string") {
             sortCol = sortColOrOptions;
             cursorCol = cursorColMaybe;
@@ -324,11 +401,15 @@ class BaseEdgeQuery {
             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;
+                sortColIsDate = sortColOrOptions.orderby[0].dateColumn ?? false;
             }
             cursorCol = sortColOrOptions.cursorCol;
+            cursorColIsDate = sortColOrOptions.cursorColIsDate ?? false;
             this.edgeQueryOptions = sortColOrOptions;
         }
         this.sortCol = sortCol;
+        this.sortColIsDate = sortColIsDate;
+        this.cursorColIsDate = cursorColIsDate;
         let m = orderbyRegex.exec(sortCol);
         if (!m) {
             throw new Error(`invalid sort column ${sortCol}`);
@@ -340,6 +421,10 @@ class BaseEdgeQuery {
         this.cursorCol = cursorCol;
         this.memoizedloadEdges = (0, memoizee_1.default)(this.loadEdges.bind(this));
         this.genIDInfosToFetch = (0, memoizee_1.default)(this.genIDInfosToFetchImpl.bind(this));
+        this.cursorKeys.push(this.cursorCol);
+        if (this.includeSortColInCursor(this.edgeQueryOptions)) {
+            this.cursorKeys.push(this.sortCol);
+        }
     }
     getSortCol() {
         return this.sortCol;
@@ -356,8 +441,12 @@ class BaseEdgeQuery {
             after,
             sortCol: this.sortCol,
             cursorCol: this.cursorCol,
+            cursorKeys: this.cursorKeys,
+            cursorColIsDate: this.cursorColIsDate,
+            sortColIsDate: this.sortColIsDate,
             orderby: this.edgeQueryOptions.orderby,
             query: this,
+            fieldOptions: this.edgeQueryOptions.fieldOptions,
         }));
         return this;
     }
@@ -379,8 +468,12 @@ class BaseEdgeQuery {
             before,
             sortCol: this.sortCol,
             cursorCol: this.cursorCol,
+            cursorKeys: this.cursorKeys,
+            cursorColIsDate: this.cursorColIsDate,
+            sortColIsDate: this.sortColIsDate,
             orderby: this.edgeQueryOptions.orderby,
             query: this,
+            fieldOptions: this.edgeQueryOptions.fieldOptions,
         }));
         return this;
     }
@@ -490,10 +583,13 @@ class BaseEdgeQuery {
         this.queryDispatched = true;
         return this.edges;
     }
+    includeSortColInCursor(options) {
+        return false;
+    }
     getCursor(row) {
         return (0, ent_1.getCursor)({
             row,
-            col: this.cursorCol,
+            keys: this.cursorKeys,
         });
     }
 }

package/core/query/shared_test.js

@@ -205,11 +205,24 @@ const commonTests = (opts) => {
     function getViewer() {
         return new viewer_1.LoggedOutViewer();
     }
-    function getCursorFrom(contacts, idx) {
-        return (0, ent_1.getCursor)({
-            row: contacts[idx],
-            col: "id",
-        });
+    function getCursorFrom(q, contacts, idx) {
+        let opts;
+        if (isCustomQuery(q)) {
+            opts = {
+                row: contacts[idx],
+                keys: ["id"],
+            };
+        }
+        else {
+            // for assoc queries, we're getting the value from 'id' field but the edge
+            // is from assoc_edge table id2 field and so cursor takes it from there
+            opts = {
+                row: contacts[idx],
+                keys: ["id2"],
+                cursorKeys: ["id"],
+            };
+        }
+        return (0, ent_1.getCursor)(opts);
     }
     function getVerifyAfterEachCursor(edges, pageLength, user) {
         return (0, query_1.getVerifyAfterEachCursorGeneric)(edges, pageLength, user, 
@@ -550,7 +563,7 @@ const commonTests = (opts) => {
         const idx = 2;
         const N = 3;
         const filter = new TestQueryFilter((q, user, contacts) => {
-            return q.first(N, getCursorFrom(contacts, idx));
+            return q.first(N, getCursorFrom(q, contacts, idx));
         }, opts.newQuery, (contacts) => {
             if (opts.orderby[0].direction === "DESC") {
                 // < check so we shouldn't get that index
@@ -611,7 +624,7 @@ const commonTests = (opts) => {
         const idx = 2;
         const N = 3;
         const filter = new TestQueryFilter((q, user, contacts) => {
-            return q.last(N, getCursorFrom(contacts, idx));
+            return q.last(N, getCursorFrom(q, contacts, idx));
         }, opts.newQuery, (contacts) => {
             // > check so we don't want that index
             if (opts.orderby[0].direction === "DESC") {

package/core/query_impl.d.ts

@@ -3,9 +3,15 @@ export interface OrderByOption {
     column: string;
     direction: "ASC" | "DESC";
     nullsPlacement?: "first" | "last";
+    dateColumn?: boolean;
 }
 export type OrderBy = OrderByOption[];
 export declare function getOrderByPhrase(orderby: OrderBy, alias?: string): string;
 export declare function reverseOrderBy(orderby: OrderBy): OrderBy;
-export declare function getJoinPhrase(join: NonNullable<QueryableDataOptions["join"]>, clauseIdx?: number): string;
+interface JoinInfo {
+    phrase: string;
+    valuesUsed: number;
+}
+export declare function getJoinInfo(join: NonNullable<QueryableDataOptions["join"]>, clauseIdx?: number): JoinInfo;
 export declare function buildQuery(options: QueryableDataOptions): string;
+export {};