@snowtop/ent 0.1.0-alpha88 → 0.1.0-alpha89-16dc3410-33c4-11ed-9fc4-5d4a927887be

package/action/action.d.ts

@@ -46,7 +46,7 @@ export interface Observer<TEnt extends Ent<TViewer>, TBuilder extends Builder<TE
     observe(builder: TBuilder, input: TInput): void | Promise<void>;
 }
 export interface Validator<TEnt extends Ent<TViewer>, TBuilder extends Builder<TEnt, TViewer, TExistingEnt>, TViewer extends Viewer = Viewer, TInput extends Data = Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
-    validate(builder: TBuilder, input: TInput): Promise<void> | void;
+    validate(builder: TBuilder, input: TInput): Promise<void | undefined | Error> | void | Error | undefined;
 }
 export interface Action<TEnt extends Ent<TViewer>, TBuilder extends Builder<TEnt, TViewer, TExistingEnt>, TViewer extends Viewer = Viewer, TInput extends Data = Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
     readonly viewer: Viewer;

package/action/orchestrator.js

@@ -368,13 +368,14 @@ class Orchestrator {
         // not ideal we're calling this twice. fix...
         // needed for now. may need to rewrite some of this?
         const editedFields2 = await this.options.editedFields();
-        const [errors, _] = await Promise.all([
+        const [errors, errs2] = await Promise.all([
             this.formatAndValidateFields(schemaFields, editedFields2),
             this.validators(validators, action, builder),
         ]);
         if (privacyError !== null) {
             errors.unshift(privacyError);
         }
+        errors.push(...errs2);
         return errors;
     }
     async triggers(action, builder, triggers) {
@@ -420,16 +421,19 @@ class Orchestrator {
         }
     }
     async validators(validators, action, builder) {
-        // TODO need to catch errors and return it...
-        // don't need it initially since what we need this for doesn't have the errors
-        let promises = [];
-        validators.forEach((validator) => {
-            let res = validator.validate(builder, action.getInput());
-            if (res) {
-                promises.push(res);
-            }
-        });
-        await Promise.all(promises);
+        const errors = [];
+        await Promise.all(validators.map(async (v) => {
+            try {
+                const r = await v.validate(builder, action.getInput());
+                if (r instanceof Error) {
+                    errors.push(r);
+                }
+            }
+            catch (err) {
+                errors.push(err);
+            }
+        }));
+        return errors;
     }
     isBuilder(val) {
         return val.placeholderID !== undefined;

package/core/clause.d.ts

@@ -4,6 +4,7 @@ export interface Clause {
     values(): any[];
     instanceKey(): string;
     logValues(): any[];
+    compositeOp?: string;
 }
 export interface SensitiveValue {
     value(): any;
@@ -37,6 +38,7 @@ export declare class inClause implements Clause {
 declare class compositeClause implements Clause {
     private clauses;
     private sep;
+    compositeOp: string;
     constructor(clauses: Clause[], sep: string);
     clause(idx: number): string;
     columns(): string[];
@@ -97,6 +99,7 @@ export declare function LessEq(col: string, value: any): simpleClause;
 export declare function And(...args: Clause[]): compositeClause;
 export declare function AndOptional(...args: (Clause | undefined)[]): Clause;
 export declare function Or(...args: Clause[]): compositeClause;
+export declare function OrOptional(...args: (Clause | undefined)[]): Clause;
 export declare function In(col: string, ...values: any): Clause;
 export declare function In(col: string, values: any[], type?: string): Clause;
 interface TsQuery {

package/core/clause.js

@@ -19,7 +19,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JSONPathValuePredicate = exports.JSONObjectFieldKeyAsText = exports.JSONObjectFieldKeyASJSON = exports.sensitiveValue = exports.TsVectorWebsearchToTsQuery = exports.TsVectorPhraseToTsQuery = exports.TsVectorPlainToTsQuery = exports.TsVectorColTsQuery = exports.WebsearchToTsQuery = exports.PhraseToTsQuery = exports.PlainToTsQuery = exports.TsQuery = exports.In = exports.Or = exports.AndOptional = exports.And = exports.LessEq = exports.GreaterEq = exports.Less = exports.Greater = exports.NotEq = exports.Eq = exports.ArrayNotEq = exports.ArrayEq = exports.PostgresArrayNotOverlaps = exports.PostgresArrayOverlaps = exports.PostgresArrayNotContains = exports.PostgresArrayNotContainsValue = exports.PostgresArrayContains = exports.PostgresArrayContainsValue = exports.inClause = void 0;
+exports.JSONPathValuePredicate = exports.JSONObjectFieldKeyAsText = exports.JSONObjectFieldKeyASJSON = exports.sensitiveValue = exports.TsVectorWebsearchToTsQuery = exports.TsVectorPhraseToTsQuery = exports.TsVectorPlainToTsQuery = exports.TsVectorColTsQuery = exports.WebsearchToTsQuery = exports.PhraseToTsQuery = exports.PlainToTsQuery = exports.TsQuery = exports.In = exports.OrOptional = exports.Or = exports.AndOptional = exports.And = exports.LessEq = exports.GreaterEq = exports.Less = exports.Greater = exports.NotEq = exports.Eq = exports.ArrayNotEq = exports.ArrayEq = exports.PostgresArrayNotOverlaps = exports.PostgresArrayOverlaps = exports.PostgresArrayNotContains = exports.PostgresArrayNotContainsValue = exports.PostgresArrayContains = exports.PostgresArrayContainsValue = exports.inClause = void 0;
 const db_1 = __importStar(require("./db"));
 function isSensitive(val) {
     return (val !== null &&
@@ -59,9 +59,9 @@ class simpleClause {
         return [this.col];
     }
     values() {
-        const sqliteClause = this.nullClause();
-        if (sqliteClause) {
-            return sqliteClause.values();
+        const nullClause = this.nullClause();
+        if (nullClause) {
+            return nullClause.values();
         }
         if (isSensitive(this.value)) {
             return [this.value.value()];
@@ -69,9 +69,9 @@ class simpleClause {
         return [this.value];
     }
     logValues() {
-        const sqliteClause = this.nullClause();
-        if (sqliteClause) {
-            return sqliteClause.logValues();
+        const nullClause = this.nullClause();
+        if (nullClause) {
+            return nullClause.logValues();
         }
         if (isSensitive(this.value)) {
             return [this.value.logValue()];
@@ -79,9 +79,9 @@ class simpleClause {
         return [this.value];
     }
     instanceKey() {
-        const sqliteClause = this.nullClause();
-        if (sqliteClause) {
-            return sqliteClause.instanceKey();
+        const nullClause = this.nullClause();
+        if (nullClause) {
+            return nullClause.instanceKey();
         }
         return `${this.col}${this.op}${rawValue(this.value)}`;
     }
@@ -300,11 +300,17 @@ class compositeClause {
     constructor(clauses, sep) {
         this.clauses = clauses;
         this.sep = sep;
+        this.compositeOp = this.sep;
     }
     clause(idx) {
         let clauses = [];
         for (const clause of this.clauses) {
-            clauses.push(clause.clause(idx));
+            let cls = clause.clause(idx);
+            // if composite clause and a different op, add parens so that we enforce order of precedence
+            if (clause.compositeOp && clause.compositeOp !== this.sep) {
+                cls = `(${cls})`;
+            }
+            clauses.push(cls);
             idx = idx + clause.values().length;
         }
         return clauses.join(this.sep);
@@ -332,7 +338,14 @@ class compositeClause {
     }
     instanceKey() {
         let keys = [];
-        this.clauses.forEach((clause) => keys.push(clause.instanceKey()));
+        this.clauses.forEach((clause) => {
+            if (clause.compositeOp && clause.compositeOp != this.sep) {
+                keys.push(`(${clause.instanceKey()})`);
+            }
+            else {
+                keys.push(clause.instanceKey());
+            }
+        });
         return keys.join(this.sep);
     }
 }
@@ -513,6 +526,15 @@ function Or(...args) {
     return new compositeClause(args, " OR ");
 }
 exports.Or = Or;
+function OrOptional(...args) {
+    // @ts-ignore
+    let filtered = args.filter((v) => v !== undefined);
+    if (filtered.length === 1) {
+        return filtered[0];
+    }
+    return Or(...filtered);
+}
+exports.OrOptional = OrOptional;
 function In(...args) {
     if (args.length < 2) {
         throw new Error(`invalid args passed to In`);

package/core/db.d.ts

@@ -77,6 +77,7 @@ interface SqliteRunResult {
 }
 interface SqliteDatabase {
     memory: boolean;
+    exec(query: string): SqliteStatement;
     prepare(query: string): SqliteStatement;
     close(): void;
     transaction(fn: (...params: any[]) => any): SqliteTransaction;

package/core/ent.d.ts

@@ -229,6 +229,6 @@ interface loadEdgeForIDOptions<T extends AssocEdge> extends loadCustomEdgesOptio
 export declare function loadEdgeForID2<T extends AssocEdge>(options: loadEdgeForIDOptions<T>): Promise<T | undefined>;
 export declare function loadNodesByEdge<T extends Ent>(viewer: Viewer, id1: ID, edgeType: string, options: LoadEntOptions<T>): Promise<T[]>;
 export declare function applyPrivacyPolicyForRow<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, options: LoadEntOptions<TEnt, TViewer>, row: Data): Promise<TEnt | null>;
-export declare function applyPrivacyPolicyForRows<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, rows: Data[], options: LoadEntOptions<TEnt, TViewer>): Promise<Map<ID, TEnt>>;
+export declare function applyPrivacyPolicyForRows<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, rows: Data[], options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt[]>;
 export declare function getEdgeTypeInGroup<T extends string>(viewer: Viewer, id1: ID, id2: ID, m: Map<T, string>): Promise<[T, AssocEdge] | undefined>;
 export {};

package/core/ent.js

@@ -196,6 +196,11 @@ function getEntKey(viewer, id, options) {
 }
 exports.getEntKey = getEntKey;
 async function loadEnt(viewer, id, options) {
+    if (typeof id !== "string" &&
+        typeof id !== "number" &&
+        typeof id !== "bigint") {
+        throw new Error(`invalid id ${id} passed to loadEnt`);
+    }
     const r = await getEntLoader(viewer, options).load(id);
     return r instanceof ErrorWrapper ? null : r;
 }
@@ -239,6 +244,11 @@ async function loadEntViaKey(viewer, key, options) {
 }
 exports.loadEntViaKey = loadEntViaKey;
 async function loadEntX(viewer, id, options) {
+    if (typeof id !== "string" &&
+        typeof id !== "number" &&
+        typeof id !== "bigint") {
+        throw new Error(`invalid id ${id} passed to loadEntX`);
+    }
     const r = await getEntLoader(viewer, options).load(id);
     if (r instanceof ErrorWrapper) {
         throw r.error;
@@ -338,25 +348,12 @@ async function loadEntsFromClause(viewer, clause, options) {
         context: viewer.context,
     };
     const rows = await loadRows(rowOptions);
-    return await applyPrivacyPolicyForRows(viewer, rows, options);
+    return applyPrivacyPolicyForRowsDeprecated(viewer, rows, options);
 }
 exports.loadEntsFromClause = loadEntsFromClause;
 async function loadCustomEnts(viewer, options, query) {
     const rows = await loadCustomData(options, query, viewer.context);
-    const result = new Array(rows.length);
-    if (!rows.length) {
-        return [];
-    }
-    const entLoader = getEntLoader(viewer, options);
-    await Promise.all(rows.map(async (row, idx) => {
-        const r = await applyPrivacyPolicyForRowAndStoreInEntLoader(viewer, row, options, entLoader);
-        if (r instanceof ErrorWrapper) {
-            return;
-        }
-        result[idx] = r;
-    }));
-    // filter ents that aren't visible because of privacy
-    return result.filter((r) => r !== undefined);
+    return applyPrivacyPolicyForRows(viewer, rows, options);
 }
 exports.loadCustomEnts = loadCustomEnts;
 function isClause(opts) {
@@ -1540,10 +1537,8 @@ async function applyPrivacyPolicyForRowX(viewer, options, row) {
     const ent = new options.ent(viewer, row);
     return await applyPrivacyPolicyForEntX(viewer, ent, row, options);
 }
-// TODO this needs to be changed to use ent cache as needed...
-// most current callsites fine not using it
-// custom_query is one that should be updated
-async function applyPrivacyPolicyForRows(viewer, rows, options) {
+// deprecated. doesn't use entcache
+async function applyPrivacyPolicyForRowsDeprecated(viewer, rows, options) {
     let m = new Map();
     // apply privacy logic
     await Promise.all(rows.map(async (row) => {
@@ -1554,6 +1549,22 @@ async function applyPrivacyPolicyForRows(viewer, rows, options) {
     }));
     return m;
 }
+async function applyPrivacyPolicyForRows(viewer, rows, options) {
+    const result = new Array(rows.length);
+    if (!rows.length) {
+        return [];
+    }
+    const entLoader = getEntLoader(viewer, options);
+    await Promise.all(rows.map(async (row, idx) => {
+        const r = await applyPrivacyPolicyForRowAndStoreInEntLoader(viewer, row, options, entLoader);
+        if (r instanceof ErrorWrapper) {
+            return;
+        }
+        result[idx] = r;
+    }));
+    // filter ents that aren't visible because of privacy
+    return result.filter((r) => r !== undefined);
+}
 exports.applyPrivacyPolicyForRows = applyPrivacyPolicyForRows;
 async function loadEdgeWithConst(viewer, id1, id2, edgeEnum, edgeType) {
     const edge = await loadEdgeForID2({

package/core/loaders/index.d.ts

@@ -3,4 +3,4 @@ export { RawCountLoader, RawCountLoaderFactory } from "./raw_count_loader";
 export { AssocEdgeCountLoader, AssocEdgeCountLoaderFactory, } from "./assoc_count_loader";
 export { AssocDirectEdgeLoader, AssocEdgeLoader, AssocEdgeLoaderFactory, } from "./assoc_edge_loader";
 export { IndexLoaderFactory } from "./index_loader";
-export { QueryLoader, QueryDirectLoader, QueryLoaderFactory, } from "./query_loader";
+export { QueryLoaderFactory } from "./query_loader";

package/core/loaders/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryLoaderFactory = exports.QueryDirectLoader = exports.QueryLoader = exports.IndexLoaderFactory = exports.AssocEdgeLoaderFactory = exports.AssocEdgeLoader = exports.AssocDirectEdgeLoader = exports.AssocEdgeCountLoaderFactory = exports.AssocEdgeCountLoader = exports.RawCountLoaderFactory = exports.RawCountLoader = exports.ObjectLoaderFactory = exports.ObjectLoader = void 0;
+exports.QueryLoaderFactory = exports.IndexLoaderFactory = exports.AssocEdgeLoaderFactory = exports.AssocEdgeLoader = exports.AssocDirectEdgeLoader = exports.AssocEdgeCountLoaderFactory = exports.AssocEdgeCountLoader = exports.RawCountLoaderFactory = exports.RawCountLoader = exports.ObjectLoaderFactory = exports.ObjectLoader = void 0;
 var object_loader_1 = require("./object_loader");
 Object.defineProperty(exports, "ObjectLoader", { enumerable: true, get: function () { return object_loader_1.ObjectLoader; } });
 Object.defineProperty(exports, "ObjectLoaderFactory", { enumerable: true, get: function () { return object_loader_1.ObjectLoaderFactory; } });
@@ -17,6 +17,4 @@ Object.defineProperty(exports, "AssocEdgeLoaderFactory", { enumerable: true, get
 var index_loader_1 = require("./index_loader");
 Object.defineProperty(exports, "IndexLoaderFactory", { enumerable: true, get: function () { return index_loader_1.IndexLoaderFactory; } });
 var query_loader_1 = require("./query_loader");
-Object.defineProperty(exports, "QueryLoader", { enumerable: true, get: function () { return query_loader_1.QueryLoader; } });
-Object.defineProperty(exports, "QueryDirectLoader", { enumerable: true, get: function () { return query_loader_1.QueryDirectLoader; } });
 Object.defineProperty(exports, "QueryLoaderFactory", { enumerable: true, get: function () { return query_loader_1.QueryLoaderFactory; } });

package/core/loaders/index_loader.d.ts

@@ -1,4 +1,4 @@
-import { ID, SelectBaseDataOptions, Context, Data, LoaderFactory, EdgeQueryableDataOptions } from "../base";
+import { ID, SelectBaseDataOptions, Context, Data, LoaderFactory, EdgeQueryableDataOptions, Loader } from "../base";
 import * as clause from "../clause";
 import { ObjectLoaderFactory } from "./object_loader";
 export declare class IndexLoaderFactory implements LoaderFactory<ID, Data[]> {
@@ -10,5 +10,5 @@ export declare class IndexLoaderFactory implements LoaderFactory<ID, Data[]> {
         toPrime?: ObjectLoaderFactory<ID>[];
     });
     createLoader(context?: Context): any;
-    createConfigurableLoader(options: EdgeQueryableDataOptions, context?: Context): import("../base").Loader<unknown, Data[]> | import("./query_loader").QueryDirectLoader<unknown>;
+    createConfigurableLoader(options: EdgeQueryableDataOptions, context?: Context): Loader<ID, Data[]>;
 }

package/core/loaders/query_loader.d.ts

@@ -1,21 +1,14 @@
 import { Context, ID, EdgeQueryableDataOptions, Loader, LoaderFactory, Data } from "../base";
 import * as clause from "../clause";
 import { ObjectLoaderFactory } from "./object_loader";
-export declare class QueryDirectLoader<K extends any> implements Loader<K, Data[]> {
+export declare function getOrderBy(sortCol: string, orderby?: string): string;
+declare class QueryDirectLoader<K extends any> implements Loader<K, Data[]> {
     private options;
     private queryOptions?;
-    constructor(options: QueryOptions, queryOptions?: Partial<Pick<import("../base").QueryableDataOptions, "limit" | "orderby" | "clause">> | undefined);
-    load(id: K): Promise<Data[]>;
-    clearAll(): void;
-}
-export declare class QueryLoader<K extends any> implements Loader<K, Data[]> {
-    private options;
     context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
-    private queryOptions?;
-    private loader;
-    private primedLoaders;
     private memoizedInitPrime;
-    constructor(options: QueryOptions, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined, queryOptions?: Partial<Pick<import("../base").QueryableDataOptions, "limit" | "orderby" | "clause">> | undefined);
+    private primedLoaders;
+    constructor(options: QueryOptions, queryOptions?: Partial<Pick<import("../base").QueryableDataOptions, "limit" | "orderby" | "clause">> | undefined, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
     private initPrime;
     load(id: K): Promise<Data[]>;
     clearAll(): void;
@@ -34,5 +27,6 @@ export declare class QueryLoaderFactory<K extends any> implements LoaderFactory<
     constructor(options: QueryOptions);
     createLoader(context?: Context): any;
     createConfigurableLoader(options: EdgeQueryableDataOptions, context?: Context): Loader<unknown, Data[]> | QueryDirectLoader<unknown>;
+    static createConfigurableLoader(name: string, queryOptions: QueryOptions, options: EdgeQueryableDataOptions, context?: Context): Loader<unknown, Data[]> | QueryDirectLoader<unknown>;
 }
 export {};

package/core/loaders/query_loader.js

@@ -22,7 +22,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryLoaderFactory = exports.QueryLoader = exports.QueryDirectLoader = void 0;
+exports.QueryLoaderFactory = exports.getOrderBy = void 0;
 const dataloader_1 = __importDefault(require("dataloader"));
 const ent_1 = require("../ent");
 const clause = __importStar(require("../clause"));
@@ -30,13 +30,17 @@ 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 orderby || `${sortCol}${orderbyDirection}`;
+    return `${sortCol}${orderbyDirection}`;
 }
+exports.getOrderBy = getOrderBy;
 async function simpleCase(options, id, queryOptions) {
     let cls;
     if (options.groupCol) {
@@ -120,16 +124,47 @@ function createLoader(options, queryOptions) {
     }, loaderOptions);
 }
 class QueryDirectLoader {
-    constructor(options, queryOptions) {
+    constructor(options, queryOptions, context) {
         this.options = options;
         this.queryOptions = queryOptions;
+        this.context = context;
+        this.memoizedInitPrime = (0, memoizee_1.default)(this.initPrime.bind(this));
+    }
+    initPrime() {
+        if (!this.context || !this.options?.toPrime) {
+            return;
+        }
+        let primedLoaders = new Map();
+        this.options.toPrime.forEach((prime) => {
+            const l2 = prime.createLoader(this.context);
+            if (l2.prime === undefined) {
+                return;
+            }
+            primedLoaders.set(prime.options.key, l2);
+        });
+        this.primedLoaders = primedLoaders;
     }
     async load(id) {
-        return simpleCase(this.options, id, this.queryOptions);
+        const rows = await simpleCase(this.options, id, this.queryOptions);
+        if (this.context) {
+            this.memoizedInitPrime();
+            if (this.primedLoaders) {
+                for (const row of rows) {
+                    for (const [key, loader] of this.primedLoaders) {
+                        const value = row[key];
+                        if (value !== undefined) {
+                            loader.prime(row);
+                        }
+                    }
+                }
+            }
+        }
+        return rows;
     }
     clearAll() { }
 }
-exports.QueryDirectLoader = QueryDirectLoader;
+// note, you should never call this directly
+// there's scenarios where QueryDirectLoader is needed instead of this...
 class QueryLoader {
     constructor(options, context, queryOptions) {
         this.options = options;
@@ -176,7 +211,6 @@ class QueryLoader {
         this.loader && this.loader.clearAll();
     }
 }
-exports.QueryLoader = QueryLoader;
 class QueryLoaderFactory {
     constructor(options) {
         this.options = options;
@@ -194,11 +228,14 @@ class QueryLoaderFactory {
         return (0, loader_1.getLoader)(this, () => new QueryLoader(this.options, context), context);
     }
     createConfigurableLoader(options, context) {
-        if (options?.clause || !context) {
-            return new QueryDirectLoader(this.options, options);
+        return QueryLoaderFactory.createConfigurableLoader(this.name, this.options, options, context);
+    }
+    static createConfigurableLoader(name, queryOptions, options, context) {
+        if (options.clause || !context) {
+            return new QueryDirectLoader(queryOptions, options, context);
         }
-        const key = `${this.name}:limit:${options.limit}:orderby:${options.orderby}`;
-        return (0, loader_1.getCustomLoader)(key, () => new QueryLoader(this.options, context, options), context);
+        const key = `${name}:limit:${options.limit}:orderby:${options.orderby}`;
+        return (0, loader_1.getCustomLoader)(key, () => new QueryLoader(queryOptions, context, options), context);
     }
 }
 exports.QueryLoaderFactory = QueryLoaderFactory;

package/core/query/custom_clause_query.d.ts

@@ -0,0 +1,24 @@
+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;
+    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>;
+    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,72 @@
+"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) {
+        super(viewer, options.sortColumn || "created_at");
+        this.viewer = viewer;
+        this.options = options;
+        this.clause = getClause(options);
+    }
+    async sourceEnt(_id) {
+        return null;
+    }
+    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 = `${this.options.sortColumn} DESC`;
+        }
+        if (!options.limit) {
+            options.limit = ent_1.DefaultLimit;
+        }
+        let sortCol = this.options.sortColumn || "created_at";
+        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)(sortCol, 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,22 +1,37 @@
 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<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;
+    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>);
     abstract sourceEnt(id: ID): Promise<Ent | null>;
     private idVisible;
+    private isDeprecatedOptions;
+    private getCountLoader;
+    private getQueryLoader;
     queryRawCount(): Promise<number>;
     queryAllRawCount(): Promise<Map<ID, number>>;
     protected loadRawIDs(addID: (src: ID | TSource) => void): Promise<void>;
+    private getLoadEntOptions;
     protected loadRawData(infos: IDInfo[], options: EdgeQueryableDataOptions): Promise<void>;
     dataToID(edge: Data): ID;
     protected loadEntsFromEdges(id: ID, rows: Data[]): Promise<TDest[]>;