@snowtop/ent 0.1.0-alpha151 → 0.1.0-alpha153

package/action/index.d.ts

@@ -3,3 +3,4 @@ export { OrchestratorOptions, Orchestrator, EntChangeset, EdgeInputData, } from
 export { DenyIfBuilder, AllowIfBuilder } from "./privacy";
 export { RelativeFieldValue, RelativeNumberValue, NumberOps, convertRelativeInput, maybeConvertRelativeInputPlusExpressions, } from "./relative_value";
 export { Transaction } from "./transaction";
+export { AssocEdgeOptions } from "./operations";

package/action/operations.d.ts

@@ -68,6 +68,7 @@ export interface AssocEdgeInputOptions extends AssocEdgeOptions {
 }
 export interface AssocEdgeOptions {
     conditional?: boolean;
+    disableTransformations?: boolean;
 }
 export interface AssocEdgeInput extends AssocEdgeInputOptions {
     id1: ID;
@@ -100,8 +101,8 @@ export declare class EdgeOperation implements DataOperation {
     private static resolveData;
     static inboundEdge<T extends Ent, T2 extends Ent>(builder: Builder<T>, edgeType: string, id1: Builder<T2> | ID, nodeType: string, options?: AssocEdgeInputOptions): EdgeOperation;
     static outboundEdge<T extends Ent, T2 extends Ent>(builder: Builder<T>, edgeType: string, id2: Builder<T2> | ID, nodeType: string, options?: AssocEdgeInputOptions): EdgeOperation;
-    static removeInboundEdge<T extends Ent>(builder: Builder<T>, edgeType: string, id1: ID): EdgeOperation;
-    static removeOutboundEdge<T extends Ent>(builder: Builder<T>, edgeType: string, id2: ID): EdgeOperation;
+    static removeInboundEdge<T extends Ent>(builder: Builder<T>, edgeType: string, id1: ID, options?: AssocEdgeInputOptions): EdgeOperation;
+    static removeOutboundEdge<T extends Ent>(builder: Builder<T>, edgeType: string, id2: ID, options?: AssocEdgeInputOptions): EdgeOperation;
 }
 export declare class ConditionalOperation<T extends Ent = Ent> implements DataOperation<T> {
     protected op: DataOperation<T>;

package/action/operations.js

@@ -311,9 +311,8 @@ class EdgeOperation {
         let transformed = null;
         let op = schema_1.SQLStatementOperation.Delete;
         let updateData = null;
-        // TODO respect disableTransformations
         const transformedEdgeWrite = (0, global_schema_1.__getGlobalSchema)()?.transformEdgeWrite;
-        if (transformedEdgeWrite) {
+        if (transformedEdgeWrite && !edge.disableTransformations) {
             transformed = transformedEdgeWrite({
                 op: schema_1.SQLStatementOperation.Delete,
                 edge,
@@ -405,10 +404,9 @@ class EdgeOperation {
                 }
             }
         }
-        // TODO respect disableTransformations
         let transformed = null;
         const transformEdgeWrite = (0, global_schema_1.__getGlobalSchema)()?.transformEdgeWrite;
-        if (transformEdgeWrite) {
+        if (transformEdgeWrite && !edge.disableTransformations) {
             transformed = transformEdgeWrite({
                 op: schema_1.SQLStatementOperation.Insert,
                 edge,
@@ -471,6 +469,7 @@ class EdgeOperation {
             edgeType: this.edgeInput.edgeType,
             time: this.edgeInput.time,
             data: this.edgeInput.data,
+            disableTransformations: this.edgeInput.disableTransformations,
         }, {
             operation: this.options.operation,
             id1Placeholder: this.options.id2Placeholder,
@@ -487,6 +486,7 @@ class EdgeOperation {
             edgeType: edgeData.inverseEdgeType,
             time: this.edgeInput.time,
             data: this.edgeInput.data,
+            disableTransformations: this.edgeInput.disableTransformations,
         }, {
             operation: this.options.operation,
             id1Placeholder: this.options.id2Placeholder,
@@ -575,7 +575,7 @@ class EdgeOperation {
             dataPlaceholder,
         });
     }
-    static removeInboundEdge(builder, edgeType, id1) {
+    static removeInboundEdge(builder, edgeType, id1, options) {
         if (!builder.existingEnt) {
             throw new Error("cannot remove an edge from a non-existing ent");
         }
@@ -585,12 +585,13 @@ class EdgeOperation {
             id2: builder.existingEnt.id,
             id2Type: "",
             id1Type: "",
+            disableTransformations: options?.disableTransformations,
         };
         return new EdgeOperation(builder, edge, {
             operation: action_1.WriteOperation.Delete,
         });
     }
-    static removeOutboundEdge(builder, edgeType, id2) {
+    static removeOutboundEdge(builder, edgeType, id2, options) {
         if (!builder.existingEnt) {
             throw new Error("cannot remove an edge from a non-existing ent");
         }
@@ -600,6 +601,7 @@ class EdgeOperation {
             id1: builder.existingEnt.id,
             id2Type: "",
             id1Type: "",
+            disableTransformations: options?.disableTransformations,
         };
         return new EdgeOperation(builder, edge, {
             operation: action_1.WriteOperation.Delete,

package/action/orchestrator.d.ts

@@ -121,6 +121,11 @@ export declare class EntChangeset<T extends Ent> implements Changeset {
     constructor(viewer: Viewer, builder: Builder<T>, placeholderID: ID, conditionalOverride: boolean, operations: DataOperation[], dependencies?: Map<ID, Builder<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>, Ent<Viewer<Ent<any> | null, ID | null>> | null>> | undefined, changesets?: Changeset[] | undefined, options?: OrchestratorOptions<T, Data, Viewer<Ent<any> | null, ID | null>, MaybeNull<T>> | undefined);
     static changesetFrom(builder: Builder<any, any, any>, ops: DataOperation[]): EntChangeset<any>;
     static changesetFromQueries(builder: Builder<any, any, any>, queries: Array<string | parameterizedQueryOptions>): EntChangeset<any>;
+    private static changesetFromEdgeOp;
+    static changesetFromOutboundEdge(builder: Builder<any, any, any>, edgeType: string, id2: Builder<any> | ID, nodeType: string, options?: AssocEdgeInputOptions): Promise<EntChangeset<any>>;
+    static changesetFromInboundEdge(builder: Builder<any, any, any>, edgeType: string, id1: Builder<any> | ID, nodeType: string, options?: AssocEdgeInputOptions): Promise<EntChangeset<any>>;
+    static changesetRemoveFromOutboundEdge(builder: Builder<any, any, any>, edgeType: string, id2: ID, options?: AssocEdgeInputOptions): Promise<EntChangeset<any>>;
+    static changesetRemoveFromInboundEdge(builder: Builder<any, any, any>, edgeType: string, id1: ID, options?: AssocEdgeInputOptions): Promise<EntChangeset<any>>;
     executor(): Executor;
 }
 export {};

package/action/orchestrator.js

@@ -161,6 +161,7 @@ class Orchestrator {
             id: id1,
             edgeType,
             direction: edgeDirection.inboundEdge,
+            options,
         }), action_1.WriteOperation.Delete, options?.conditional);
     }
     removeOutboundEdge(id2, edgeType, options) {
@@ -168,6 +169,7 @@ class Orchestrator {
             id: id2,
             edgeType,
             direction: edgeDirection.outboundEdge,
+            options,
         }), action_1.WriteOperation.Delete, options?.conditional);
     }
     // this doesn't take a direction as that's an implementation detail
@@ -255,10 +257,10 @@ class Orchestrator {
             }
             let id2 = edge.id;
             if (edge.direction === edgeDirection.outboundEdge) {
-                return operations_1.EdgeOperation.removeOutboundEdge(this.options.builder, edgeType, id2);
+                return operations_1.EdgeOperation.removeOutboundEdge(this.options.builder, edgeType, id2, edge.options);
             }
             else {
-                return operations_1.EdgeOperation.removeInboundEdge(this.options.builder, edgeType, id2);
+                return operations_1.EdgeOperation.removeInboundEdge(this.options.builder, edgeType, id2, edge.options);
             }
         }
         throw new Error("could not find an edge operation from the given parameters");
@@ -288,6 +290,8 @@ class Orchestrator {
                         if (!edgeData) {
                             throw new Error(`could not load edge data for '${edgeType}'`);
                         }
+                        // similar logic in EntChangeset.changesetFromEdgeOp
+                        // doesn't support conditional edges
                         if (edgeData.symmetricEdge) {
                             let symmetric = edgeOp.symmetricEdge();
                             if (conditional) {
@@ -941,9 +945,37 @@ class EntChangeset {
         `$ent.idPlaceholderID$ ${randomNum()}-${builder.ent.name}`, false, ops);
     }
     static changesetFromQueries(builder, queries) {
-        return new EntChangeset(builder.viewer, builder, 
-        // need unique placeholderID different from the builder. see comment above EntChangeset
-        `$ent.idPlaceholderID$ ${randomNum()}-${builder.ent.name}`, false, [new operations_2.RawQueryOperation(builder, queries)]);
+        return EntChangeset.changesetFrom(builder, [
+            new operations_2.RawQueryOperation(builder, queries),
+        ]);
+    }
+    static async changesetFromEdgeOp(builder, op, edgeType) {
+        const edgeData = await (0, ent_1.loadEdgeData)(edgeType);
+        const ops = [op];
+        if (!edgeData) {
+            throw new Error(`could not load edge data for '${edgeType}'`);
+        }
+        // similar logic in Orchestrator.buildEdgeOps
+        // doesn't support conditional edges
+        if (edgeData.symmetricEdge) {
+            ops.push(op.symmetricEdge());
+        }
+        if (edgeData.inverseEdgeType) {
+            ops.push(op.inverseEdge(edgeData));
+        }
+        return EntChangeset.changesetFrom(builder, ops);
+    }
+    static async changesetFromOutboundEdge(builder, edgeType, id2, nodeType, options) {
+        return EntChangeset.changesetFromEdgeOp(builder, operations_1.EdgeOperation.outboundEdge(builder, edgeType, id2, nodeType, options), edgeType);
+    }
+    static async changesetFromInboundEdge(builder, edgeType, id1, nodeType, options) {
+        return EntChangeset.changesetFromEdgeOp(builder, operations_1.EdgeOperation.inboundEdge(builder, edgeType, id1, nodeType, options), edgeType);
+    }
+    static changesetRemoveFromOutboundEdge(builder, edgeType, id2, options) {
+        return EntChangeset.changesetFromEdgeOp(builder, operations_1.EdgeOperation.removeOutboundEdge(builder, edgeType, id2, options), edgeType);
+    }
+    static changesetRemoveFromInboundEdge(builder, edgeType, id1, options) {
+        return EntChangeset.changesetFromEdgeOp(builder, operations_1.EdgeOperation.removeInboundEdge(builder, edgeType, id1, options), edgeType);
     }
     executor() {
         if (this._executor) {

package/core/base.d.ts

@@ -1,5 +1,6 @@
 import * as clause from "./clause";
 import { ObjectLoaderFactory } from "./loaders";
+import { OrderBy } from "./query_impl";
 export interface Loader<K, V> {
     context?: Context;
     load(key: K): Promise<V>;
@@ -19,7 +20,8 @@ interface LoaderFactoryWithLoaderMany<T, V> extends LoaderFactory<T, V> {
 export interface ConfigurableLoaderFactory<T, V> extends LoaderFactory<T, V> {
     createConfigurableLoader(options: EdgeQueryableDataOptions, context?: Context): Loader<T, V>;
 }
-export type EdgeQueryableDataOptions = Partial<Pick<QueryableDataOptions, "limit" | "orderby" | "clause">>;
+export type EdgeQueryableDataOptions = Partial<Pick<QueryableDataOptions, "limit" | "orderby" | "clause" | "disableTransformations">>;
+export type EdgeQueryableDataOptionsConfigureLoader = Pick<EdgeQueryableDataOptions, "disableTransformations">;
 export interface PrimableLoader<K, V> extends Loader<K, V> {
     prime(d: V): void;
     primeAll?(d: V): void;
@@ -37,7 +39,7 @@ interface queryOptions {
     fields: string[];
     tableName: string;
     clause: clause.Clause;
-    orderby?: string;
+    orderby?: OrderBy;
 }
 export interface Context<TViewer extends Viewer = Viewer> {
     getViewer(): TViewer;
@@ -80,7 +82,7 @@ export interface QueryableDataOptions extends SelectBaseDataOptions, QueryDataOp
 export interface QueryDataOptions<T extends Data = Data, K = keyof T> {
     distinct?: boolean;
     clause: clause.Clause<T, K>;
-    orderby?: string;
+    orderby?: OrderBy;
     groupby?: K;
     limit?: number;
     disableTransformations?: boolean;

package/core/context.d.ts

@@ -3,6 +3,7 @@ import { Viewer, Data, Loader, LoaderWithLoadMany } from "./base";
 import { IncomingMessage, ServerResponse } from "http";
 import * as clause from "./clause";
 import { Context } from "./base";
+import { OrderBy } from "./query_impl";
 export interface RequestContext<TViewer extends Viewer = Viewer> extends Context<TViewer> {
     authViewer(viewer: TViewer): Promise<void>;
     logout(): Promise<void>;
@@ -27,6 +28,6 @@ interface queryOptions {
     fields: string[];
     tableName: string;
     clause: clause.Clause;
-    orderby?: string;
+    orderby?: OrderBy;
 }
 export {};

package/core/context.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContextCache = void 0;
 const logger_1 = require("./logger");
+const query_impl_1 = require("./query_impl");
 class ContextCache {
     constructor() {
         this.loaders = new Map();
@@ -39,7 +40,7 @@ class ContextCache {
             options.clause.instanceKey(),
         ];
         if (options.orderby) {
-            parts.push(options.orderby);
+            parts.push((0, query_impl_1.getOrderByPhrase)(options.orderby));
         }
         return parts.join(",");
     }

package/core/ent.d.ts

@@ -2,6 +2,7 @@ import { Queryer, SyncQueryer } from "./db";
 import { Viewer, Ent, ID, LoadRowsOptions, LoadRowOptions, Data, DataOptions, QueryableDataOptions, EditRowOptions, LoadEntOptions, LoadCustomEntOptions, EdgeQueryableDataOptions, Context, CreateRowOptions, QueryDataOptions, SelectCustomDataOptions } from "./base";
 import * as clause from "./clause";
 import DataLoader from "dataloader";
+import { OrderBy } from "./query_impl";
 export declare function getEntKey<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, id: ID, options: LoadEntOptions<TEnt, TViewer>): string;
 export declare function loadEnt<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, id: ID, options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt | null>;
 export declare function loadEntViaKey<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, key: any, options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt | null>;
@@ -75,7 +76,7 @@ interface GroupQueryOptions<T extends Data, K = keyof T> {
     groupColumn: K;
     fields: K[];
     values: any[];
-    orderby?: string;
+    orderby?: OrderBy;
     limit: number;
 }
 export declare function buildGroupQuery<T extends Data = Data, K = keyof T>(options: GroupQueryOptions<T, K>): [string, clause.Clause<T, K>];
@@ -126,7 +127,6 @@ interface loadEdgesOptions {
     edgeType: string;
     context?: Context;
     queryOptions?: EdgeQueryableDataOptions;
-    disableTransformations?: boolean;
 }
 interface loadCustomEdgesOptions<T extends AssocEdge> extends loadEdgesOptions {
     ctr: AssocEdgeConstructor<T>;
@@ -134,7 +134,7 @@ interface loadCustomEdgesOptions<T extends AssocEdge> extends loadEdgesOptions {
 export declare function setDefaultLimit(limit: number): void;
 export declare function getDefaultLimit(): number;
 export declare function loadEdges(options: loadEdgesOptions): Promise<AssocEdge[]>;
-export declare function getEdgeClauseAndFields(cls: clause.Clause, options: Pick<loadEdgesOptions, "disableTransformations">): {
+export declare function getEdgeClauseAndFields(cls: clause.Clause, options: Pick<loadEdgesOptions, "queryOptions">): {
     cls: clause.Clause<Data, string | number>;
     fields: string[];
 };

package/core/ent.js

@@ -33,6 +33,7 @@ const clause = __importStar(require("./clause"));
 const logger_1 = require("./logger");
 const dataloader_1 = __importDefault(require("dataloader"));
 const global_schema_1 = require("./global_schema");
+const query_impl_1 = require("./query_impl");
 // TODO kill this and createDataLoader
 class cacheMap {
     constructor(options) {
@@ -635,7 +636,7 @@ function buildQuery(options) {
         parts.push(`GROUP BY ${options.groupby}`);
     }
     if (options.orderby) {
-        parts.push(`ORDER BY ${options.orderby}`);
+        parts.push(`ORDER BY ${(0, query_impl_1.getOrderByPhrase)(options.orderby)}`);
     }
     if (options.limit) {
         parts.push(`LIMIT ${options.limit}`);
@@ -652,7 +653,7 @@ function buildGroupQuery(options) {
     }
     let orderby = "";
     if (options.orderby) {
-        orderby = `ORDER BY ${options.orderby}`;
+        orderby = `ORDER BY ${(0, query_impl_1.getOrderByPhrase)(options.orderby)}`;
     }
     // window functions work in sqlite!
     //    https://www.sqlite.org/windowfunctions.html
@@ -975,7 +976,12 @@ function defaultEdgeQueryOptions(id1, edgeType, id2) {
     }
     return {
         clause: cls,
-        orderby: "time DESC",
+        orderby: [
+            {
+                column: "time",
+                direction: "DESC",
+            },
+        ],
         limit: defaultLimit,
     };
 }
@@ -988,7 +994,7 @@ function getEdgeClauseAndFields(cls, options) {
     const transformEdgeRead = (0, global_schema_1.__getGlobalSchema)()?.transformEdgeRead;
     if (transformEdgeRead) {
         const transformClause = transformEdgeRead();
-        if (!options.disableTransformations) {
+        if (!options.queryOptions?.disableTransformations) {
             cls = clause.And(cls, transformClause);
         }
         fields = edgeFields.concat(transformClause.columns());

package/core/loaders/assoc_count_loader.d.ts

@@ -1,10 +1,11 @@
-import { ID, Context, Loader, LoaderFactory } from "../base";
+import { ID, Context, Loader, LoaderFactory, EdgeQueryableDataOptionsConfigureLoader } from "../base";
 export declare class AssocEdgeCountLoader implements Loader<ID, number> {
     private edgeType;
     context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
+    private options?;
     private loaderFn;
     private loader;
-    constructor(edgeType: string, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
+    constructor(edgeType: string, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     private getLoader;
     load(id: ID): Promise<number>;
     clearAll(): void;
@@ -15,4 +16,5 @@ export declare class AssocEdgeCountLoaderFactory implements LoaderFactory<ID, nu
     constructor(edgeType: string);
     getEdgeType(): string;
     createLoader(context?: Context): AssocEdgeCountLoader;
+    createConfigurableLoader(options: EdgeQueryableDataOptionsConfigureLoader, context?: Context): AssocEdgeCountLoader;
 }

package/core/loaders/assoc_count_loader.js

@@ -33,9 +33,10 @@ const loader_1 = require("./loader");
 const raw_count_loader_1 = require("./raw_count_loader");
 const memoizee_1 = __importDefault(require("memoizee"));
 class AssocEdgeCountLoader {
-    constructor(edgeType, context) {
+    constructor(edgeType, context, options) {
         this.edgeType = edgeType;
         this.context = context;
+        this.options = options;
         if (context) {
             this.loaderFn = (0, memoizee_1.default)(this.getLoader);
         }
@@ -45,7 +46,9 @@ class AssocEdgeCountLoader {
         if (!edgeData) {
             throw new Error(`error loading edge data for ${this.edgeType}`);
         }
-        const { cls } = (0, ent_1.getEdgeClauseAndFields)(clause.Eq("edge_type", this.edgeType), {});
+        const { cls } = (0, ent_1.getEdgeClauseAndFields)(clause.Eq("edge_type", this.edgeType), {
+            queryOptions: this.options,
+        });
         this.loader = (0, raw_count_loader_1.createCountDataLoader)({
             tableName: edgeData.edgeTable,
             groupCol: "id1",
@@ -58,6 +61,7 @@ class AssocEdgeCountLoader {
             return (0, ent_1.loadRawEdgeCountX)({
                 id1: id,
                 edgeType: this.edgeType,
+                queryOptions: this.options,
             });
         }
         const loader = await this.loaderFn();
@@ -79,5 +83,9 @@ class AssocEdgeCountLoaderFactory {
     createLoader(context) {
         return (0, loader_1.getLoader)(this, () => new AssocEdgeCountLoader(this.edgeType, context), context);
     }
+    createConfigurableLoader(options, context) {
+        const key = `${this.name}:disableTransformations:${options.disableTransformations}`;
+        return (0, loader_1.getCustomLoader)(key, () => new AssocEdgeCountLoader(this.edgeType, context, options), context);
+    }
 }
 exports.AssocEdgeCountLoaderFactory = AssocEdgeCountLoaderFactory;

package/core/loaders/assoc_edge_loader.d.ts

@@ -1,6 +1,6 @@
 import { Context, ID, EdgeQueryableDataOptions, Loader, LoaderFactory } from "../base";
 import { AssocEdge, AssocEdgeConstructor } from "../ent";
-interface AssocLoader<T extends AssocEdge> extends Loader<ID, T[]> {
+export interface AssocLoader<T extends AssocEdge> extends Loader<ID, T[]> {
     loadEdgeForID2(id: ID, id2: ID): Promise<T | undefined>;
 }
 export declare class AssocEdgeLoader<T extends AssocEdge> implements Loader<ID, T[]> {
@@ -21,7 +21,7 @@ export declare class AssocDirectEdgeLoader<T extends AssocEdge> implements Loade
     private edgeCtr;
     private options?;
     context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
-    constructor(edgeType: string, edgeCtr: AssocEdgeConstructor<T>, options?: Partial<Pick<import("../base").QueryableDataOptions, "clause" | "limit" | "orderby">> | undefined, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
+    constructor(edgeType: string, edgeCtr: AssocEdgeConstructor<T>, options?: Partial<Pick<import("../base").QueryableDataOptions, "clause" | "limit" | "orderby" | "disableTransformations">> | undefined, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
     load(id: ID): Promise<T[]>;
     loadEdgeForID2(id: ID, id2: ID): Promise<T | undefined>;
     clearAll(): void;
@@ -35,4 +35,3 @@ export declare class AssocEdgeLoaderFactory<T extends AssocEdge> implements Load
     private isConstructor;
     createConfigurableLoader(options: EdgeQueryableDataOptions, context?: Context): AssocLoader<T>;
 }
-export {};

package/core/loaders/assoc_edge_loader.js

@@ -59,11 +59,18 @@ function createLoader(options, edgeType, edgeCtr, edgeData) {
             // store the index....
             m.set(keys[i], i);
         }
-        options.orderby = options.orderby || "time DESC";
+        options.orderby = options.orderby || [
+            {
+                column: "time",
+                direction: "DESC",
+            },
+        ];
         // TODO defaultEdgeQueryOptions
         options.limit = options.limit || (0, ent_1.getDefaultLimit)();
         const tableName = edgeData.edgeTable;
-        const { cls: cls1, fields } = (0, ent_1.getEdgeClauseAndFields)(clause.Eq("edge_type", edgeType), {});
+        const { cls: cls1, fields } = (0, ent_1.getEdgeClauseAndFields)(clause.Eq("edge_type", edgeType), {
+            queryOptions: options,
+        });
         const [query, cls] = (0, ent_1.buildGroupQuery)({
             tableName: tableName,
             fields,
@@ -114,6 +121,7 @@ class AssocEdgeLoader {
             id2,
             context: this.context,
             ctr: this.edgeCtr,
+            queryOptions: this.options,
         });
     }
     clearAll() {
@@ -129,7 +137,7 @@ class AssocDirectEdgeLoader {
         this.context = context;
     }
     async load(id) {
-        return await (0, ent_1.loadCustomEdges)({
+        return (0, ent_1.loadCustomEdges)({
             id1: id,
             edgeType: this.edgeType,
             context: this.context,
@@ -137,12 +145,14 @@ class AssocDirectEdgeLoader {
             ctr: this.edgeCtr,
         });
     }
+    // TODO should this have a disableTransformations flag to get these rows
     async loadEdgeForID2(id, id2) {
         return (0, ent_1.loadEdgeForID2)({
             id1: id,
             edgeType: this.edgeType,
             id2,
             context: this.context,
+            queryOptions: this.options,
             ctr: this.edgeCtr,
         });
     }
@@ -181,7 +191,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}`;
+        const key = `${this.name}:limit:${options.limit}:orderby:${options.orderby}:disableTransformations:${options.disableTransformations}`;
         return (0, loader_1.getCustomLoader)(key, () => new AssocEdgeLoader(this.edgeType, ctr, options, context), context);
     }
 }

package/core/loaders/index_loader.d.ts

@@ -1,12 +1,13 @@
 import { ID, SelectBaseDataOptions, Context, Data, LoaderFactory, EdgeQueryableDataOptions, Loader } from "../base";
 import * as clause from "../clause";
+import { OrderBy } from "../query_impl";
 import { ObjectLoaderFactory } from "./object_loader";
 export declare class IndexLoaderFactory implements LoaderFactory<ID, Data[]> {
     name: string;
     private factory;
     constructor(options: SelectBaseDataOptions, col: string, opts?: {
         extraClause?: clause.Clause;
-        sortColumn?: string;
+        orderby?: OrderBy;
         toPrime?: ObjectLoaderFactory<Data>[];
     });
     createLoader(context?: Context): any;

package/core/loaders/index_loader.js

@@ -12,7 +12,7 @@ class IndexLoaderFactory {
             tableName: options.tableName,
             groupCol: col,
             clause: opts?.extraClause,
-            sortColumn: opts?.sortColumn,
+            orderby: opts?.orderby,
             toPrime: opts?.toPrime,
         });
         this.name = `indexLoader:${options.tableName}:${col}`;

package/core/loaders/query_loader.d.ts

@@ -1,14 +1,14 @@
 import { Context, ID, EdgeQueryableDataOptions, Loader, LoaderFactory, Data } from "../base";
 import * as clause from "../clause";
 import { ObjectLoaderFactory } from "./object_loader";
-export declare function getOrderBy(sortCol: string, orderby?: string): string;
+import { OrderBy } from "../query_impl";
 declare class QueryDirectLoader<K extends any> implements Loader<K, Data[]> {
     private options;
     private queryOptions?;
     context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
     private memoizedInitPrime;
     private primedLoaders;
-    constructor(options: QueryOptions, queryOptions?: Partial<Pick<import("../base").QueryableDataOptions, "clause" | "limit" | "orderby">> | undefined, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
+    constructor(options: QueryOptions, queryOptions?: Partial<Pick<import("../base").QueryableDataOptions, "clause" | "limit" | "orderby" | "disableTransformations">> | undefined, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
     private initPrime;
     load(id: K): Promise<Data[]>;
     clearAll(): void;
@@ -18,7 +18,7 @@ interface QueryOptions {
     tableName: string;
     groupCol?: string;
     clause?: clause.Clause;
-    sortColumn?: string;
+    orderby?: OrderBy;
     toPrime?: ObjectLoaderFactory<Data>[];
 }
 export declare class QueryLoaderFactory<K extends any> implements LoaderFactory<K, Data[]> {

package/core/loaders/query_loader.js

@@ -26,25 +26,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryLoaderFactory = exports.getOrderBy = void 0;
+exports.QueryLoaderFactory = void 0;
 const dataloader_1 = __importDefault(require("dataloader"));
 const ent_1 = require("../ent");
 const clause = __importStar(require("../clause"));
 const logger_1 = require("../logger");
 const loader_1 = require("./loader");
 const memoizee_1 = __importDefault(require("memoizee"));
-function getOrderBy(sortCol, orderby) {
-    if (orderby) {
-        return orderby;
-    }
-    let sortColLower = sortCol.toLowerCase();
-    let orderbyDirection = " DESC";
-    if (sortColLower.endsWith("asc") || sortCol.endsWith("desc")) {
-        orderbyDirection = "";
-    }
-    return `${sortCol}${orderbyDirection}`;
+function getOrderByLocal(options, queryOptions) {
+    return (options.orderby ??
+        queryOptions?.orderby ?? [
+        {
+            column: "created_at",
+            direction: "DESC",
+        },
+    ]);
 }
-exports.getOrderBy = getOrderBy;
 async function simpleCase(options, id, queryOptions) {
     let cls;
     if (options.groupCol) {
@@ -62,16 +59,14 @@ async function simpleCase(options, id, queryOptions) {
     if (queryOptions?.clause) {
         cls = clause.And(cls, queryOptions.clause);
     }
-    let sortCol = options.sortColumn || "created_at";
     return await (0, ent_1.loadRows)({
         ...options,
         clause: cls,
-        orderby: getOrderBy(sortCol, queryOptions?.orderby),
+        orderby: getOrderByLocal(options, queryOptions),
         limit: queryOptions?.limit || (0, ent_1.getDefaultLimit)(),
     });
 }
 function createLoader(options, queryOptions) {
-    let sortCol = options.sortColumn || "created_at";
     const loaderOptions = {};
     // if query logging is enabled, we should log what's happening with loader
     if ((0, logger_1.logEnabled)("query")) {
@@ -109,7 +104,7 @@ function createLoader(options, queryOptions) {
             tableName: options.tableName,
             fields: options.fields,
             values: keys,
-            orderby: getOrderBy(sortCol, queryOptions?.orderby),
+            orderby: getOrderByLocal(options, queryOptions),
             limit: queryOptions?.limit || (0, ent_1.getDefaultLimit)(),
             groupColumn: col,
             clause: extraClause,