@snowtop/ent 0.1.0-alpha149 → 0.1.0-alpha150

package/core/ent.js

@@ -627,17 +627,18 @@ function buildQuery(options) {
     const fields = options.fields.join(", ");
     // always start at 1
     const whereClause = options.clause.clause(1);
-    let query = `SELECT ${fields} FROM ${options.tableName} WHERE ${whereClause}`;
+    const parts = [];
+    parts.push(`SELECT ${fields} FROM ${options.tableName} WHERE ${whereClause}`);
     if (options.groupby) {
-        query = `${query} GROUP BY ${options.groupby}`;
+        parts.push(`GROUP BY ${options.groupby}`);
     }
     if (options.orderby) {
-        query = `${query} ORDER BY ${options.orderby}`;
+        parts.push(`ORDER BY ${options.orderby}`);
     }
     if (options.limit) {
-        query = `${query} LIMIT ${options.limit}`;
+        parts.push(`LIMIT ${options.limit}`);
     }
-    return query;
+    return parts.join(" ");
 }
 exports.buildQuery = buildQuery;
 // this is used for queries when we select multiple ids at once

package/core/query/custom_clause_query.d.ts

@@ -1,13 +1,14 @@
 import { Data, EdgeQueryableDataOptions, Ent, ID, LoadEntOptions, Viewer } from "../base";
 import { Clause } from "../clause";
 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;
     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> {
@@ -24,4 +25,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

@@ -30,7 +30,11 @@ class CustomClauseQuery extends query_1.BaseEdgeQuery {
         if (options.orderByDirection) {
             sortCol = `${sortCol} ${options.orderByDirection}`;
         }
-        super(viewer, sortCol, unique);
+        super(viewer, {
+            sortCol,
+            cursorCol: unique,
+            nullsPlacement: options.nullsPlacement,
+        });
         this.viewer = viewer;
         this.options = options;
         this.clause = getClause(options);

package/core/query/query.d.ts

@@ -29,6 +29,11 @@ export interface PaginationInfo {
     startCursor: string;
     endCursor: string;
 }
+interface EdgeQueryOptions {
+    cursorCol: string;
+    sortCol: string;
+    nullsPlacement?: "first" | "last";
+}
 export declare abstract class BaseEdgeQuery<TSource extends Ent, TDest extends Ent, TEdge extends Data> implements EdgeQuery<TSource, TDest, TEdge> {
     viewer: Viewer;
     private filters;
@@ -42,7 +47,9 @@ export declare abstract class BaseEdgeQuery<TSource extends Ent, TDest extends E
     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>;
@@ -76,3 +83,4 @@ export interface IDInfo {
     id: ID;
     invalidated?: boolean;
 }
+export {};

package/core/query/query.js

@@ -99,9 +99,19 @@ class FirstFilter {
         // 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";
+            }
+        }
         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}`;
+            // 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}`;
             if (this.offset) {
                 const res = this.edgeQuery.getTableName();
                 const tableName = util_1.types.isPromise(res) ? await res : res;
@@ -110,7 +120,7 @@ class FirstFilter {
             }
         }
         else {
-            options.orderby = `${this.sortCol} ${orderby}`;
+            options.orderby = `${this.sortCol}${nullsPlacement} ${orderby}`;
             if (this.offset) {
                 let clauseFn = less ? clause.Less : clause.Greater;
                 let val = this.options.sortColTime
@@ -205,7 +215,7 @@ class LastFilter {
     }
 }
 class BaseEdgeQuery {
-    constructor(viewer, sortCol, cursorCol) {
+    constructor(viewer, sortColOrOptions, cursorColMaybe) {
         this.viewer = viewer;
         this.filters = [];
         this.edges = new Map();
@@ -262,6 +272,21 @@ class BaseEdgeQuery {
             await Promise.all(promises);
             return results;
         };
+        let sortCol;
+        let cursorCol;
+        if (typeof sortColOrOptions === "string") {
+            sortCol = sortColOrOptions;
+            cursorCol = cursorColMaybe;
+            this.edgeQueryOptions = {
+                cursorCol,
+                sortCol,
+            };
+        }
+        else {
+            sortCol = sortColOrOptions.sortCol;
+            cursorCol = sortColOrOptions.cursorCol;
+            this.edgeQueryOptions = sortColOrOptions;
+        }
         let m = orderbyRegex.exec(sortCol);
         if (!m) {
             throw new Error(`invalid sort column ${sortCol}`);
@@ -294,6 +319,7 @@ class BaseEdgeQuery {
             sortCol: this.sortCol,
             cursorCol: this.cursorCol,
             defaultDirection: this.defaultDirection,
+            nullsPlacement: this.edgeQueryOptions.nullsPlacement,
             query: this,
         }));
         return this;
@@ -306,6 +332,7 @@ class BaseEdgeQuery {
             sortCol: this.sortCol,
             cursorCol: this.cursorCol,
             defaultDirection: this.defaultDirection,
+            nullsPlacement: this.edgeQueryOptions.nullsPlacement,
             query: this,
         }));
         return this;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.1.0-alpha149",
+  "version": "0.1.0-alpha150",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",

package/testutils/fake_data/test_helpers.js

@@ -257,7 +257,7 @@ async function createAllEvents(opts) {
         const input = opts.eventInputs?.[idx];
         const builder = (0, fake_event_1.getEventBuilder)(user.viewer, getEventInput(user, input));
         await builder.saveX();
-        return await builder.editedEntX();
+        return builder.editedEntX();
     }));
     expect(events.length).toBe(opts.howMany);
     return [user, events];