@snowtop/ent 0.1.0-alpha13 → 0.1.0-alpha130

package/core/privacy.d.ts

@@ -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 | undefined): Promise<PrivacyResult>;
+    apply(_v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
 };
 export declare const AlwaysDenyRule: {
-    apply(_v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(_v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
 };
 export declare const DenyIfLoggedOutRule: {
-    apply(v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
 };
 export declare const DenyIfLoggedInRule: {
-    apply(v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
 };
 export declare const AllowIfHasIdentity: {
-    apply(v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
 };
 export declare const AllowIfViewerRule: {
-    apply(v: Viewer, ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 };
 export declare class AllowIfViewerEqualsRule {
     private id;
@@ -71,45 +71,45 @@ export declare class DenyIfEntPropertyIsRule<T extends Ent> implements PrivacyPo
     constructor(property: keyof T, val: any);
     apply(v: Viewer, ent?: T): Promise<PrivacyResult>;
 }
-export declare class AllowIfEntIsVisibleRule<T extends Ent> implements PrivacyPolicyRule {
+export declare class AllowIfEntIsVisibleRule<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicyRule {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
-    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
+    apply(v: TViewer, _ent?: Ent): Promise<PrivacyResult>;
 }
-export declare class AllowIfEntIsNotVisibleRule<T extends Ent> implements PrivacyPolicyRule {
+export declare class AllowIfEntIsNotVisibleRule<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicyRule {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
-    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
+    apply(v: TViewer, _ent?: Ent): Promise<PrivacyResult>;
 }
-export declare class AllowIfEntIsVisiblePolicy<T extends Ent> implements PrivacyPolicy {
+export declare class AllowIfEntIsVisiblePolicy<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicy<TEnt, TViewer> {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
     rules: {
-        apply(_v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+        apply(_v: Viewer<Ent<any> | null, ID | null>, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
     }[];
 }
-export declare class DenyIfEntIsVisiblePolicy<T extends Ent> implements PrivacyPolicy {
+export declare class DenyIfEntIsVisiblePolicy<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicy<TEnt, TViewer> {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
     rules: {
-        apply(_v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+        apply(_v: Viewer<Ent<any> | null, ID | null>, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
     }[];
 }
-export declare class DenyIfEntIsVisibleRule<T extends Ent> implements PrivacyPolicyRule {
+export declare class DenyIfEntIsVisibleRule<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicyRule<TEnt, TViewer> {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
-    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
+    apply(v: TViewer, _ent?: Ent): Promise<PrivacyResult>;
 }
-export declare class DenyIfEntIsNotVisibleRule<T extends Ent> implements PrivacyPolicyRule {
+export declare class DenyIfEntIsNotVisibleRule<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicyRule {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
-    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
+    apply(v: TViewer, _ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class AllowIfEdgeExistsRule implements PrivacyPolicyRule {
     private id1;
@@ -183,6 +183,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,8 @@
 "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 base_1 = require("./base");
 const ent_1 = require("./ent");
-const logger_1 = require("./logger");
 // copied from ./base
 var privacyResult;
 (function (privacyResult) {
@@ -437,45 +436,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,17 +3,18 @@ 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, TDest extends Ent = Ent> = TSource | TSource[] | ID | ID[] | EdgeQuery<TDest, Ent, AssocEdge>;
-declare type loaderOptionsFunc = (type: string) => LoadEntOptions<Ent>;
-export declare abstract class AssocEdgeQueryBase<TSource extends Ent, TDest extends Ent, TEdge extends AssocEdge> extends BaseEdgeQuery<TSource, TDest, TEdge> implements EdgeQuery<TSource, TDest, TEdge> {
-    viewer: Viewer;
-    src: EdgeQuerySource<TSource, TDest>;
+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>;
     private countLoaderFactory;
     private dataLoaderFactory;
     private options;
-    constructor(viewer: Viewer, src: EdgeQuerySource<TSource, TDest>, countLoaderFactory: AssocEdgeCountLoaderFactory, dataLoaderFactory: AssocEdgeLoaderFactory<TEdge>, options: LoadEntOptions<TDest> | loaderOptionsFunc);
+    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) {

package/core/query/custom_clause_query.d.ts

@@ -0,0 +1,27 @@
+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> {
+    loadEntOptions: LoadEntOptions<TDest, TViewer>;
+    clause: Clause;
+    name: string;
+    sortColumn?: string;
+    sortColumnUnique?: boolean;
+    orderByDirection?: "asc" | "desc";
+    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[]>;
+}
+export {};

package/core/query/custom_clause_query.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomClauseQuery = void 0;
+const clause_1 = require("../clause");
+const ent_1 = require("../ent");
+const query_loader_1 = require("../loaders/query_loader");
+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 sortCol = options.sortColumn || "id";
+        let unique = options.sortColumnUnique
+            ? sortCol
+            : options.loadEntOptions.loaderFactory.options?.key || "id";
+        // pass direction to base class since it uses it
+        // this API needs to be cleaned up...
+        if (options.orderByDirection) {
+            sortCol = `${sortCol} ${options.orderByDirection}`;
+        }
+        super(viewer, sortCol, unique);
+        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) {
+            const direction = this.options.orderByDirection ?? "desc";
+            options.orderby = `${this.options.sortColumn} ${direction}`;
+        }
+        if (!options.limit) {
+            options.limit = ent_1.DefaultLimit;
+        }
+        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: (0, query_loader_1.getOrderBy)(this.getSortCol(), options?.orderby),
+            limit: options?.limit || ent_1.DefaultLimit,
+            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,34 @@
 import { Data, Ent, ID, EdgeQueryableDataOptions, LoadEntOptions, Viewer, LoaderFactory, ConfigurableLoaderFactory } from "../base";
+import { Clause } from "../clause";
 import { BaseEdgeQuery, IDInfo, EdgeQuery } from "./query";
-export interface CustomEdgeQueryOptions<TSource extends Ent, TDest extends Ent> {
+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>;
+    options: LoadEntOptions<TDest, TViewer>;
     sortColumn?: string;
 }
-export declare abstract class CustomEdgeQueryBase<TSource extends Ent, TDest extends Ent> extends BaseEdgeQuery<TSource, TDest, Data> implements EdgeQuery<TSource, TDest, Data> {
-    viewer: Viewer;
+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;
+    sortColumnUnique?: 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: Viewer, options: CustomEdgeQueryOptions<TSource, TDest>);
+    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>;

package/core/query/custom_query.js

@@ -1,20 +1,86 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CustomEdgeQueryBase = void 0;
+const clause_1 = require("../clause");
 const ent_1 = require("../ent");
+const loaders_1 = require("../loaders");
 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);
+}
+function getRawCountLoader(viewer, opts) {
+    if (!viewer.context?.cache) {
+        return new loaders_1.RawCountLoader({
+            tableName: opts.loadEntOptions.tableName,
+            groupCol: opts.groupCol,
+            clause: getClause(opts),
+        });
+    }
+    const name = `custom_query_count_loader:${opts.name}`;
+    return viewer.context.cache.getLoader(name, () => new loaders_1.RawCountLoader({
+        tableName: opts.loadEntOptions.tableName,
+        groupCol: opts.groupCol,
+        clause: getClause(opts),
+    }));
+}
+function getQueryLoader(viewer, opts, options) {
+    const loader = opts.loadEntOptions.loaderFactory;
+    const name = `custom_query_loader:${opts.name}`;
+    return loaders_1.QueryLoaderFactory.createConfigurableLoader(name, {
+        tableName: opts.loadEntOptions.tableName,
+        fields: opts.loadEntOptions.fields,
+        groupCol: opts.groupCol,
+        clause: getClause(opts),
+        toPrime: [loader],
+    }, options, viewer.context);
+}
+function isDeprecatedOptions(options) {
+    return (options
+        .countLoaderFactory !== undefined);
+}
 class CustomEdgeQueryBase extends query_1.BaseEdgeQuery {
     constructor(viewer, options) {
-        super(viewer, options.sortColumn || "created_at");
+        let opts;
+        let defaultSort = "id";
+        let uniqueColIsSort = false;
+        if (isDeprecatedOptions(options)) {
+            opts = options.options;
+        }
+        else {
+            opts = options.loadEntOptions;
+            if (options.sortColumnUnique) {
+                uniqueColIsSort = true;
+            }
+        }
+        let uniqueCol = opts.loaderFactory.options?.key || "id";
+        if (uniqueColIsSort) {
+            uniqueCol = options.sortColumn || defaultSort;
+        }
+        options.sortColumn = options.sortColumn || defaultSort;
+        super(viewer, options.sortColumn, uniqueCol);
         this.viewer = viewer;
         this.options = options;
-        options.sortColumn = options.sortColumn || "created_at";
         if (typeof options.src === "object") {
             this.id = options.src.id;
         }
         else {
             this.id = options.src;
         }
+        this.opts = opts;
+    }
+    getTableName() {
+        return this.opts.tableName;
     }
     async idVisible() {
         const ids = await this.genIDInfosToFetch();
@@ -23,14 +89,24 @@ class CustomEdgeQueryBase extends query_1.BaseEdgeQuery {
         }
         return !ids[0].invalidated;
     }
+    getCountLoader() {
+        if (isDeprecatedOptions(this.options)) {
+            return this.options.countLoaderFactory.createLoader(this.viewer.context);
+        }
+        return getRawCountLoader(this.viewer, this.options);
+    }
+    getQueryLoader(options) {
+        if (isDeprecatedOptions(this.options)) {
+            return this.options.dataLoaderFactory.createConfigurableLoader(options, this.viewer.context);
+        }
+        return getQueryLoader(this.viewer, this.options, options);
+    }
     async queryRawCount() {
         const idVisible = await this.idVisible();
         if (!idVisible) {
             return 0;
         }
-        return await this.options.countLoaderFactory
-            .createLoader(this.viewer.context)
-            .load(this.id);
+        return this.getCountLoader().load(this.id);
     }
     async queryAllRawCount() {
         let count = 0;
@@ -44,16 +120,16 @@ class CustomEdgeQueryBase extends query_1.BaseEdgeQuery {
         addID(this.options.src);
     }
     async loadRawData(infos, options) {
-        const loader = this.options.dataLoaderFactory.createConfigurableLoader(options, this.viewer.context);
+        if (infos.length !== 1) {
+            throw new Error(`expected 1 info passed to loadRawData. ${infos.length} passed`);
+        }
         if (!options.orderby) {
-            options.orderby = `${this.options.sortColumn} DESC`;
+            options.orderby = `${this.getSortCol()} DESC`;
         }
         if (!options.limit) {
             options.limit = ent_1.DefaultLimit;
         }
-        if (infos.length !== 1) {
-            throw new Error(`expected 1 info passed to loadRawData. ${infos.length} passed`);
-        }
+        const loader = this.getQueryLoader(options);
         const info = infos[0];
         if (info.invalidated) {
             this.edges.set(this.id, []);
@@ -66,8 +142,7 @@ class CustomEdgeQueryBase extends query_1.BaseEdgeQuery {
         return edge.id;
     }
     async loadEntsFromEdges(id, rows) {
-        const ents = await (0, ent_1.applyPrivacyPolicyForRows)(this.viewer, rows, this.options.options);
-        return Array.from(ents.values());
+        return (0, ent_1.applyPrivacyPolicyForRows)(this.viewer, rows, this.opts);
     }
 }
 exports.CustomEdgeQueryBase = CustomEdgeQueryBase;

package/core/query/index.d.ts

@@ -1,3 +1,4 @@
 export { EdgeQuery, BaseEdgeQuery, EdgeQueryFilter, PaginationInfo, } from "./query";
 export { AssocEdgeQueryBase, EdgeQuerySource } from "./assoc_query";
 export { CustomEdgeQueryBase } from "./custom_query";
+export { CustomClauseQuery } from "./custom_clause_query";

package/core/query/index.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CustomEdgeQueryBase = exports.AssocEdgeQueryBase = exports.BaseEdgeQuery = void 0;
+exports.CustomClauseQuery = exports.CustomEdgeQueryBase = exports.AssocEdgeQueryBase = exports.BaseEdgeQuery = void 0;
 var query_1 = require("./query");
 Object.defineProperty(exports, "BaseEdgeQuery", { enumerable: true, get: function () { return query_1.BaseEdgeQuery; } });
 var assoc_query_1 = require("./assoc_query");
 Object.defineProperty(exports, "AssocEdgeQueryBase", { enumerable: true, get: function () { return assoc_query_1.AssocEdgeQueryBase; } });
 var custom_query_1 = require("./custom_query");
 Object.defineProperty(exports, "CustomEdgeQueryBase", { enumerable: true, get: function () { return custom_query_1.CustomEdgeQueryBase; } });
+var custom_clause_query_1 = require("./custom_clause_query");
+Object.defineProperty(exports, "CustomClauseQuery", { enumerable: true, get: function () { return custom_clause_query_1.CustomClauseQuery; } });

package/core/query/query.d.ts

@@ -20,7 +20,7 @@ export interface EdgeQuery<TSource extends Ent, TDest extends Ent, TEdge extends
 }
 export interface EdgeQueryFilter<T extends Data> {
     filter?(id: ID, edges: T[]): T[];
-    query?(options: EdgeQueryableDataOptions): EdgeQueryableDataOptions;
+    query?(options: EdgeQueryableDataOptions): EdgeQueryableDataOptions | Promise<EdgeQueryableDataOptions>;
     paginationInfo?(id: ID): PaginationInfo | undefined;
 }
 export interface PaginationInfo {
@@ -31,7 +31,6 @@ export interface PaginationInfo {
 }
 export declare abstract class BaseEdgeQuery<TSource extends Ent, TDest extends Ent, TEdge extends Data> implements EdgeQuery<TSource, TDest, TEdge> {
     viewer: Viewer;
-    private sortCol;
     private filters;
     private queryDispatched;
     protected edges: Map<ID, TEdge[]>;
@@ -40,8 +39,12 @@ export declare abstract class BaseEdgeQuery<TSource extends Ent, TDest extends E
     protected genIDInfosToFetch: () => Promise<IDInfo[]>;
     private idMap;
     private idsToFetch;
-    constructor(viewer: Viewer, sortCol: string);
-    getPrivacyPolicy(): PrivacyPolicy<Ent>;
+    private sortCol;
+    private cursorCol;
+    private defaultDirection?;
+    constructor(viewer: Viewer, sortCol: string, cursorCol: string);
+    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>;
     first(n: number, after?: string): this;
     last(n: number, before?: string): this;
@@ -64,6 +67,7 @@ export declare abstract class BaseEdgeQuery<TSource extends Ent, TDest extends E
     protected abstract loadRawIDs(addID: (src: ID | TSource) => void): Promise<void>;
     protected abstract loadRawData(infos: IDInfo[], options: EdgeQueryableDataOptions): Promise<void>;
     private addID;
+    abstract getTableName(): string | Promise<string>;
     protected genIDInfosToFetchImpl(): Promise<IDInfo[]>;
     private loadEdges;
     getCursor(row: TEdge): string;