@snowtop/ent 0.1.24 → 0.1.26

package/action/operations.d.ts

@@ -1,7 +1,7 @@
-import { Queryer, SyncQueryer } from "../core/db";
-import { Viewer, Ent, ID, Data, DataOptions, EditRowOptions, LoadEntOptions, Context, CreateRowOptions } from "../core/base";
+import { Builder, WriteOperation } from "../action";
 import { Executor } from "../action/action";
-import { WriteOperation, Builder } from "../action";
+import { Context, CreateRowOptions, Data, DataOptions, EditRowOptions, Ent, ID, LoadEntOptions, Viewer } from "../core/base";
+import { Queryer, SyncQueryer } from "../core/db";
 import { AssocEdgeData, parameterizedQueryOptions } from "../core/ent";
 export interface UpdatedOperation<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
     operation: WriteOperation;

package/action/operations.js

@@ -24,12 +24,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConditionalNodeOperation = exports.ConditionalOperation = exports.EdgeOperation = exports.EditNodeOperation = exports.NoOperation = exports.RawQueryOperation = exports.DeleteNodeOperation = void 0;
-const clause = __importStar(require("../core/clause"));
 const action_1 = require("../action");
-const schema_1 = require("../schema/schema");
-const global_schema_1 = require("../core/global_schema");
+const clause = __importStar(require("../core/clause"));
 const ent_1 = require("../core/ent");
+const global_schema_1 = require("../core/global_schema");
 const query_impl_1 = require("../core/query_impl");
+const schema_1 = require("../schema/schema");
 class DeleteNodeOperation {
     constructor(id, builder, options) {
         this.id = id;
@@ -224,7 +224,14 @@ class EditNodeOperation {
     }
     getReturning() {
         if (this.options.loadEntOptions.fields.length) {
-            return `RETURNING ${this.options.loadEntOptions.fields.join(",")}`;
+            return `RETURNING ${this.options.loadEntOptions.fields
+                .map((f) => {
+                if (typeof f === "object") {
+                    return `${f.alias}.${f.column}`;
+                }
+                return f;
+            })
+                .join(",")}`;
         }
         return `RETURNING *`;
     }

package/core/base.d.ts

@@ -67,7 +67,10 @@ export interface DataOptions {
     context?: Context;
 }
 export interface SelectBaseDataOptions extends DataOptions {
-    fields: string[];
+    fields: (string | {
+        alias: string;
+        column: string;
+    })[];
     fieldsAlias?: string;
     disableFieldsAlias?: boolean;
     disableDefaultOrderByAlias?: boolean;

package/core/clause.js

@@ -591,7 +591,7 @@ function ArrayNotEq(col, value) {
 exports.ArrayNotEq = ArrayNotEq;
 function Eq(col, value, overrideAlias) {
     return new simpleClause(col, value, "=", {
-        handleNull: new isNullClause(col),
+        handleNull: new isNullClause(col, overrideAlias),
         overrideAlias,
     });
 }
@@ -870,7 +870,7 @@ exports.JSONPathValuePredicate = JSONPathValuePredicate;
 function JSONKeyExists(dbCol, val, overrideAlias) {
     return new simpleClause(dbCol, val, "?", {
         // TODO ola: does isNullClause make sense here???
-        handleNull: new isNullClause(dbCol),
+        handleNull: new isNullClause(dbCol, overrideAlias),
         overrideAlias,
     });
 }
@@ -952,35 +952,35 @@ exports.PaginationMultipleColsQuery = PaginationMultipleColsQuery;
 // These 5 are used on the RHS of an expression
 function Add(col, value, overrideAlias) {
     return new simpleClause(col, value, "+", {
-        handleNull: new isNullClause(col),
+        handleNull: new isNullClause(col, overrideAlias),
         overrideAlias,
     });
 }
 exports.Add = Add;
 function Subtract(col, value, overrideAlias) {
     return new simpleClause(col, value, "-", {
-        handleNull: new isNullClause(col),
+        handleNull: new isNullClause(col, overrideAlias),
         overrideAlias,
     });
 }
 exports.Subtract = Subtract;
 function Multiply(col, value, overrideAlias) {
     return new simpleClause(col, value, "*", {
-        handleNull: new isNullClause(col),
+        handleNull: new isNullClause(col, overrideAlias),
         overrideAlias,
     });
 }
 exports.Multiply = Multiply;
 function Divide(col, value, overrideAlias) {
     return new simpleClause(col, value, "/", {
-        handleNull: new isNullClause(col),
+        handleNull: new isNullClause(col, overrideAlias),
         overrideAlias,
     });
 }
 exports.Divide = Divide;
 function Modulo(col, value, overrideAlias) {
     return new simpleClause(col, value, "%", {
-        handleNull: new isNullClause(col),
+        handleNull: new isNullClause(col, overrideAlias),
         overrideAlias,
     });
 }

package/core/context.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
-import { Viewer, Data, Loader, LoaderWithLoadMany, QueryOptions } from "./base";
 import { IncomingMessage, ServerResponse } from "http";
+import { Data, Loader, LoaderWithLoadMany, QueryOptions, Viewer } from "./base";
 import { Context } from "./base";
 export interface RequestContext<TViewer extends Viewer = Viewer> extends Context<TViewer> {
     authViewer(viewer: TViewer): Promise<void>;

package/core/context.js

@@ -39,7 +39,14 @@ class ContextCache {
     // maybe we just want to store sql queries???
     getkey(options) {
         let parts = [
-            options.fields.join(","),
+            options.fields
+                .map((f) => {
+                if (typeof f === "object") {
+                    return `${f.alias}.${f.column}`;
+                }
+                return f;
+            })
+                .join(","),
             options.clause.instanceKey(),
         ];
         if (options.orderby) {

package/core/ent.d.ts

@@ -1,7 +1,7 @@
+import { Context, CreateRowOptions, Data, DataOptions, EdgeQueryableDataOptions, EditRowOptions, Ent, ID, LoadCustomEntOptions, LoadEntOptions, LoadRowOptions, LoadRowsOptions, LoaderWithLoadMany, QueryDataOptions, SelectCustomDataOptions, Viewer } from "./base";
 import { Queryer, SyncQueryer } from "./db";
-import { Viewer, Ent, ID, LoadRowsOptions, LoadRowOptions, Data, DataOptions, EditRowOptions, LoadEntOptions, LoadCustomEntOptions, EdgeQueryableDataOptions, Context, CreateRowOptions, QueryDataOptions, SelectCustomDataOptions, LoaderWithLoadMany } from "./base";
-import * as clause from "./clause";
 import DataLoader from "dataloader";
+import * as clause from "./clause";
 import { OrderBy } from "./query_impl";
 declare class entCacheMap<TViewer extends Viewer, TEnt extends Ent<TViewer>> {
     private viewer;
@@ -103,7 +103,10 @@ interface GroupQueryOptions<T extends Data, K = keyof T> {
     tableName: string;
     clause?: clause.Clause<T, K>;
     groupColumn: K;
-    fields: K[];
+    fields: (K | {
+        alias: string;
+        column: K;
+    })[];
     values: any[];
     orderby?: OrderBy;
     limit: number;

package/core/ent.js

@@ -30,12 +30,12 @@ exports.applyPrivacyPolicyForRow = exports.loadNodesByEdge = exports.loadTwoWayE
 exports.getEdgeTypeInGroup = exports.applyPrivacyPolicyForRows = void 0;
 const db_1 = __importStar(require("./db"));
 const privacy_1 = require("./privacy");
-const clause = __importStar(require("./clause"));
-const logger_1 = require("./logger");
 const dataloader_1 = __importDefault(require("dataloader"));
+const clause = __importStar(require("./clause"));
 const global_schema_1 = require("./global_schema");
-const query_impl_1 = require("./query_impl");
 const loader_1 = require("./loaders/loader");
+const logger_1 = require("./logger");
+const query_impl_1 = require("./query_impl");
 class entCacheMap {
     constructor(viewer, options) {
         this.viewer = viewer;
@@ -638,8 +638,19 @@ function buildGroupQuery(options) {
     }
     // window functions work in sqlite!
     //    https://www.sqlite.org/windowfunctions.html
+    const fieldString = fields
+        .map((f) => {
+        if (typeof f === "object") {
+            // TS doesn't understand that K can only be a string, so we need
+            // for it to treat f as the object we know it is.
+            const fObj = f;
+            return `${fObj.alias}.${fObj.column}`;
+        }
+        return f;
+    })
+        .join(",");
     return [
-        `SELECT * FROM (SELECT ${fields.join(",")} OVER (PARTITION BY ${options.groupColumn} ${orderby}) as row_num FROM ${options.tableName} WHERE ${cls.clause(1)}) t WHERE row_num <= ${options.limit}`,
+        `SELECT * FROM (SELECT ${fieldString} OVER (PARTITION BY ${options.groupColumn} ${orderby}) as row_num FROM ${options.tableName} WHERE ${cls.clause(1)}) t WHERE row_num <= ${options.limit}`,
         cls,
     ];
 }

package/core/loaders/query_loader.d.ts

@@ -1,7 +1,7 @@
-import { Context, EdgeQueryableDataOptions, Loader, LoaderFactory, Data } from "../base";
+import { Context, Data, EdgeQueryableDataOptions, Loader, LoaderFactory } from "../base";
 import * as clause from "../clause";
-import { ObjectLoaderFactory } from "./object_loader";
 import { OrderBy } from "../query_impl";
+import { ObjectLoaderFactory } from "./object_loader";
 declare class QueryDirectLoader<K extends any> implements Loader<K, Data[]> {
     private options;
     private queryOptions?;
@@ -14,7 +14,10 @@ declare class QueryDirectLoader<K extends any> implements Loader<K, Data[]> {
     clearAll(): void;
 }
 interface QueryOptions {
-    fields: string[];
+    fields: (string | {
+        alias: string;
+        column: string;
+    })[];
     tableName: string;
     groupCol?: string;
     clause?: clause.Clause;

package/core/loaders/query_loader.js

@@ -28,11 +28,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryLoaderFactory = 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 getOrderByLocal(options, queryOptions) {
     return (options.orderby ??
         queryOptions?.orderby ?? [

package/core/query/custom_clause_query.js

@@ -67,15 +67,15 @@ class CustomClauseQuery extends query_1.BaseEdgeQuery {
         // 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 firstRequestedField = this.options.loadEntOptions.fields[0];
             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 fieldString = typeof firstRequestedField === "object"
+                ? `${firstRequestedField.alias}.${firstRequestedField.column}`
+                : alias
+                    ? `${alias}.${firstRequestedField}`
+                    : firstRequestedField;
+            fields = [`count(distinct ${fieldString}) as count`];
         }
         const row = await (0, ent_1.loadRow)({
             ...this.options.loadEntOptions,

package/core/query_impl.js

@@ -47,9 +47,20 @@ function getJoinInfo(join, clauseIdx = 1) {
 exports.getJoinInfo = getJoinInfo;
 function buildQuery(options) {
     const fieldsAlias = options.fieldsAlias ?? options.alias;
-    const fields = fieldsAlias && !options.disableFieldsAlias
-        ? options.fields.map((f) => `${fieldsAlias}.${f}`).join(", ")
-        : options.fields.join(", ");
+    const fields = options.fields
+        .map((f) => {
+        if (typeof f === "object") {
+            if (!options.disableFieldsAlias) {
+                return `${f.alias}.${f.column}`;
+            }
+            return f.column;
+        }
+        if (fieldsAlias && !options.disableFieldsAlias) {
+            return `${fieldsAlias}.${f}`;
+        }
+        return f;
+    })
+        .join(", ");
     // always start at 1
     const parts = [];
     const tableName = options.alias

package/package.json

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