@snowtop/ent 0.2.7 → 0.2.9

package/core/loaders/assoc_edge_loader.js

@@ -32,15 +32,12 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssocEdgeLoaderFactory = exports.AssocDirectEdgeLoader = exports.AssocEdgeLoader = void 0;
-const memoizee_1 = __importDefault(require("memoizee"));
 const clause = __importStar(require("../clause"));
 const ent_1 = require("../ent");
-const cache_utils_1 = require("../cache_utils");
+const memoize_1 = require("../memoize");
+const query_impl_1 = require("../query_impl");
 const loader_1 = require("./loader");
 function getDefaultOrderBy() {
     return [
@@ -121,7 +118,7 @@ class AssocEdgeLoader {
         this.edgeCtr = edgeCtr;
         this.options = options;
         this.context = context;
-        this.loaderFn = (0, memoizee_1.default)(this.getLoader);
+        this.loaderFn = (0, memoize_1.memoizeNoArgs)(this.getLoader.bind(this));
     }
     async getLoader() {
         const edgeData = await (0, ent_1.loadEdgeData)(this.edgeType);
@@ -167,7 +164,7 @@ class AssocDirectEdgeLoader {
         this.options = options;
         this.context = context;
         if (this.context) {
-            this.loaderFn = (0, memoizee_1.default)(this.getLoader);
+            this.loaderFn = (0, memoize_1.memoizeNoArgs)(this.getLoader.bind(this));
         }
     }
     async getLoader() {
@@ -264,7 +261,7 @@ class AssocEdgeLoaderFactory {
             return new AssocDirectEdgeLoader(this.edgeType, edgeCtr, options, context);
         }
         const effectiveOptions = getEffectiveOptions(options);
-        const key = `${this.name}:limit:${effectiveOptions.limit}:orderby:${(0, cache_utils_1.stableStringify)(effectiveOptions.orderby)}:disableTransformations:${effectiveOptions.disableTransformations}`;
+        const key = `${this.name}:limit:${effectiveOptions.limit}:orderby:${(0, query_impl_1.getOrderByKey)(effectiveOptions.orderby ?? getDefaultOrderBy())}:disableTransformations:${effectiveOptions.disableTransformations}`;
         return (0, loader_1.getCustomLoader)(key, () => new AssocEdgeLoader(this.edgeType, ctr, effectiveOptions, context), context);
     }
 }

package/core/loaders/loader.js

@@ -195,7 +195,7 @@ class CacheMap {
             // was designed for ObjectLoader time. Now we have different needs e.g. count, assoc etc
             (0, logger_1.log)("cache", {
                 "dataloader-cache-hit": key,
-                "tableName": this.options.tableName,
+                tableName: this.options.tableName,
             });
         }
         return ret;

package/core/loaders/object_loader.js

@@ -32,9 +32,6 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjectLoaderFactory = exports.ObjectCountLoader = exports.ObjectLoader = exports.mapWithConcurrency = void 0;
 exports.setClauseLoaderConcurrency = setClauseLoaderConcurrency;
@@ -45,7 +42,7 @@ const clause = __importStar(require("../clause"));
 const logger_1 = require("../logger");
 const clause_1 = require("../clause");
 const loader_1 = require("./loader");
-const memoizee_1 = __importDefault(require("memoizee"));
+const memoize_1 = require("../memoize");
 const DEFAULT_CLAUSE_LOADER_CONCURRENCY = 10;
 let clauseLoaderConcurrency = DEFAULT_CLAUSE_LOADER_CONCURRENCY;
 function setClauseLoaderConcurrency(limit) {
@@ -151,7 +148,7 @@ class clauseCacheMap {
         if (ret) {
             (0, logger_1.log)("cache", {
                 "dataloader-cache-hit": key2 + (this.count ? ":count" : ""),
-                "tableName": this.options.tableName,
+                tableName: this.options.tableName,
             });
         }
         return ret;
@@ -205,7 +202,7 @@ class ObjectLoader {
             this.idLoader = createDataLoader(options, context);
             this.clauseLoader = createClauseDataLoder(options, context);
         }
-        this.memoizedInitPrime = (0, memoizee_1.default)(this.initPrime.bind(this));
+        this.memoizedInitPrime = (0, memoize_1.memoizeNoArgs)(this.initPrime.bind(this));
     }
     getOptions() {
         return this.options;

package/core/loaders/query_loader.d.ts

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

package/core/loaders/query_loader.js

@@ -32,15 +32,12 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryLoaderFactory = void 0;
-const memoizee_1 = __importDefault(require("memoizee"));
 const clause = __importStar(require("../clause"));
 const ent_1 = require("../ent");
-const cache_utils_1 = require("../cache_utils");
+const memoize_1 = require("../memoize");
+const query_impl_1 = require("../query_impl");
 const loader_1 = require("./loader");
 function getOrderByLocal(options, queryOptions) {
     return (options.orderby ??
@@ -105,6 +102,10 @@ function createLoader(options, queryOptions, context) {
             m.set(keys[i], i);
         }
         const col = options.groupCol;
+        const effectiveOrderBy = getOrderByLocal(options, queryOptions);
+        if ((0, query_impl_1.orderByHasExpressions)(effectiveOrderBy)) {
+            throw new Error("grouped query loaders do not support computed order expressions");
+        }
         let extraClause;
         if (options.clause && queryOptions?.clause) {
             extraClause = clause.And(options.clause, queryOptions.clause);
@@ -119,7 +120,7 @@ function createLoader(options, queryOptions, context) {
             tableName: options.tableName,
             fields: options.fields,
             values: keys,
-            orderby: getOrderByLocal(options, queryOptions),
+            orderby: effectiveOrderBy,
             limit: queryOptions?.limit || (0, ent_1.getDefaultLimit)(),
             groupColumn: col,
             clause: extraClause,
@@ -142,7 +143,7 @@ class QueryDirectLoader {
         this.options = options;
         this.queryOptions = queryOptions;
         this.context = context;
-        this.memoizedInitPrime = (0, memoizee_1.default)(this.initPrime.bind(this));
+        this.memoizedInitPrime = (0, memoize_1.memoizeNoArgs)(this.initPrime.bind(this));
     }
     initPrime() {
         if (!this.context || !this.options?.toPrime) {
@@ -187,7 +188,7 @@ class QueryLoader {
         if (context) {
             this.loader = createLoader(options, queryOptions, context);
         }
-        this.memoizedInitPrime = (0, memoizee_1.default)(this.initPrime.bind(this));
+        this.memoizedInitPrime = (0, memoize_1.memoizeNoArgs)(this.initPrime.bind(this));
     }
     initPrime() {
         if (!this.context || !this.options?.toPrime) {
@@ -259,7 +260,7 @@ class QueryLoaderFactory {
                     ? `baseClause:${queryOptions.clause.instanceKey()}`
                     : undefined,
                 `limit:${effectiveLimit}`,
-                `orderby:${(0, cache_utils_1.stableStringify)(effectiveOrderBy)}`,
+                `orderby:${(0, query_impl_1.getOrderByKey)(effectiveOrderBy)}`,
                 `disableTransformations:${disableTransformations}`,
             ];
             const key = keyParts
@@ -270,7 +271,7 @@ class QueryLoaderFactory {
         const effectiveOrderBy = getOrderByLocal(queryOptions, options);
         const effectiveLimit = options.limit || (0, ent_1.getDefaultLimit)();
         const disableTransformations = options.disableTransformations ?? false;
-        const key = `${name}:limit:${effectiveLimit}:orderby:${(0, cache_utils_1.stableStringify)(effectiveOrderBy)}:disableTransformations:${disableTransformations}`;
+        const key = `${name}:limit:${effectiveLimit}:orderby:${(0, query_impl_1.getOrderByKey)(effectiveOrderBy)}:disableTransformations:${disableTransformations}`;
         return (0, loader_1.getCustomLoader)(key, () => new QueryLoader(queryOptions, context, options), context);
     }
 }

package/core/memoize.d.ts

@@ -0,0 +1 @@
+export declare function memoizeNoArgs<T>(fn: () => T): () => T;

package/core/memoize.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoizeNoArgs = memoizeNoArgs;
+function memoizeNoArgs(fn) {
+    let called = false;
+    let value;
+    return () => {
+        if (called) {
+            return value;
+        }
+        value = fn();
+        called = true;
+        return value;
+    };
+}

package/core/query/custom_clause_query.js

@@ -81,7 +81,11 @@ class CustomClauseQuery extends query_1.BaseEdgeQuery {
             const alias = this.options.loadEntOptions.fieldsAlias ??
                 this.options.loadEntOptions.alias;
             const fieldString = typeof firstRequestedField === "object"
-                ? `${firstRequestedField.alias}.${firstRequestedField.column}`
+                ? "expression" in firstRequestedField
+                    ? (() => {
+                        throw new Error("join-backed raw counts do not support computed select expressions");
+                    })()
+                    : `${firstRequestedField.alias}.${firstRequestedField.column}`
                 : alias
                     ? `${alias}.${firstRequestedField}`
                     : firstRequestedField;

package/core/query/query.d.ts

@@ -84,7 +84,7 @@ export declare abstract class BaseEdgeQuery<TSource extends Ent, TDest extends E
     protected genIDInfosToFetchImpl(): Promise<IDInfo[]>;
     private _defaultEdgeQueryableOptions;
     protected configureEdgeQueryableDataOptions(opts: EdgeQueryableDataOptionsConfigureLoader): void;
-    protected getDefaultEdgeQueryOptions(): Partial<Pick<QueryableDataOptions, "clause" | "limit" | "orderby" | "disableTransformations">> | undefined;
+    protected getDefaultEdgeQueryOptions(): Partial<Pick<QueryableDataOptions, "limit" | "orderby" | "clause" | "disableTransformations">> | undefined;
     private loadEdges;
     getCursor(row: TEdge): string;
 }

package/core/query/query.js

@@ -32,16 +32,13 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseEdgeQuery = void 0;
-const memoizee_1 = __importDefault(require("memoizee"));
 const types_1 = require("util/types");
 const clause = __importStar(require("../clause"));
 const ent_1 = require("../ent");
 const privacy_1 = require("../privacy");
+const memoize_1 = require("../memoize");
 const query_impl_1 = require("../query_impl");
 // TODO can we generalize EdgeQuery to support any clause
 function assertPositive(n) {
@@ -51,7 +48,7 @@ function assertPositive(n) {
 }
 function translateCursorToKeyValues(cursor, opts) {
     const { keys } = opts;
-    const decoded = atob(cursor);
+    const decoded = (0, ent_1.decodeCursorPayload)(cursor);
     let cursorData = [];
     try {
         cursorData = JSON.parse(decoded);
@@ -149,6 +146,9 @@ class FirstFilter {
         options.limit = this.options.limit + 1;
         const orderBy = this.options.orderby;
         if (this.offset) {
+            if ((0, query_impl_1.orderByHasExpressions)(orderBy)) {
+                throw new Error("cursor pagination does not support computed order expressions");
+            }
             const keyValuePairs = {};
             for (const [key, value] of this.cursorKeyValues) {
                 keyValuePairs[key] = value;
@@ -219,6 +219,9 @@ class LastFilter {
         // we also sort cursor col in same direction. (direction doesn't matter)
         const orderBy = (0, query_impl_1.reverseOrderBy)(this.options.orderby);
         if (this.offset) {
+            if ((0, query_impl_1.orderByHasExpressions)(orderBy)) {
+                throw new Error("cursor pagination does not support computed order expressions");
+            }
             const keyValuePairs = {};
             for (const [key, value] of this.cursorKeyValues) {
                 keyValuePairs[key] = value;
@@ -316,8 +319,8 @@ class BaseEdgeQuery {
         this.edgeQueryOptions = { ...options, orderby: orderBy };
         this.cursorCol = options.cursorCol;
         this.cursorKeys = orderBy.map((orderBy) => orderBy.column);
-        this.memoizedloadEdges = (0, memoizee_1.default)(this.loadEdges.bind(this));
-        this.genIDInfosToFetch = (0, memoizee_1.default)(this.genIDInfosToFetchImpl.bind(this));
+        this.memoizedloadEdges = (0, memoize_1.memoizeNoArgs)(this.loadEdges.bind(this));
+        this.genIDInfosToFetch = (0, memoize_1.memoizeNoArgs)(this.genIDInfosToFetchImpl.bind(this));
     }
     getCursorCol() {
         return this.cursorCol;

package/core/query_expression.d.ts

@@ -0,0 +1,6 @@
+export interface QueryExpression {
+    clause(idx: number, alias?: string): string;
+    values(): any[];
+    logValues(): any[];
+    instanceKey(): string;
+}

package/core/query_expression.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/query_impl.d.ts

@@ -1,17 +1,33 @@
 import { QueryableDataOptions } from "./base";
+import { QueryExpression } from "./query_expression";
 export interface OrderByOption {
     column: string;
     direction: "ASC" | "DESC";
     alias?: string;
     nullsPlacement?: "first" | "last";
+    expression?: QueryExpression;
 }
 export type OrderBy = OrderByOption[];
-export declare function getOrderByPhrase(orderby: OrderBy, alias?: string): string;
-export declare function reverseOrderBy(orderby: OrderBy): OrderBy;
-interface JoinInfo {
+interface QueryFragmentInfo {
     phrase: string;
+    values: any[];
+    logValues: any[];
     valuesUsed: number;
 }
+export interface BuiltQueryData {
+    query: string;
+    values: any[];
+    logValues: any[];
+}
+export declare function getSelectFieldsKey(fields: QueryableDataOptions["fields"]): string;
+export declare function getOrderByKey(orderby: OrderBy): string;
+export declare function orderByHasExpressions(orderby?: OrderBy): boolean;
+export declare function getOrderByInfo(orderby: OrderBy, alias?: string, clauseIdx?: number): QueryFragmentInfo;
+export declare function getOrderByPhrase(orderby: OrderBy, alias?: string): string;
+export declare function reverseOrderBy(orderby: OrderBy): OrderBy;
+interface JoinInfo extends QueryFragmentInfo {
+}
 export declare function getJoinInfo(join: NonNullable<QueryableDataOptions["join"]>, clauseIdx?: number): JoinInfo;
+export declare function buildQueryData(options: QueryableDataOptions): BuiltQueryData;
 export declare function buildQuery(options: QueryableDataOptions): string;
 export {};

package/core/query_impl.js

@@ -1,14 +1,98 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSelectFieldsKey = getSelectFieldsKey;
+exports.getOrderByKey = getOrderByKey;
+exports.orderByHasExpressions = orderByHasExpressions;
+exports.getOrderByInfo = getOrderByInfo;
 exports.getOrderByPhrase = getOrderByPhrase;
 exports.reverseOrderBy = reverseOrderBy;
 exports.getJoinInfo = getJoinInfo;
+exports.buildQueryData = buildQueryData;
 exports.buildQuery = buildQuery;
-function getOrderByPhrase(orderby, alias) {
+const cache_utils_1 = require("./cache_utils");
+function isExpressionField(field) {
+    return typeof field === "object" && "expression" in field;
+}
+function getCacheKeyForExpression(expression) {
+    return expression.instanceKey();
+}
+function getSelectFieldsKey(fields) {
+    return fields
+        .map((field) => {
+        if (typeof field === "string") {
+            return field;
+        }
+        if (isExpressionField(field)) {
+            return (0, cache_utils_1.stableStringify)({
+                alias: field.alias,
+                expression: getCacheKeyForExpression(field.expression),
+            });
+        }
+        return (0, cache_utils_1.stableStringify)({
+            alias: field.alias,
+            column: field.column,
+        });
+    })
+        .join(",");
+}
+function getOrderByKey(orderby) {
     return orderby
-        .map((v) => {
+        .map((entry) => (0, cache_utils_1.stableStringify)({
+        column: entry.column,
+        direction: entry.direction,
+        alias: entry.alias,
+        nullsPlacement: entry.nullsPlacement,
+        expression: entry.expression
+            ? getCacheKeyForExpression(entry.expression)
+            : undefined,
+    }))
+        .join("|");
+}
+function orderByHasExpressions(orderby) {
+    return orderby?.some((entry) => entry.expression !== undefined) ?? false;
+}
+function getFieldsInfo(fields, alias, disableFieldsAlias, clauseIdx = 1) {
+    let valuesUsed = 0;
+    const values = [];
+    const logValues = [];
+    const phrase = fields
+        .map((field) => {
+        if (typeof field === "string") {
+            if (alias && !disableFieldsAlias) {
+                return `${alias}.${field}`;
+            }
+            return field;
+        }
+        if (isExpressionField(field)) {
+            const expression = field.expression;
+            const rendered = expression.clause(clauseIdx + valuesUsed, disableFieldsAlias ? undefined : alias);
+            const expressionValues = expression.values();
+            valuesUsed += expressionValues.length;
+            values.push(...expressionValues);
+            logValues.push(...expression.logValues());
+            return `${rendered} AS ${field.alias}`;
+        }
+        if (!disableFieldsAlias) {
+            return `${field.alias}.${field.column}`;
+        }
+        return field.column;
+    })
+        .join(", ");
+    return {
+        phrase,
+        valuesUsed,
+        values,
+        logValues,
+    };
+}
+function getOrderByInfo(orderby, alias, clauseIdx = 1) {
+    let valuesUsed = 0;
+    const values = [];
+    const logValues = [];
+    const phrase = orderby
+        .map((entry) => {
         let nullsPlacement = "";
-        switch (v.nullsPlacement) {
+        switch (entry.nullsPlacement) {
             case "first":
                 nullsPlacement = " NULLS FIRST";
                 break;
@@ -16,11 +100,28 @@ function getOrderByPhrase(orderby, alias) {
                 nullsPlacement = " NULLS LAST";
                 break;
         }
-        const orderByAlias = v.alias ?? alias;
-        const col = orderByAlias ? `${orderByAlias}.${v.column}` : v.column;
-        return `${col} ${v.direction}${nullsPlacement}`;
+        const orderByAlias = entry.alias ?? alias;
+        let col = orderByAlias ? `${orderByAlias}.${entry.column}` : entry.column;
+        if (entry.expression) {
+            const rendered = entry.expression.clause(clauseIdx + valuesUsed, orderByAlias);
+            const expressionValues = entry.expression.values();
+            valuesUsed += expressionValues.length;
+            values.push(...expressionValues);
+            logValues.push(...entry.expression.logValues());
+            col = rendered;
+        }
+        return `${col} ${entry.direction}${nullsPlacement}`;
     })
         .join(", ");
+    return {
+        phrase,
+        valuesUsed,
+        values,
+        logValues,
+    };
+}
+function getOrderByPhrase(orderby, alias) {
+    return getOrderByInfo(orderby, alias).phrase;
 }
 function reverseOrderBy(orderby) {
     return orderby.map((o) => {
@@ -31,12 +132,18 @@ function reverseOrderBy(orderby) {
 }
 function getJoinInfo(join, clauseIdx = 1) {
     let valuesUsed = 0;
-    const str = join
+    const values = [];
+    const logValues = [];
+    const phrase = join
         .map((join) => {
         const joinTable = join.alias
             ? `${join.tableName} ${join.alias}`
             : join.tableName;
-        valuesUsed += join.clause.values().length;
+        const joinValues = join.clause.values();
+        const renderedClause = join.clause.clause(clauseIdx + valuesUsed);
+        valuesUsed += joinValues.length;
+        values.push(...joinValues);
+        logValues.push(...join.clause.logValues());
         let joinType;
         switch (join.type) {
             case "left":
@@ -54,53 +161,52 @@ function getJoinInfo(join, clauseIdx = 1) {
             default:
                 joinType = "JOIN";
         }
-        return `${joinType} ${joinTable} ON ${join.clause.clause(clauseIdx)}`;
+        return `${joinType} ${joinTable} ON ${renderedClause}`;
     })
         .join(" ");
     return {
-        phrase: str,
+        phrase,
         valuesUsed,
+        values,
+        logValues,
     };
 }
-function buildQuery(options) {
+function buildQueryData(options) {
     const fieldsAlias = options.fieldsAlias ?? options.alias;
-    const fields = options.fields
-        .map((f) => {
-        if (typeof f === "object") {
-            if (!options.disableFieldsAlias) {
-                return `${f.alias}.${f.column}`;
-            }
-            return f.column;
-        }
-        if (fieldsAlias && !options.disableFieldsAlias) {
-            return `${fieldsAlias}.${f}`;
-        }
-        return f;
-    })
-        .join(", ");
-    // always start at 1
+    const fieldInfo = getFieldsInfo(options.fields, fieldsAlias, options.disableFieldsAlias, 1);
+    const values = [...fieldInfo.values];
+    const logValues = [...fieldInfo.logValues];
+    let clauseIdx = 1 + fieldInfo.valuesUsed;
     const parts = [];
     const tableName = options.alias
         ? `${options.tableName} AS ${options.alias}`
         : options.tableName;
     if (options.distinct) {
-        parts.push(`SELECT DISTINCT ${fields} FROM ${tableName}`);
+        parts.push(`SELECT DISTINCT ${fieldInfo.phrase} FROM ${tableName}`);
     }
     else {
-        parts.push(`SELECT ${fields} FROM ${tableName}`);
+        parts.push(`SELECT ${fieldInfo.phrase} FROM ${tableName}`);
     }
-    let whereStart = 1;
     if (options.join) {
-        const { phrase, valuesUsed } = getJoinInfo(options.join);
-        parts.push(phrase);
-        whereStart += valuesUsed;
+        const joinInfo = getJoinInfo(options.join, clauseIdx);
+        parts.push(joinInfo.phrase);
+        values.push(...joinInfo.values);
+        logValues.push(...joinInfo.logValues);
+        clauseIdx += joinInfo.valuesUsed;
     }
-    parts.push(`WHERE ${options.clause.clause(whereStart, options.alias)}`);
+    parts.push(`WHERE ${options.clause.clause(clauseIdx, options.alias)}`);
+    values.push(...options.clause.values());
+    logValues.push(...options.clause.logValues());
+    clauseIdx += options.clause.values().length;
     if (options.groupby) {
         parts.push(`GROUP BY ${options.groupby}`);
     }
     if (options.orderby) {
-        parts.push(`ORDER BY ${getOrderByPhrase(options.orderby, options.disableDefaultOrderByAlias ? undefined : fieldsAlias)}`);
+        const orderByInfo = getOrderByInfo(options.orderby, options.disableDefaultOrderByAlias ? undefined : fieldsAlias, clauseIdx);
+        parts.push(`ORDER BY ${orderByInfo.phrase}`);
+        values.push(...orderByInfo.values);
+        logValues.push(...orderByInfo.logValues);
+        clauseIdx += orderByInfo.valuesUsed;
     }
     if (options.limit !== undefined) {
         parts.push(`LIMIT ${options.limit}`);
@@ -108,5 +214,12 @@ function buildQuery(options) {
     if (options.offset !== undefined) {
         parts.push(`OFFSET ${options.offset}`);
     }
-    return parts.join(" ");
+    return {
+        query: parts.join(" "),
+        values,
+        logValues,
+    };
+}
+function buildQuery(options) {
+    return buildQueryData(options).query;
 }

package/index.d.ts

@@ -2,15 +2,17 @@ export * from "./core/base";
 export { loadEnt, loadCustomData, loadCustomEnts, loadCustomCount, loadEntX, loadEnts, CustomQuery, loadDerivedEnt, loadDerivedEntX, loadEntViaKey, loadEntXViaKey, performRawQuery, loadRowX, loadRow, loadRows, AssocEdge, AssocEdgeData, loadEdgeData, loadEdgeDatas, loadEdges, loadUniqueEdge, loadUniqueNode, loadRawEdgeCountX, loadEdgeForID2, loadNodesByEdge, getEdgeTypeInGroup, setEntLoaderPrivacyConcurrencyLimit, getEntLoaderPrivacyConcurrencyLimit, } from "./core/ent";
 export { DataOperation, EditNodeOptions, EditNodeOperation, RawQueryOperation, EdgeOperation, DeleteNodeOperation, AssocEdgeInputOptions, AssocEdgeInput, } from "./action/operations";
 export { setGlobalSchema } from "./core/global_schema";
+export { registerExtensionRuntime } from "./core/extensions";
 import DB from "./core/db";
 export * from "./core/loaders";
 export { DB };
 export { EntPrivacyError, AlwaysAllowRule, AlwaysDenyRule, DenyIfLoggedInRule, DenyIfLoggedOutRule, AllowIfHasIdentity, AllowIfViewerRule, AllowIfFuncRule, AllowIfViewerIsRule, AllowIfViewerIsEntPropertyRule, AllowIfEntPropertyIsRule, DenyIfEntPropertyIsRule, AllowIfViewerEqualsRule, DenyIfViewerEqualsRule, AllowIfEdgeExistsRule, AllowIfViewerInboundEdgeExistsRule, AllowIfViewerOutboundEdgeExistsRule, DenyIfEdgeExistsRule, DenyIfViewerInboundEdgeExistsRule, DenyIfViewerOutboundEdgeExistsRule, DenyIfEdgeDoesNotExistRule, DenyIfViewerInboundEdgeDoesNotExistRule, DenyIfViewerOutboundEdgeDoesNotExistRule, AllowIfEntIsVisibleRule, AllowIfEntIsNotVisibleRule, DenyIfEntIsVisibleRule, DenyIfEntIsNotVisibleRule, AllowIfEntIsVisiblePolicy, DenyIfEntIsVisiblePolicy, DelayedResultRule, applyPrivacyPolicy, applyPrivacyPolicyX, AlwaysAllowPrivacyPolicy, AlwaysDenyPrivacyPolicy, AllowIfConditionAppliesRule, AllowIfSubPolicyAllowsRule, AllowIfViewerPrivacyPolicy, AllowIfViewerHasIdentityPrivacyPolicy, } from "./core/privacy";
 export * from "./core/query";
 export * from "./core/query_impl";
+export type { QueryExpression } from "./core/query_expression";
 export * from "./schema/";
 import * as q from "./core/clause";
-export { Clause } from "./core/clause";
+export { Clause, Expression, ParameterizedExpression } from "./core/clause";
 declare const query: {
     Eq: typeof q.Eq;
     NotEq: typeof q.NotEq;
@@ -50,6 +52,8 @@ declare const query: {
     TsVectorPlainToTsQuery: typeof q.TsVectorPlainToTsQuery;
     TsVectorPhraseToTsQuery: typeof q.TsVectorPhraseToTsQuery;
     TsVectorWebsearchToTsQuery: typeof q.TsVectorWebsearchToTsQuery;
+    Expression: typeof q.Expression;
+    ParameterizedExpression: typeof q.ParameterizedExpression;
 };
 export { query };
 export { RequestContext, ContextCache } from "./core/context";

package/index.js

@@ -39,8 +39,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AllowIfViewerOutboundEdgeExistsRule = exports.AllowIfViewerInboundEdgeExistsRule = exports.AllowIfEdgeExistsRule = exports.DenyIfViewerEqualsRule = exports.AllowIfViewerEqualsRule = exports.DenyIfEntPropertyIsRule = exports.AllowIfEntPropertyIsRule = exports.AllowIfViewerIsEntPropertyRule = exports.AllowIfViewerIsRule = exports.AllowIfFuncRule = exports.AllowIfViewerRule = exports.AllowIfHasIdentity = exports.DenyIfLoggedOutRule = exports.DenyIfLoggedInRule = exports.AlwaysDenyRule = exports.AlwaysAllowRule = exports.EntPrivacyError = exports.DB = exports.setGlobalSchema = exports.DeleteNodeOperation = exports.EdgeOperation = exports.RawQueryOperation = exports.EditNodeOperation = exports.getEntLoaderPrivacyConcurrencyLimit = exports.setEntLoaderPrivacyConcurrencyLimit = exports.getEdgeTypeInGroup = exports.loadNodesByEdge = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadEdges = exports.loadEdgeDatas = exports.loadEdgeData = exports.AssocEdgeData = exports.AssocEdge = exports.loadRows = exports.loadRow = exports.loadRowX = exports.performRawQuery = exports.loadEntXViaKey = exports.loadEntViaKey = exports.loadDerivedEntX = exports.loadDerivedEnt = exports.loadEnts = exports.loadEntX = exports.loadCustomCount = exports.loadCustomEnts = exports.loadCustomData = exports.loadEnt = void 0;
-exports.setLogLevels = exports.loadConfig = exports.LoggedOutViewer = exports.IDViewer = exports.ContextCache = exports.query = exports.AllowIfViewerHasIdentityPrivacyPolicy = exports.AllowIfViewerPrivacyPolicy = exports.AllowIfSubPolicyAllowsRule = exports.AllowIfConditionAppliesRule = exports.AlwaysDenyPrivacyPolicy = exports.AlwaysAllowPrivacyPolicy = exports.applyPrivacyPolicyX = exports.applyPrivacyPolicy = exports.DelayedResultRule = exports.DenyIfEntIsVisiblePolicy = exports.AllowIfEntIsVisiblePolicy = exports.DenyIfEntIsNotVisibleRule = exports.DenyIfEntIsVisibleRule = exports.AllowIfEntIsNotVisibleRule = exports.AllowIfEntIsVisibleRule = exports.DenyIfViewerOutboundEdgeDoesNotExistRule = exports.DenyIfViewerInboundEdgeDoesNotExistRule = exports.DenyIfEdgeDoesNotExistRule = exports.DenyIfViewerOutboundEdgeExistsRule = exports.DenyIfViewerInboundEdgeExistsRule = exports.DenyIfEdgeExistsRule = void 0;
+exports.AllowIfViewerInboundEdgeExistsRule = exports.AllowIfEdgeExistsRule = exports.DenyIfViewerEqualsRule = exports.AllowIfViewerEqualsRule = exports.DenyIfEntPropertyIsRule = exports.AllowIfEntPropertyIsRule = exports.AllowIfViewerIsEntPropertyRule = exports.AllowIfViewerIsRule = exports.AllowIfFuncRule = exports.AllowIfViewerRule = exports.AllowIfHasIdentity = exports.DenyIfLoggedOutRule = exports.DenyIfLoggedInRule = exports.AlwaysDenyRule = exports.AlwaysAllowRule = exports.EntPrivacyError = exports.DB = exports.registerExtensionRuntime = exports.setGlobalSchema = exports.DeleteNodeOperation = exports.EdgeOperation = exports.RawQueryOperation = exports.EditNodeOperation = exports.getEntLoaderPrivacyConcurrencyLimit = exports.setEntLoaderPrivacyConcurrencyLimit = exports.getEdgeTypeInGroup = exports.loadNodesByEdge = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadEdges = exports.loadEdgeDatas = exports.loadEdgeData = exports.AssocEdgeData = exports.AssocEdge = exports.loadRows = exports.loadRow = exports.loadRowX = exports.performRawQuery = exports.loadEntXViaKey = exports.loadEntViaKey = exports.loadDerivedEntX = exports.loadDerivedEnt = exports.loadEnts = exports.loadEntX = exports.loadCustomCount = exports.loadCustomEnts = exports.loadCustomData = exports.loadEnt = void 0;
+exports.setLogLevels = exports.loadConfig = exports.LoggedOutViewer = exports.IDViewer = exports.ContextCache = exports.query = exports.ParameterizedExpression = exports.Expression = exports.AllowIfViewerHasIdentityPrivacyPolicy = exports.AllowIfViewerPrivacyPolicy = exports.AllowIfSubPolicyAllowsRule = exports.AllowIfConditionAppliesRule = exports.AlwaysDenyPrivacyPolicy = exports.AlwaysAllowPrivacyPolicy = exports.applyPrivacyPolicyX = exports.applyPrivacyPolicy = exports.DelayedResultRule = exports.DenyIfEntIsVisiblePolicy = exports.AllowIfEntIsVisiblePolicy = exports.DenyIfEntIsNotVisibleRule = exports.DenyIfEntIsVisibleRule = exports.AllowIfEntIsNotVisibleRule = exports.AllowIfEntIsVisibleRule = exports.DenyIfViewerOutboundEdgeDoesNotExistRule = exports.DenyIfViewerInboundEdgeDoesNotExistRule = exports.DenyIfEdgeDoesNotExistRule = exports.DenyIfViewerOutboundEdgeExistsRule = exports.DenyIfViewerInboundEdgeExistsRule = exports.DenyIfEdgeExistsRule = exports.AllowIfViewerOutboundEdgeExistsRule = void 0;
 __exportStar(require("./core/base"), exports);
 var ent_1 = require("./core/ent");
 Object.defineProperty(exports, "loadEnt", { enumerable: true, get: function () { return ent_1.loadEnt; } });
@@ -79,6 +79,8 @@ Object.defineProperty(exports, "EdgeOperation", { enumerable: true, get: functio
 Object.defineProperty(exports, "DeleteNodeOperation", { enumerable: true, get: function () { return operations_1.DeleteNodeOperation; } });
 var global_schema_1 = require("./core/global_schema");
 Object.defineProperty(exports, "setGlobalSchema", { enumerable: true, get: function () { return global_schema_1.setGlobalSchema; } });
+var extensions_1 = require("./core/extensions");
+Object.defineProperty(exports, "registerExtensionRuntime", { enumerable: true, get: function () { return extensions_1.registerExtensionRuntime; } });
 const db_1 = __importDefault(require("./core/db"));
 exports.DB = db_1.default;
 __exportStar(require("./core/loaders"), exports);
@@ -126,6 +128,9 @@ __exportStar(require("./core/query"), exports);
 __exportStar(require("./core/query_impl"), exports);
 __exportStar(require("./schema/"), exports);
 const q = __importStar(require("./core/clause"));
+var clause_1 = require("./core/clause");
+Object.defineProperty(exports, "Expression", { enumerable: true, get: function () { return clause_1.Expression; } });
+Object.defineProperty(exports, "ParameterizedExpression", { enumerable: true, get: function () { return clause_1.ParameterizedExpression; } });
 const query = {
     Eq: q.Eq,
     NotEq: q.NotEq,
@@ -165,6 +170,8 @@ const query = {
     TsVectorPlainToTsQuery: q.TsVectorPlainToTsQuery,
     TsVectorPhraseToTsQuery: q.TsVectorPhraseToTsQuery,
     TsVectorWebsearchToTsQuery: q.TsVectorWebsearchToTsQuery,
+    Expression: q.Expression,
+    ParameterizedExpression: q.ParameterizedExpression,
 };
 exports.query = query;
 var context_1 = require("./core/context");