@snowtop/ent 0.1.0-alpha16 → 0.1.0-alpha160-test1

package/core/privacy.d.ts

@@ -1,4 +1,4 @@
-import { Ent, ID, LoadEntOptions, PrivacyError, PrivacyPolicy, PrivacyPolicyRule, PrivacyResult, Viewer } from "./base";
+import { Ent, ID, LoadEntOptions, PrivacyError, PrivacyPolicy, PrivacyPolicyRule, PrivacyResult, Viewer, EdgeQueryableDataOptionsConfigureLoader } from "./base";
 export declare class EntPrivacyError extends Error implements PrivacyError {
     privacyPolicy: PrivacyPolicy;
     privacyRule: PrivacyPolicyRule;
@@ -6,22 +6,22 @@ export declare class EntPrivacyError extends Error implements PrivacyError {
     constructor(privacyPolicy: PrivacyPolicy, rule: PrivacyPolicyRule, ent?: Ent);
 }
 export declare const AlwaysAllowRule: {
-    apply(_v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
+    apply(_v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
 };
 export declare const AlwaysDenyRule: {
-    apply(_v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
+    apply(_v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
 };
 export declare const DenyIfLoggedOutRule: {
-    apply(v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
 };
 export declare const DenyIfLoggedInRule: {
-    apply(v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
 };
 export declare const AllowIfHasIdentity: {
-    apply(v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
 };
 export declare const AllowIfViewerRule: {
-    apply(v: Viewer, ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 };
 export declare class AllowIfViewerEqualsRule {
     private id;
@@ -115,51 +115,60 @@ export declare class AllowIfEdgeExistsRule implements PrivacyPolicyRule {
     private id1;
     private id2;
     private edgeType;
-    constructor(id1: ID, id2: ID, edgeType: string);
+    private options?;
+    constructor(id1: ID, id2: ID, edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class AllowIfViewerInboundEdgeExistsRule implements PrivacyPolicyRule {
     private edgeType;
-    constructor(edgeType: string);
+    private options?;
+    constructor(edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class AllowIfViewerOutboundEdgeExistsRule implements PrivacyPolicyRule {
     private edgeType;
-    constructor(edgeType: string);
+    private options?;
+    constructor(edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class DenyIfEdgeExistsRule implements PrivacyPolicyRule {
     private id1;
     private id2;
     private edgeType;
-    constructor(id1: ID, id2: ID, edgeType: string);
+    private options?;
+    constructor(id1: ID, id2: ID, edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class DenyIfViewerInboundEdgeExistsRule implements PrivacyPolicyRule {
     private edgeType;
-    constructor(edgeType: string);
+    private options?;
+    constructor(edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class DenyIfViewerOutboundEdgeExistsRule implements PrivacyPolicyRule {
     private edgeType;
-    constructor(edgeType: string);
+    private options?;
+    constructor(edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class DenyIfEdgeDoesNotExistRule implements PrivacyPolicyRule {
     private id1;
     private id2;
     private edgeType;
-    constructor(id1: ID, id2: ID, edgeType: string);
+    private options?;
+    constructor(id1: ID, id2: ID, edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class DenyIfViewerInboundEdgeDoesNotExistRule implements PrivacyPolicyRule {
     private edgeType;
-    constructor(edgeType: string);
+    private options?;
+    constructor(edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class DenyIfViewerOutboundEdgeDoesNotExistRule implements PrivacyPolicyRule {
     private edgeType;
-    constructor(edgeType: string);
+    private options?;
+    constructor(edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class AllowIfConditionAppliesRule implements PrivacyPolicyRule {
@@ -183,6 +192,7 @@ export declare class AllowIfSubPolicyAllowsRule implements PrivacyPolicyRule {
 }
 export declare function applyPrivacyPolicy(v: Viewer, policy: PrivacyPolicy, ent: Ent | undefined): Promise<boolean>;
 export declare function applyPrivacyPolicyX(v: Viewer, policy: PrivacyPolicy, ent: Ent | undefined, throwErr?: () => Error): Promise<boolean>;
+export declare function applyPrivacyPolicyImpl(v: Viewer, policy: PrivacyPolicy, ent: Ent | undefined, throwErr?: () => Error): Promise<Error | null>;
 export declare const AlwaysAllowPrivacyPolicy: PrivacyPolicy;
 export declare const AlwaysDenyPrivacyPolicy: PrivacyPolicy;
 export declare const AllowIfViewerPrivacyPolicy: PrivacyPolicy;

package/core/privacy.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AllowIfViewerHasIdentityPrivacyPolicy = exports.AllowIfViewerPrivacyPolicy = exports.AlwaysDenyPrivacyPolicy = exports.AlwaysAllowPrivacyPolicy = exports.applyPrivacyPolicyX = exports.applyPrivacyPolicy = exports.AllowIfSubPolicyAllowsRule = exports.DelayedResultRule = exports.AllowIfConditionAppliesRule = exports.DenyIfViewerOutboundEdgeDoesNotExistRule = exports.DenyIfViewerInboundEdgeDoesNotExistRule = exports.DenyIfEdgeDoesNotExistRule = exports.DenyIfViewerOutboundEdgeExistsRule = exports.DenyIfViewerInboundEdgeExistsRule = exports.DenyIfEdgeExistsRule = exports.AllowIfViewerOutboundEdgeExistsRule = exports.AllowIfViewerInboundEdgeExistsRule = exports.AllowIfEdgeExistsRule = exports.DenyIfEntIsNotVisibleRule = exports.DenyIfEntIsVisibleRule = exports.DenyIfEntIsVisiblePolicy = exports.AllowIfEntIsVisiblePolicy = exports.AllowIfEntIsNotVisibleRule = exports.AllowIfEntIsVisibleRule = exports.DenyIfEntPropertyIsRule = exports.AllowIfEntPropertyIsRule = exports.AllowIfViewerIsEntPropertyRule = exports.AllowIfViewerIsRule = exports.DenyIfFuncRule = exports.AllowIfFuncRule = exports.DenyIfViewerEqualsRule = exports.AllowIfViewerEqualsRule = exports.AllowIfViewerRule = exports.AllowIfHasIdentity = exports.DenyIfLoggedInRule = exports.DenyIfLoggedOutRule = exports.AlwaysDenyRule = exports.AlwaysAllowRule = exports.EntPrivacyError = void 0;
+exports.AllowIfViewerHasIdentityPrivacyPolicy = exports.AllowIfViewerPrivacyPolicy = exports.AlwaysDenyPrivacyPolicy = exports.AlwaysAllowPrivacyPolicy = exports.applyPrivacyPolicyImpl = exports.applyPrivacyPolicyX = exports.applyPrivacyPolicy = exports.AllowIfSubPolicyAllowsRule = exports.DelayedResultRule = exports.AllowIfConditionAppliesRule = exports.DenyIfViewerOutboundEdgeDoesNotExistRule = exports.DenyIfViewerInboundEdgeDoesNotExistRule = exports.DenyIfEdgeDoesNotExistRule = exports.DenyIfViewerOutboundEdgeExistsRule = exports.DenyIfViewerInboundEdgeExistsRule = exports.DenyIfEdgeExistsRule = exports.AllowIfViewerOutboundEdgeExistsRule = exports.AllowIfViewerInboundEdgeExistsRule = exports.AllowIfEdgeExistsRule = exports.DenyIfEntIsNotVisibleRule = exports.DenyIfEntIsVisibleRule = exports.DenyIfEntIsVisiblePolicy = exports.AllowIfEntIsVisiblePolicy = exports.AllowIfEntIsNotVisibleRule = exports.AllowIfEntIsVisibleRule = exports.DenyIfEntPropertyIsRule = exports.AllowIfEntPropertyIsRule = exports.AllowIfViewerIsEntPropertyRule = exports.AllowIfViewerIsRule = exports.DenyIfFuncRule = exports.AllowIfFuncRule = exports.DenyIfViewerEqualsRule = exports.AllowIfViewerEqualsRule = exports.AllowIfViewerRule = exports.AllowIfHasIdentity = exports.DenyIfLoggedInRule = exports.DenyIfLoggedOutRule = exports.AlwaysDenyRule = exports.AlwaysAllowRule = exports.EntPrivacyError = void 0;
+const types_1 = require("util/types");
 const base_1 = require("./base");
 const ent_1 = require("./ent");
-const logger_1 = require("./logger");
 // copied from ./base
 var privacyResult;
 (function (privacyResult) {
@@ -103,7 +103,10 @@ class AllowIfFuncRule {
         this.fn = fn;
     }
     async apply(v, ent) {
-        const result = await this.fn(v, ent);
+        let result = this.fn(v, ent);
+        if ((0, types_1.isPromise)(result)) {
+            result = await result;
+        }
         if (result) {
             return (0, base_1.Allow)();
         }
@@ -116,7 +119,10 @@ class DenyIfFuncRule {
         this.fn = fn;
     }
     async apply(v, ent) {
-        const result = await this.fn(v, ent);
+        let result = this.fn(v, ent);
+        if ((0, types_1.isPromise)(result)) {
+            result = await result;
+        }
         if (result) {
             return (0, base_1.Deny)();
         }
@@ -256,7 +262,7 @@ class DenyIfEntIsNotVisibleRule {
     }
 }
 exports.DenyIfEntIsNotVisibleRule = DenyIfEntIsNotVisibleRule;
-async function allowIfEdgeExistsRule(id1, id2, edgeType, context) {
+async function allowIfEdgeExistsRule(id1, id2, edgeType, context, options) {
     if (id1 && id2) {
         const edge = await (0, ent_1.loadEdgeForID2)({
             id1,
@@ -264,6 +270,7 @@ async function allowIfEdgeExistsRule(id1, id2, edgeType, context) {
             id2,
             context,
             ctr: ent_1.AssocEdge,
+            queryOptions: options,
         });
         if (edge) {
             return (0, base_1.Allow)();
@@ -272,35 +279,38 @@ async function allowIfEdgeExistsRule(id1, id2, edgeType, context) {
     return (0, base_1.Skip)();
 }
 class AllowIfEdgeExistsRule {
-    constructor(id1, id2, edgeType) {
+    constructor(id1, id2, edgeType, options) {
         this.id1 = id1;
         this.id2 = id2;
         this.edgeType = edgeType;
+        this.options = options;
     }
     async apply(v, _ent) {
-        return allowIfEdgeExistsRule(this.id1, this.id2, this.edgeType, v.context);
+        return allowIfEdgeExistsRule(this.id1, this.id2, this.edgeType, v.context, this.options);
     }
 }
 exports.AllowIfEdgeExistsRule = AllowIfEdgeExistsRule;
 class AllowIfViewerInboundEdgeExistsRule {
-    constructor(edgeType) {
+    constructor(edgeType, options) {
         this.edgeType = edgeType;
+        this.options = options;
     }
     async apply(v, ent) {
-        return allowIfEdgeExistsRule(v.viewerID, ent?.id, this.edgeType, v.context);
+        return allowIfEdgeExistsRule(v.viewerID, ent?.id, this.edgeType, v.context, this.options);
     }
 }
 exports.AllowIfViewerInboundEdgeExistsRule = AllowIfViewerInboundEdgeExistsRule;
 class AllowIfViewerOutboundEdgeExistsRule {
-    constructor(edgeType) {
+    constructor(edgeType, options) {
         this.edgeType = edgeType;
+        this.options = options;
     }
     async apply(v, ent) {
-        return allowIfEdgeExistsRule(ent?.id, v.viewerID, this.edgeType, v.context);
+        return allowIfEdgeExistsRule(ent?.id, v.viewerID, this.edgeType, v.context, this.options);
     }
 }
 exports.AllowIfViewerOutboundEdgeExistsRule = AllowIfViewerOutboundEdgeExistsRule;
-async function denyIfEdgeExistsRule(id1, id2, edgeType, context) {
+async function denyIfEdgeExistsRule(id1, id2, edgeType, context, options) {
     // edge doesn't exist if no viewer
     if (id1 && id2) {
         const edge = await (0, ent_1.loadEdgeForID2)({
@@ -309,6 +319,7 @@ async function denyIfEdgeExistsRule(id1, id2, edgeType, context) {
             id2,
             context,
             ctr: ent_1.AssocEdge,
+            queryOptions: options,
         });
         if (edge) {
             return (0, base_1.Deny)();
@@ -316,7 +327,7 @@ async function denyIfEdgeExistsRule(id1, id2, edgeType, context) {
     }
     return (0, base_1.Skip)();
 }
-async function denyIfEdgeDoesNotExistRule(id1, id2, edgeType, context) {
+async function denyIfEdgeDoesNotExistRule(id1, id2, edgeType, context, options) {
     // edge doesn't exist if no viewer
     if (!id1 || !id2) {
         return (0, base_1.Deny)();
@@ -327,6 +338,7 @@ async function denyIfEdgeDoesNotExistRule(id1, id2, edgeType, context) {
         id2,
         context,
         ctr: ent_1.AssocEdge,
+        queryOptions: options,
     });
     if (!edge) {
         return (0, base_1.Deny)();
@@ -334,60 +346,66 @@ async function denyIfEdgeDoesNotExistRule(id1, id2, edgeType, context) {
     return (0, base_1.Skip)();
 }
 class DenyIfEdgeExistsRule {
-    constructor(id1, id2, edgeType) {
+    constructor(id1, id2, edgeType, options) {
         this.id1 = id1;
         this.id2 = id2;
         this.edgeType = edgeType;
+        this.options = options;
     }
     async apply(v, _ent) {
-        return denyIfEdgeExistsRule(this.id1, this.id2, this.edgeType, v.context);
+        return denyIfEdgeExistsRule(this.id1, this.id2, this.edgeType, v.context, this.options);
     }
 }
 exports.DenyIfEdgeExistsRule = DenyIfEdgeExistsRule;
 class DenyIfViewerInboundEdgeExistsRule {
-    constructor(edgeType) {
+    constructor(edgeType, options) {
         this.edgeType = edgeType;
+        this.options = options;
     }
     async apply(v, ent) {
-        return denyIfEdgeExistsRule(v.viewerID, ent?.id, this.edgeType, v.context);
+        return denyIfEdgeExistsRule(v.viewerID, ent?.id, this.edgeType, v.context, this.options);
     }
 }
 exports.DenyIfViewerInboundEdgeExistsRule = DenyIfViewerInboundEdgeExistsRule;
 class DenyIfViewerOutboundEdgeExistsRule {
-    constructor(edgeType) {
+    constructor(edgeType, options) {
         this.edgeType = edgeType;
+        this.options = options;
     }
     async apply(v, ent) {
-        return denyIfEdgeExistsRule(ent?.id, v.viewerID, this.edgeType, v.context);
+        return denyIfEdgeExistsRule(ent?.id, v.viewerID, this.edgeType, v.context, this.options);
     }
 }
 exports.DenyIfViewerOutboundEdgeExistsRule = DenyIfViewerOutboundEdgeExistsRule;
 class DenyIfEdgeDoesNotExistRule {
-    constructor(id1, id2, edgeType) {
+    constructor(id1, id2, edgeType, options) {
         this.id1 = id1;
         this.id2 = id2;
         this.edgeType = edgeType;
+        this.options = options;
     }
     async apply(v, _ent) {
-        return denyIfEdgeDoesNotExistRule(this.id1, this.id2, this.edgeType, v.context);
+        return denyIfEdgeDoesNotExistRule(this.id1, this.id2, this.edgeType, v.context, this.options);
     }
 }
 exports.DenyIfEdgeDoesNotExistRule = DenyIfEdgeDoesNotExistRule;
 class DenyIfViewerInboundEdgeDoesNotExistRule {
-    constructor(edgeType) {
+    constructor(edgeType, options) {
         this.edgeType = edgeType;
+        this.options = options;
     }
     async apply(v, ent) {
-        return denyIfEdgeDoesNotExistRule(v.viewerID, ent?.id, this.edgeType, v.context);
+        return denyIfEdgeDoesNotExistRule(v.viewerID, ent?.id, this.edgeType, v.context, this.options);
     }
 }
 exports.DenyIfViewerInboundEdgeDoesNotExistRule = DenyIfViewerInboundEdgeDoesNotExistRule;
 class DenyIfViewerOutboundEdgeDoesNotExistRule {
-    constructor(edgeType) {
+    constructor(edgeType, options) {
         this.edgeType = edgeType;
+        this.options = options;
     }
     async apply(v, ent) {
-        return denyIfEdgeDoesNotExistRule(ent?.id, v.viewerID, this.edgeType, v.context);
+        return denyIfEdgeDoesNotExistRule(ent?.id, v.viewerID, this.edgeType, v.context, this.options);
     }
 }
 exports.DenyIfViewerOutboundEdgeDoesNotExistRule = DenyIfViewerOutboundEdgeDoesNotExistRule;
@@ -413,12 +431,14 @@ class DelayedResultRule {
         this.fn = fn;
     }
     async apply(v, ent) {
-        const rule = await this.fn(v, ent);
+        let rule = this.fn(v, ent);
+        if ((0, types_1.isPromise)(rule)) {
+            rule = await rule;
+        }
         if (!rule) {
             return (0, base_1.Skip)();
         }
-        const res = await rule.apply(v, ent);
-        return res;
+        return rule.apply(v, ent);
     }
 }
 exports.DelayedResultRule = DelayedResultRule;
@@ -437,45 +457,42 @@ class AllowIfSubPolicyAllowsRule {
 }
 exports.AllowIfSubPolicyAllowsRule = AllowIfSubPolicyAllowsRule;
 async function applyPrivacyPolicy(v, policy, ent) {
-    try {
-        return await applyPrivacyPolicyX(v, policy, ent);
-    }
-    catch (e) {
-        // TODO privacy errors should not throw
-        // but other expected errors should throw...
-        // we shouldn't just hide them
-        (0, logger_1.log)("debug", e);
-        return false;
-    }
+    const err = await applyPrivacyPolicyImpl(v, policy, ent);
+    return err === null;
 }
 exports.applyPrivacyPolicy = applyPrivacyPolicy;
-// this will throw an exception if fails or return error | null?
 async function applyPrivacyPolicyX(v, policy, ent, throwErr) {
-    // right now we apply all at same time. todo: be smart about this in the future
-    const results = await Promise.all(policy.rules.map((rule) => rule.apply(v, ent)));
-    for (let i = 0; i < results.length; i++) {
-        const res = results[i];
-        const rule = policy.rules[i];
+    const err = await applyPrivacyPolicyImpl(v, policy, ent, throwErr);
+    if (err !== null) {
+        throw err;
+    }
+    return true;
+}
+exports.applyPrivacyPolicyX = applyPrivacyPolicyX;
+// this will throw an exception if fails or return error | null?
+async function applyPrivacyPolicyImpl(v, policy, ent, throwErr) {
+    for (const rule of policy.rules) {
+        const res = await rule.apply(v, ent);
         if (res.result == privacyResult.Allow) {
-            return true;
+            return null;
         }
         else if (res.result == privacyResult.Deny) {
             // specific error throw that
             if (res.error) {
-                throw res.error;
+                return res.error;
             }
             if (res.getError) {
-                throw res.getError(policy, rule, ent);
+                return res.getError(policy, rule, ent);
             }
             if (throwErr) {
-                throw throwErr();
+                return throwErr();
             }
-            throw new EntPrivacyError(policy, rule, ent);
+            return new EntPrivacyError(policy, rule, ent);
         }
     }
-    throw new EntInvalidPrivacyPolicyError(policy, ent);
+    return new EntInvalidPrivacyPolicyError(policy, ent);
 }
-exports.applyPrivacyPolicyX = applyPrivacyPolicyX;
+exports.applyPrivacyPolicyImpl = applyPrivacyPolicyImpl;
 exports.AlwaysAllowPrivacyPolicy = {
     rules: [exports.AlwaysAllowRule],
 };

package/core/query/assoc_query.d.ts

@@ -3,8 +3,8 @@ import { AssocEdge } from "../ent";
 import { AssocEdgeCountLoaderFactory } from "../loaders/assoc_count_loader";
 import { AssocEdgeLoaderFactory } from "../loaders/assoc_edge_loader";
 import { EdgeQuery, BaseEdgeQuery, IDInfo } from "./query";
-export declare type EdgeQuerySource<TSource extends Ent<TViewer>, TDest extends Ent<TViewer> = Ent<any>, TViewer extends Viewer = Viewer> = TSource | TSource[] | ID | ID[] | EdgeQuery<TDest, Ent, AssocEdge>;
-declare type loaderOptionsFunc<TViewer extends Viewer> = (type: string) => LoadEntOptions<Ent, TViewer>;
+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> {
     viewer: TViewer;
     src: EdgeQuerySource<TSource, TDest, TViewer>;
@@ -14,6 +14,7 @@ export declare abstract class AssocEdgeQueryBase<TSource extends Ent<TViewer>, T
     constructor(viewer: TViewer, src: EdgeQuerySource<TSource, TDest, TViewer>, countLoaderFactory: AssocEdgeCountLoaderFactory, dataLoaderFactory: AssocEdgeLoaderFactory<TEdge>, options: LoadEntOptions<TDest, TViewer> | loaderOptionsFunc<TViewer>);
     private isEdgeQuery;
     abstract sourceEnt(id: ID): Promise<Ent | null>;
+    getTableName(): Promise<string>;
     private getSingleID;
     queryRawCount(): Promise<number>;
     queryAllRawCount(): Promise<Map<ID, number>>;

package/core/query/assoc_query.js

@@ -3,12 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssocEdgeQueryBase = void 0;
 const ent_1 = require("../ent");
 const query_1 = require("./query");
+// 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");
+        super(viewer, "time", "id2");
         this.viewer = viewer;
         this.src = src;
         this.countLoaderFactory = countLoaderFactory;
@@ -21,6 +22,13 @@ class AssocEdgeQueryBase extends query_1.BaseEdgeQuery {
         }
         return false;
     }
+    async getTableName() {
+        const edgeData = await (0, ent_1.loadEdgeData)(this.countLoaderFactory.getEdgeType());
+        if (!edgeData) {
+            throw new Error(`couldn't load edgeData`);
+        }
+        return edgeData.edgeTable;
+    }
     async getSingleID() {
         const infos = await this.genIDInfosToFetch();
         if (infos.length !== 1) {
@@ -35,7 +43,7 @@ class AssocEdgeQueryBase extends query_1.BaseEdgeQuery {
             return 0;
         }
         return this.countLoaderFactory
-            .createLoader(this.viewer.context)
+            .createConfigurableLoader(this.getDefaultEdgeQueryOptions() ?? {}, this.viewer.context)
             .load(info.id);
     }
     async queryAllRawCount() {

package/core/query/custom_clause_query.d.ts

@@ -0,0 +1,29 @@
+import { Data, EdgeQueryableDataOptions, Ent, ID, LoadEntOptions, Viewer } from "../base";
+import { Clause } from "../clause";
+import { OrderBy } from "../query_impl";
+import { BaseEdgeQuery, IDInfo } from "./query";
+export interface CustomClauseQueryOptions<TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
+    loadEntOptions: LoadEntOptions<TDest, TViewer>;
+    clause: Clause;
+    name: string;
+    primarySortColIsUnique?: boolean;
+    orderby?: OrderBy;
+    sortColumn?: string;
+    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> {
+    viewer: TViewer;
+    private options;
+    private clause;
+    constructor(viewer: TViewer, options: CustomClauseQueryOptions<TDest, TViewer>);
+    sourceEnt(_id: ID): Promise<null>;
+    getTableName(): string;
+    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[]>;
+}

package/core/query/custom_clause_query.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomClauseQuery = void 0;
+const clause_1 = require("../clause");
+const ent_1 = require("../ent");
+const query_1 = require("./query");
+function getClause(opts) {
+    let cls = opts.clause;
+    if (opts.disableTransformations) {
+        return cls;
+    }
+    let optClause = opts.loadEntOptions.loaderFactory?.options?.clause;
+    if (typeof optClause === "function") {
+        optClause = optClause();
+    }
+    if (!optClause) {
+        return cls;
+    }
+    return (0, clause_1.AndOptional)(cls, optClause);
+}
+class CustomClauseQuery extends query_1.BaseEdgeQuery {
+    constructor(viewer, options) {
+        let orderby;
+        let primarySortCol;
+        if (options.orderby &&
+            (options.sortColumn || options.orderByDirection || options.nullsPlacement)) {
+            throw new Error(`cannot pass orderby and sortColumn|orderByDirection|nullsPlacement`);
+        }
+        if (options.orderby) {
+            primarySortCol = options.orderby[0].column;
+            orderby = options.orderby;
+        }
+        else {
+            primarySortCol = options.sortColumn || "id";
+            orderby = [
+                {
+                    column: primarySortCol,
+                    direction: options.orderByDirection ?? "DESC",
+                    nullsPlacement: options.nullsPlacement,
+                },
+            ];
+        }
+        let cursorCol = options.primarySortColIsUnique
+            ? primarySortCol
+            : options.loadEntOptions.loaderFactory.options?.key || "id";
+        super(viewer, {
+            orderby,
+            cursorCol,
+        });
+        this.viewer = viewer;
+        this.options = options;
+        this.clause = getClause(options);
+    }
+    async sourceEnt(_id) {
+        return null;
+    }
+    getTableName() {
+        return this.options.loadEntOptions.tableName;
+    }
+    async queryRawCount() {
+        const row = await (0, ent_1.loadRow)({
+            tableName: this.options.loadEntOptions.tableName,
+            // sqlite needs as count otherwise it returns count(1)
+            fields: ["count(1) as count"],
+            clause: this.clause,
+            context: this.viewer.context,
+        });
+        return parseInt(row?.count, 10) || 0;
+    }
+    async queryAllRawCount() {
+        throw new Error(`queryAllRawCount doesn't make sense in CustomClauseQuery`);
+    }
+    // nothing to do here
+    async loadRawIDs(_addID) { }
+    async loadRawData(_infos, options) {
+        if (!options.orderby) {
+            options.orderby = [
+                {
+                    column: this.getSortCol(),
+                    direction: this.options.orderByDirection ?? "DESC",
+                    nullsPlacement: this.options.nullsPlacement,
+                },
+            ];
+        }
+        if (!options.limit) {
+            options.limit = (0, ent_1.getDefaultLimit)();
+        }
+        const rows = await (0, ent_1.loadRows)({
+            tableName: this.options.loadEntOptions.tableName,
+            fields: this.options.loadEntOptions.fields,
+            clause: (0, clause_1.AndOptional)(this.clause, options.clause),
+            orderby: options.orderby,
+            limit: options?.limit || (0, ent_1.getDefaultLimit)(),
+            context: this.viewer.context,
+        });
+        this.edges.set(1, rows);
+    }
+    dataToID(edge) {
+        return edge.id;
+    }
+    async loadEntsFromEdges(id, rows) {
+        return (0, ent_1.applyPrivacyPolicyForRows)(this.viewer, rows, this.options.loadEntOptions);
+    }
+}
+exports.CustomClauseQuery = CustomClauseQuery;

package/core/query/custom_query.d.ts

@@ -1,19 +1,36 @@
 import { Data, Ent, ID, EdgeQueryableDataOptions, LoadEntOptions, Viewer, LoaderFactory, ConfigurableLoaderFactory } from "../base";
+import { Clause } from "../clause";
+import { OrderBy } from "../query_impl";
 import { BaseEdgeQuery, IDInfo, EdgeQuery } from "./query";
-export interface CustomEdgeQueryOptions<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
+export interface CustomEdgeQueryOptionsDeprecated<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
     src: TSource | ID;
     countLoaderFactory: LoaderFactory<ID, number>;
     dataLoaderFactory: ConfigurableLoaderFactory<ID, Data[]>;
     options: LoadEntOptions<TDest, TViewer>;
     sortColumn?: string;
 }
+export interface CustomEdgeQueryOptions<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
+    src: TSource | ID;
+    loadEntOptions: LoadEntOptions<TDest, TViewer>;
+    groupCol?: string;
+    clause?: Clause;
+    name: string;
+    sortColumn?: string;
+    orderby?: OrderBy;
+    primarySortColIsUnique?: boolean;
+    disableTransformations?: boolean;
+}
 export declare abstract class CustomEdgeQueryBase<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> extends BaseEdgeQuery<TSource, TDest, Data> implements EdgeQuery<TSource, TDest, Data> {
     viewer: TViewer;
     private options;
     private id;
-    constructor(viewer: TViewer, options: CustomEdgeQueryOptions<TSource, TDest, TViewer>);
+    private opts;
+    constructor(viewer: TViewer, options: CustomEdgeQueryOptionsDeprecated<TSource, TDest, TViewer> | CustomEdgeQueryOptions<TSource, TDest, TViewer>);
+    getTableName(): string;
     abstract sourceEnt(id: ID): Promise<Ent | null>;
     private idVisible;
+    private getCountLoader;
+    private getQueryLoader;
     queryRawCount(): Promise<number>;
     queryAllRawCount(): Promise<Map<ID, number>>;
     protected loadRawIDs(addID: (src: ID | TSource) => void): Promise<void>;