@snowtop/ent 0.2.6 → 0.2.8

package/core/loaders/raw_count_loader.js

@@ -32,16 +32,11 @@ 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.RawCountLoaderFactory = exports.RawCountLoader = void 0;
 exports.createCountDataLoader = createCountDataLoader;
-const dataloader_1 = __importDefault(require("dataloader"));
 const ent_1 = require("../ent");
 const clause = __importStar(require("../clause"));
-const logger_1 = require("../logger");
 const loader_1 = require("./loader");
 async function simpleCase(options, key, context) {
     let cls;
@@ -66,21 +61,23 @@ async function simpleCase(options, key, context) {
     });
     return [parseInt(row?.count, 10) || 0];
 }
-function createCountDataLoader(options) {
+function createCountDataLoader(options, context) {
+    const loaderName = options.groupCol
+        ? `rawCountLoader:${options.tableName}:${options.groupCol}`
+        : options.clause
+            ? `rawCountLoader:${options.tableName}:${options.clause.instanceKey()}`
+            : `rawCountLoader:${options.tableName}`;
     const loaderOptions = {
         maxBatchSize: (0, loader_1.getLoaderMaxBatchSize)(),
+        cacheMap: (0, loader_1.createLoaderCacheMap)(options),
     };
-    // if query logging is enabled, we should log what's happening with loader
-    if ((0, logger_1.logEnabled)("query")) {
-        loaderOptions.cacheMap = new loader_1.CacheMap(options);
-    }
-    return new dataloader_1.default(async (keys) => {
+    return new loader_1.InstrumentedDataLoader(loaderName, async (keys) => {
         if (!keys.length) {
             return [];
         }
         // keep query simple if we're only fetching for one id
         if (keys.length == 1 || !options.groupCol) {
-            return simpleCase(options, keys[0]);
+            return simpleCase(options, keys[0], context);
         }
         let typ = options.groupColType || "uuid";
         let cls = clause.DBTypeIn(options.groupCol, keys, typ);
@@ -99,6 +96,7 @@ function createCountDataLoader(options) {
             fields: ["count(1) as count", options.groupCol],
             groupby: options.groupCol,
             clause: cls,
+            context,
         };
         const rows = await (0, ent_1.loadRows)(rowOptions);
         for (const row of rows) {
@@ -110,7 +108,7 @@ function createCountDataLoader(options) {
             result[idx] = parseInt(row.count, 10);
         }
         return result;
-    }, loaderOptions);
+    }, loaderOptions, options.tableName);
 }
 // for now this only works for single column counts
 // e.g. foreign key count
@@ -120,7 +118,7 @@ class RawCountLoader {
         this.options = options;
         this.context = context;
         if (context && options.groupCol) {
-            this.loader = createCountDataLoader(options);
+            this.loader = createCountDataLoader(options, context);
         }
     }
     async load(id) {

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/metrics.d.ts

@@ -0,0 +1,22 @@
+export type DataLoaderBatchMetrics = {
+    loaderName: string;
+    batchSize: number;
+};
+export type DataLoaderCacheHitMetrics = {
+    tableName: string;
+    key: unknown;
+};
+export type QueryCacheHitMetrics = {
+    tableName: string;
+    key: string;
+};
+export type MetricsHook = {
+    onDataLoaderBatch?: (info: DataLoaderBatchMetrics) => void;
+    onDataLoaderCacheHit?: (info: DataLoaderCacheHitMetrics) => void;
+    onQueryCacheHit?: (info: QueryCacheHitMetrics) => void;
+};
+export declare function setMetricsHook(hooks?: MetricsHook | null): void;
+export declare function getMetricsHook(): MetricsHook;
+export declare function getOnDataLoaderBatch(): ((info: DataLoaderBatchMetrics) => void) | undefined;
+export declare function getOnDataLoaderCacheHit(): ((info: DataLoaderCacheHitMetrics) => void) | undefined;
+export declare function getOnQueryCacheHit(): ((info: QueryCacheHitMetrics) => void) | undefined;

package/core/metrics.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setMetricsHook = setMetricsHook;
+exports.getMetricsHook = getMetricsHook;
+exports.getOnDataLoaderBatch = getOnDataLoaderBatch;
+exports.getOnDataLoaderCacheHit = getOnDataLoaderCacheHit;
+exports.getOnQueryCacheHit = getOnQueryCacheHit;
+let onDataLoaderBatch;
+let onDataLoaderCacheHit;
+let onQueryCacheHit;
+function setMetricsHook(hooks) {
+    onDataLoaderBatch = hooks?.onDataLoaderBatch;
+    onDataLoaderCacheHit = hooks?.onDataLoaderCacheHit;
+    onQueryCacheHit = hooks?.onQueryCacheHit;
+}
+function getMetricsHook() {
+    return {
+        onDataLoaderBatch,
+        onDataLoaderCacheHit,
+        onQueryCacheHit,
+    };
+}
+function getOnDataLoaderBatch() {
+    return onDataLoaderBatch;
+}
+function getOnDataLoaderCacheHit() {
+    return onDataLoaderCacheHit;
+}
+function getOnQueryCacheHit() {
+    return onQueryCacheHit;
+}

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

@@ -1,16 +1,18 @@
 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, } from "./core/ent";
+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,10 +52,13 @@ 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";
 export { IDViewer, LoggedOutViewer, IDViewerOptions } from "./core/viewer";
 export { loadConfig } from "./core/config";
 export { setLogLevels } from "./core/logger";
+export * from "./core/metrics";
 export * from "./core/convert";

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.DenyIfViewerInboundEdgeExistsRule = exports.DenyIfEdgeExistsRule = 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.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 = 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; } });
@@ -69,6 +69,8 @@ Object.defineProperty(exports, "loadRawEdgeCountX", { enumerable: true, get: fun
 Object.defineProperty(exports, "loadEdgeForID2", { enumerable: true, get: function () { return ent_1.loadEdgeForID2; } });
 Object.defineProperty(exports, "loadNodesByEdge", { enumerable: true, get: function () { return ent_1.loadNodesByEdge; } });
 Object.defineProperty(exports, "getEdgeTypeInGroup", { enumerable: true, get: function () { return ent_1.getEdgeTypeInGroup; } });
+Object.defineProperty(exports, "setEntLoaderPrivacyConcurrencyLimit", { enumerable: true, get: function () { return ent_1.setEntLoaderPrivacyConcurrencyLimit; } });
+Object.defineProperty(exports, "getEntLoaderPrivacyConcurrencyLimit", { enumerable: true, get: function () { return ent_1.getEntLoaderPrivacyConcurrencyLimit; } });
 // TODO should these even be exported from the root?
 var operations_1 = require("./action/operations");
 Object.defineProperty(exports, "EditNodeOperation", { enumerable: true, get: function () { return operations_1.EditNodeOperation; } });
@@ -77,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);
@@ -124,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,
@@ -163,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");
@@ -174,4 +183,5 @@ var config_1 = require("./core/config");
 Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return config_1.loadConfig; } });
 var logger_1 = require("./core/logger");
 Object.defineProperty(exports, "setLogLevels", { enumerable: true, get: function () { return logger_1.setLogLevels; } });
+__exportStar(require("./core/metrics"), exports);
 __exportStar(require("./core/convert"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",
@@ -9,17 +9,11 @@
   },
   "dependencies": {
     "@types/node": "^25.0.3",
-    "cosmiconfig": "^9.0.0",
     "dataloader": "^2.2.3",
     "glob": "^13.0.0",
-    "graph-data-structure": "^4.5.0",
     "js-yaml": "^4.1.1",
-    "json5": "^2.2.3",
     "luxon": "^3.7.2",
-    "memoizee": "^0.4.17",
-    "minimist": "^1.2.8",
     "pg": "^8.16.3",
-    "prettier": "^3.7.4",
     "ts-node": "^11.0.0-beta.1",
     "tsconfig-paths": "^4.2.0",
     "tslib": "^2.8.1",