@snowtop/ent 0.1.0-alpha15 → 0.1.0-alpha150

package/core/context.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { Viewer, Data, Loader } from "./base";
+import { Viewer, Data, Loader, LoaderWithLoadMany } from "./base";
 import { IncomingMessage, ServerResponse } from "http";
 import * as clause from "./clause";
 import { Context } from "./base";
@@ -11,7 +11,9 @@ export interface RequestContext<TViewer extends Viewer = Viewer> extends Context
 }
 export declare class ContextCache {
     loaders: Map<string, Loader<any, any>>;
-    getLoader<T, V>(name: string, create: () => Loader<T, V>): Loader<T, V>;
+    loaderWithLoadMany: Map<string, LoaderWithLoadMany<any, any>>;
+    getLoader<K, V>(name: string, create: () => Loader<K, V>): Loader<K, V>;
+    getLoaderWithLoadMany<K, V>(name: string, create: () => LoaderWithLoadMany<K, V>): LoaderWithLoadMany<K, V>;
     private itemMap;
     private listMap;
     private getkey;

package/core/context.js

@@ -5,6 +5,8 @@ const logger_1 = require("./logger");
 class ContextCache {
     constructor() {
         this.loaders = new Map();
+        // we should eventually combine the two but better for typing to be separate for now
+        this.loaderWithLoadMany = new Map();
         // we have a per-table map to make it easier to purge and have less things to compare with
         this.itemMap = new Map();
         this.listMap = new Map();
@@ -19,6 +21,16 @@ class ContextCache {
         this.loaders.set(name, l);
         return l;
     }
+    getLoaderWithLoadMany(name, create) {
+        let l = this.loaderWithLoadMany.get(name);
+        if (l) {
+            return l;
+        }
+        (0, logger_1.log)("debug", `new context-aware loader created for ${name}`);
+        l = create();
+        this.loaderWithLoadMany.set(name, l);
+        return l;
+    }
     // tableName is ignored bcos already indexed on that
     // maybe we just want to store sql queries???
     getkey(options) {
@@ -39,7 +51,7 @@ class ContextCache {
         const key = this.getkey(options);
         let rows = m.get(key);
         if (rows) {
-            (0, logger_1.log)("query", {
+            (0, logger_1.log)("cache", {
                 "cache-hit": key,
                 "tableName": options.tableName,
             });
@@ -54,7 +66,7 @@ class ContextCache {
         const key = this.getkey(options);
         let row = m.get(key);
         if (row) {
-            (0, logger_1.log)("query", {
+            (0, logger_1.log)("cache", {
                 "cache-hit": key,
                 "tableName": options.tableName,
             });
@@ -79,7 +91,13 @@ class ContextCache {
             // but may have some benefits by explicitily doing so?
             loader.clearAll();
         }
+        for (const [_key, loader] of this.loaderWithLoadMany) {
+            // may not need this since we're clearing the loaders themselves...
+            // but may have some benefits by explicitily doing so?
+            loader.clearAll();
+        }
         this.loaders.clear();
+        this.loaderWithLoadMany.clear();
         this.itemMap.clear();
         this.listMap.clear();
     }

package/core/convert.d.ts

@@ -10,5 +10,5 @@ export declare function convertBoolList(val: any): boolean[];
 export declare function convertNullableBoolList(val: any): boolean[] | null;
 export declare function convertJSON(val: any): any;
 export declare function convertNullableJSON(val: any): any | null;
-export declare function convertJSONList(val: any): boolean[];
+export declare function convertJSONList(val: any): any[];
 export declare function convertNullableJSONList(val: any): any[] | null;

package/core/date.js

@@ -10,11 +10,7 @@ function parseDate(val, throwErr) {
     else if (typeof val === "string") {
         dt = luxon_1.DateTime.fromISO(val);
         if (!dt.isValid) {
-            let ms = Date.parse(val);
-            if (ms === NaN) {
-                throw throwErr(`invalid input for type Time ${val}`);
-            }
-            dt = luxon_1.DateTime.fromMillis(ms);
+            dt = luxon_1.DateTime.fromMillis(Date.parse(val));
         }
     }
     else if (val instanceof Date) {

package/core/db.d.ts

@@ -5,10 +5,9 @@ export interface Database extends PoolConfig {
     password?: string;
     host?: string;
     port?: number;
-    ssl?: boolean;
     sslmode?: string;
 }
-export declare type env = "production" | "test" | "development";
+export type env = "production" | "test" | "development";
 export declare type DBDict = Partial<Record<env, Database>>;
 export declare enum Dialect {
     Postgres = "postgres",
@@ -19,6 +18,12 @@ interface DatabaseInfo {
     config: PoolConfig;
     filePath?: string;
 }
+interface clientConfigArgs {
+    connectionString?: string;
+    dbFile?: string;
+    db?: Database | DBDict;
+    cfg?: PoolConfig;
+}
 export default class DB {
     db: DatabaseInfo;
     static instance: DB;
@@ -29,15 +34,12 @@ export default class DB {
     getConnection(): Connection;
     getPool(): Queryer;
     getNewClient(): Promise<Client>;
-    getSQLiteClient(): Promise<Sqlite>;
+    getSQLiteClient(): Sqlite;
     endPool(): Promise<void>;
+    emitsExplicitTransactionStatements(): boolean;
     static getInstance(): DB;
     static getDialect(): Dialect;
-    static initDB(args?: {
-        connectionString?: string;
-        dbFile?: string;
-        db?: Database | DBDict;
-    }): void;
+    static initDB(args?: clientConfigArgs): void;
 }
 export declare const defaultTimestampParser: any;
 export interface Queryer {
@@ -54,6 +56,7 @@ export interface Connection extends Queryer {
     self(): Queryer;
     newClient(): Promise<Client>;
     close(): Promise<void>;
+    runInTransaction?(cb: () => void | Promise<void>): any;
 }
 export interface QueryResultRow {
     [column: string]: any;
@@ -78,6 +81,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/db.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -35,13 +39,14 @@ var Dialect;
     Dialect["Postgres"] = "postgres";
     Dialect["SQLite"] = "sqlite";
 })(Dialect = exports.Dialect || (exports.Dialect = {}));
-function parseConnectionString(str) {
+function parseConnectionString(str, args) {
     if (str.startsWith("sqlite:///")) {
         let filePath = str.substr(10);
         return {
             dialect: Dialect.SQLite,
             config: {
                 connectionString: str,
+                ...args?.cfg,
             },
             filePath,
         };
@@ -49,6 +54,7 @@ function parseConnectionString(str) {
     return {
         dialect: Dialect.Postgres,
         config: {
+            ...args?.cfg,
             connectionString: str,
         },
     };
@@ -63,12 +69,12 @@ function getClientConfig(args) {
     // if there's a db connection string, use that first
     const str = process.env.DB_CONNECTION_STRING;
     if (str) {
-        return parseConnectionString(str);
+        return parseConnectionString(str, args);
     }
     let file = "config/database.yml";
     if (args) {
         if (args.connectionString) {
-            return parseConnectionString(args.connectionString);
+            return parseConnectionString(args.connectionString, args);
         }
         if (args.db) {
             let db;
@@ -148,7 +154,7 @@ class DB {
     async getNewClient() {
         return this.q.newClient();
     }
-    async getSQLiteClient() {
+    getSQLiteClient() {
         if (this.db.dialect == Dialect.Postgres) {
             throw new Error(`can't call getSQLiteClient when dialect is postgres`);
         }
@@ -158,6 +164,10 @@ class DB {
     async endPool() {
         return this.q.close();
     }
+    emitsExplicitTransactionStatements() {
+        const instance = DB.getInstance();
+        return instance.q.runInTransaction === undefined;
+    }
     // throws if invalid
     static getInstance() {
         if (DB.instance) {
@@ -192,8 +202,6 @@ exports.defaultTimestampParser = pg_1.default.types.getTypeParser(pg_1.default.t
 // it's parsed as UTC time as opposed to the local time
 pg_1.default.types.setTypeParser(pg_1.default.types.builtins.TIMESTAMP, function (val) {
     return luxon_1.DateTime.fromSQL(val + "Z").toJSDate();
-    // let d = new Date(val + "Z");
-    // return d;
 });
 class Sqlite {
     constructor(db) {
@@ -230,6 +238,8 @@ class Sqlite {
             r = this.db.prepare(query).get(this.convertValues(values));
         }
         else {
+            // TODO querySync() with no values seems to do the wrong thing...
+            // e.g. querySync('select count(*) as count from table') returns nonsense
             r = this.db.prepare(query).run();
         }
         return {
@@ -312,7 +322,7 @@ class Postgres {
         };
     }
     async close() {
-        return this.pool.end();
+        return await this.pool.end();
     }
 }
 exports.Postgres = Postgres;

package/core/ent.d.ts

@@ -1,113 +1,92 @@
 import { Queryer, SyncQueryer } from "./db";
-import { Viewer, Ent, ID, LoadRowsOptions, LoadRowOptions, Data, DataOptions, QueryableDataOptions, EditRowOptions, LoadEntOptions, LoadCustomEntOptions, EdgeQueryableDataOptions, Context, SelectBaseDataOptions, CreateRowOptions, QueryDataOptions } from "./base";
-import { Executor } from "../action/action";
+import { Viewer, Ent, ID, LoadRowsOptions, LoadRowOptions, Data, DataOptions, QueryableDataOptions, EditRowOptions, LoadEntOptions, LoadCustomEntOptions, EdgeQueryableDataOptions, Context, CreateRowOptions, QueryDataOptions, SelectCustomDataOptions } from "./base";
 import * as clause from "./clause";
-import { Builder } from "../action";
 import DataLoader from "dataloader";
+export declare function getEntKey<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, id: ID, options: LoadEntOptions<TEnt, TViewer>): string;
 export declare function loadEnt<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, id: ID, options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt | null>;
 export declare function loadEntViaKey<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, key: any, options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt | null>;
 export declare function loadEntX<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, id: ID, options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt>;
 export declare function loadEntXViaKey<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, key: any, options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt>;
+/**
+ * @deprecated use loadCustomEnts
+ */
 export declare function loadEntFromClause<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, options: LoadEntOptions<TEnt, TViewer>, clause: clause.Clause): Promise<TEnt | null>;
+/**
+ * @deprecated use loadCustomEnts
+ */
 export declare function loadEntXFromClause<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, options: LoadEntOptions<TEnt, TViewer>, clause: clause.Clause): Promise<TEnt>;
 export declare function loadEnts<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, options: LoadEntOptions<TEnt, TViewer>, ...ids: ID[]): Promise<Map<ID, TEnt>>;
 export declare function loadEntsList<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, options: LoadEntOptions<TEnt, TViewer>, ...ids: ID[]): Promise<TEnt[]>;
+/**
+ * @deperecated use loadCustomEnts
+ */
 export declare function loadEntsFromClause<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, clause: clause.Clause, options: LoadEntOptions<TEnt, TViewer>): Promise<Map<ID, TEnt>>;
-export declare function loadCustomEnts<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, options: LoadCustomEntOptions<TEnt, TViewer>, query: CustomQuery): Promise<TEnt[]>;
-interface rawQueryOptions {
+export declare function loadCustomEnts<TEnt extends Ent<TViewer>, TViewer extends Viewer, TQueryData extends Data = Data, TResultData extends Data = TQueryData, TKey = keyof TQueryData>(viewer: TViewer, options: LoadCustomEntOptions<TEnt, TViewer, TResultData>, query: CustomQuery<TQueryData, TKey>): Promise<TEnt[]>;
+export interface parameterizedQueryOptions {
     query: string;
     values?: any[];
     logValues?: any[];
 }
-export declare type CustomQuery = string | rawQueryOptions | clause.Clause | QueryDataOptions;
-export declare function loadCustomData(options: SelectBaseDataOptions, query: CustomQuery, context: Context | undefined): Promise<Data[]>;
+export type CustomQuery<T extends Data = Data, K = keyof T> = string | parameterizedQueryOptions | clause.Clause<T, K> | QueryDataOptions<T, K>;
+/**
+ * Note that if there's default read transformations (e.g. soft delete) and a clause is passed in
+ * either as Clause or QueryDataOptions without {disableTransformations: true}, the default transformation
+ * (e.g. soft delete) is applied.
+ *
+ * Passing a full SQL string or Paramterized SQL string doesn't apply it and the given string is sent to the
+ * database as written.
+ *
+ * e.g.
+ * Foo.loadCustom(opts, 'SELECT * FROM foo') // doesn't change the query
+ * Foo.loadCustom(opts, { query: 'SELECT * FROM foo WHERE id = ?', values: [1]}) // doesn't change the query
+ * Foo.loadCustom(opts, query.Eq('time', Date.now())) // changes the query
+ * Foo.loadCustom(opts, {
+ *   clause:  query.LessEq('time', Date.now()),
+ *   limit: 100,
+ *   orderby: 'time',
+ *  }) // changes the query
+ * Foo.loadCustom(opts, {
+ *   clause:  query.LessEq('time', Date.now()),
+ *   limit: 100,
+ *   orderby: 'time',
+ *   disableTransformations: false
+ *  }) // doesn't change the query
+ *
+ * For queries that pass in a clause, we batch them with an underlying dataloader so that multiple queries with the same clause
+ * or parallel queries with the same clause are batched together.
+ *
+ * If a raw or parameterized query is passed in, we don't attempt to batch them together and they're executed as is.
+ * If you end up with a scenario where you may need to coalesce or batch (non-clause) queries here, you should use some kind of memoization here.
+ */
+export declare function loadCustomData<TQueryData extends Data = Data, TResultData extends Data = TQueryData, K = keyof TQueryData>(options: SelectCustomDataOptions<TResultData>, query: CustomQuery<TQueryData, K>, context: Context | undefined): Promise<TResultData[]>;
+export declare function loadCustomCount<T extends Data = Data, K = keyof T>(options: SelectCustomDataOptions<T>, query: CustomQuery<T, K>, context: Context | undefined): Promise<number>;
 export declare function loadDerivedEnt<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, data: Data, loader: new (viewer: TViewer, data: Data) => TEnt): Promise<TEnt | null>;
 export declare function loadDerivedEntX<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, data: Data, loader: new (viewer: TViewer, data: Data) => TEnt): Promise<TEnt>;
+export declare function logQuery(query: string, logValues: any[]): void;
 export declare function loadRowX(options: LoadRowOptions): Promise<Data>;
 export declare function loadRow(options: LoadRowOptions): Promise<Data | null>;
+export declare function ___setLogQueryErrorWithError(val: boolean | undefined): void;
 export declare function performRawQuery(query: string, values: any[], logValues?: any[]): Promise<Data[]>;
 export declare function loadRows(options: LoadRowsOptions): Promise<Data[]>;
 export declare function buildQuery(options: QueryableDataOptions): string;
-interface GroupQueryOptions {
+interface GroupQueryOptions<T extends Data, K = keyof T> {
     tableName: string;
-    clause?: clause.Clause;
-    groupColumn: string;
-    fields: string[];
+    clause?: clause.Clause<T, K>;
+    groupColumn: K;
+    fields: K[];
     values: any[];
     orderby?: string;
     limit: number;
 }
-export declare function buildGroupQuery(options: GroupQueryOptions): [string, clause.Clause];
-export interface DataOperation<T extends Ent = Ent> {
-    preFetch?(queryer: Queryer, context?: Context): Promise<void>;
-    performWriteSync(queryer: SyncQueryer, context?: Context): void;
-    performWrite(queryer: Queryer, context?: Context): Promise<void>;
-    placeholderID?: ID;
-    returnedRow?(): Data | null;
-    createdEnt?(viewer: Viewer): T | null;
-    resolve?(executor: Executor): void;
-    postFetch?(queryer: Queryer, context?: Context): Promise<void>;
-}
-export interface EditNodeOptions<T extends Ent> extends EditRowOptions {
-    fieldsToResolve: string[];
-    loadEntOptions: LoadEntOptions<T>;
-    placeholderID?: ID;
-}
-export declare class EditNodeOperation<T extends Ent> implements DataOperation {
-    options: EditNodeOptions<T>;
-    private existingEnt;
-    row: Data | null;
-    placeholderID?: ID | undefined;
-    constructor(options: EditNodeOptions<T>, existingEnt?: Ent | null);
-    resolve<T extends Ent>(executor: Executor): void;
-    private hasData;
-    performWrite(queryer: Queryer, context?: Context): Promise<void>;
-    private reloadRow;
-    performWriteSync(queryer: SyncQueryer, context?: Context): void;
-    returnedRow(): Data | null;
-    createdEnt(viewer: Viewer): T | null;
-}
-export declare class EdgeOperation implements DataOperation {
-    edgeInput: AssocEdgeInput;
-    private options;
-    private edgeData;
-    private constructor();
-    preFetch(queryer: Queryer, context?: Context): Promise<void>;
-    performWrite(queryer: Queryer, context?: Context): Promise<void>;
-    performWriteSync(queryer: SyncQueryer, context?: Context): void;
-    private getDeleteRowParams;
-    private performDeleteWrite;
-    private performDeleteWriteSync;
-    private getInsertRowParams;
-    private performInsertWrite;
-    private performInsertWriteSync;
-    private resolveImpl;
-    resolve(executor: Executor): void;
-    symmetricEdge(): EdgeOperation;
-    inverseEdge(edgeData: AssocEdgeData): EdgeOperation;
-    private static resolveIDs;
-    private static isBuilder;
-    private static resolveData;
-    static inboundEdge<T extends Ent, T2 extends Ent>(builder: Builder<T>, edgeType: string, id1: Builder<T2> | ID, nodeType: string, options?: AssocEdgeInputOptions): EdgeOperation;
-    static outboundEdge<T extends Ent, T2 extends Ent>(builder: Builder<T>, edgeType: string, id2: Builder<T2> | ID, nodeType: string, options?: AssocEdgeInputOptions): EdgeOperation;
-    static removeInboundEdge<T extends Ent>(builder: Builder<T>, edgeType: string, id1: ID): EdgeOperation;
-    static removeOutboundEdge<T extends Ent>(builder: Builder<T>, edgeType: string, id2: ID): EdgeOperation;
-}
+export declare function buildGroupQuery<T extends Data = Data, K = keyof T>(options: GroupQueryOptions<T, K>): [string, clause.Clause<T, K>];
 export declare function buildInsertQuery(options: CreateRowOptions, suffix?: string): [string, string[], string[]];
 export declare function createRow(queryer: Queryer, options: CreateRowOptions, suffix: string): Promise<Data | null>;
 export declare function createRowSync(queryer: SyncQueryer, options: CreateRowOptions, suffix: string): Data | null;
-export declare function buildUpdateQuery(options: EditRowOptions, id: ID, suffix?: string): [string, any[], any[]];
-export declare function editRow(queryer: Queryer, options: EditRowOptions, id: ID, suffix?: string): Promise<Data | null>;
-export declare function editRowSync(queryer: SyncQueryer, options: EditRowOptions, id: ID, suffix?: string): Data | null;
+export declare function buildUpdateQuery(options: EditRowOptions, suffix?: string): [string, any[], any[]];
+export declare function editRow(queryer: Queryer, options: EditRowOptions, suffix?: string): Promise<Data | null>;
+export declare function editRowSync(queryer: SyncQueryer, options: EditRowOptions, suffix?: string): Data | null;
 export declare function deleteRows(queryer: Queryer, options: DataOptions, cls: clause.Clause): Promise<void>;
 export declare function deleteRowsSync(queryer: SyncQueryer, options: DataOptions, cls: clause.Clause): void;
-export declare class DeleteNodeOperation implements DataOperation {
-    private id;
-    private options;
-    constructor(id: ID, options: DataOptions);
-    performWrite(queryer: Queryer, context?: Context): Promise<void>;
-    performWriteSync(queryer: SyncQueryer, context?: Context): void;
-}
 export declare class AssocEdge {
     id1: ID;
     id1Type: string;
@@ -116,7 +95,9 @@ export declare class AssocEdge {
     id2Type: string;
     time: Date;
     data?: string | null;
+    private rawData;
     constructor(data: Data);
+    __getRawData(): Data;
     getCursor(): string;
 }
 interface cursorOptions {
@@ -126,17 +107,6 @@ interface cursorOptions {
     conv?: (any: any) => any;
 }
 export declare function getCursor(opts: cursorOptions): string;
-export interface AssocEdgeInputOptions {
-    time?: Date;
-    data?: string | Builder<Ent>;
-}
-export interface AssocEdgeInput extends AssocEdgeInputOptions {
-    id1: ID;
-    id1Type: string;
-    edgeType: string;
-    id2: ID;
-    id2Type: string;
-}
 export declare class AssocEdgeData {
     edgeType: string;
     edgeName: string;
@@ -145,7 +115,7 @@ export declare class AssocEdgeData {
     edgeTable: string;
     constructor(data: Data);
 }
-export declare const assocEdgeLoader: DataLoader<any, any, any>;
+export declare const assocEdgeLoader: DataLoader<ID, Data | null, ID>;
 export declare function loadEdgeData(edgeType: string): Promise<AssocEdgeData | null>;
 export declare function loadEdgeDatas(...edgeTypes: string[]): Promise<Map<string, AssocEdgeData>>;
 export interface AssocEdgeConstructor<T extends AssocEdge> {
@@ -156,13 +126,18 @@ interface loadEdgesOptions {
     edgeType: string;
     context?: Context;
     queryOptions?: EdgeQueryableDataOptions;
+    disableTransformations?: boolean;
 }
 interface loadCustomEdgesOptions<T extends AssocEdge> extends loadEdgesOptions {
     ctr: AssocEdgeConstructor<T>;
 }
-export declare const DefaultLimit = 1000;
-export declare function defaultEdgeQueryOptions(id1: ID, edgeType: string): EdgeQueryableDataOptions;
+export declare function setDefaultLimit(limit: number): void;
+export declare function getDefaultLimit(): number;
 export declare function loadEdges(options: loadEdgesOptions): Promise<AssocEdge[]>;
+export declare function getEdgeClauseAndFields(cls: clause.Clause, options: Pick<loadEdgesOptions, "disableTransformations">): {
+    cls: clause.Clause<Data, string | number>;
+    fields: string[];
+};
 export declare function loadCustomEdges<T extends AssocEdge>(options: loadCustomEdgesOptions<T>): Promise<T[]>;
 export declare function loadUniqueEdge(options: loadEdgesOptions): Promise<AssocEdge | null>;
 export declare function loadUniqueNode<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, id1: ID, edgeType: string, options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt | null>;
@@ -172,8 +147,7 @@ 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<T extends Ent>(viewer: Viewer, options: LoadEntOptions<T>, row: Data | null): Promise<T | null>;
-export declare function applyPrivacyPolicyForRowX<T extends Ent>(viewer: Viewer, options: LoadEntOptions<T>, row: Data): Promise<T>;
-export declare function applyPrivacyPolicyForRows<T extends Ent>(viewer: Viewer, rows: Data[], options: LoadEntOptions<T>): Promise<Map<ID, 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<TEnt[]>;
 export declare function getEdgeTypeInGroup<T extends string>(viewer: Viewer, id1: ID, id2: ID, m: Map<T, string>): Promise<[T, AssocEdge] | undefined>;
 export {};