@snowtop/ent 0.1.0-alpha81 → 0.1.0-alpha87

package/action/action.d.ts

@@ -1,14 +1,16 @@
-import { Ent, EntConstructor, Viewer, ID, Data, PrivacyPolicy, Context } from "../core/base";
+import { Ent, EntConstructor, Viewer, ID, Data, PrivacyPolicy, Context, WriteOperation } from "../core/base";
 import { DataOperation, AssocEdgeInputOptions } from "../core/ent";
 import { Queryer } from "../core/db";
 import { TransformedUpdateOperation, UpdateOperation } from "../schema";
-export declare enum WriteOperation {
-    Insert = "insert",
-    Edit = "edit",
-    Delete = "delete"
-}
+import { FieldInfoMap } from "../schema/schema";
+export { WriteOperation };
 declare type MaybeNull<T extends Ent> = T | null;
 declare type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
+interface BuilderOrchestrator {
+    __getOptions(): {
+        fieldInfo: FieldInfoMap;
+    };
+}
 export interface Builder<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
     existingEnt: TExistingEnt;
     ent: EntConstructor<TEnt, TViewer>;
@@ -18,6 +20,8 @@ export interface Builder<TEnt extends Ent<TViewer>, TViewer extends Viewer = Vie
     operation: WriteOperation;
     editedEnt?(): Promise<TEnt | null>;
     nodeType: string;
+    getInput(): Data;
+    orchestrator: BuilderOrchestrator;
 }
 export interface Executor extends Iterable<DataOperation>, Iterator<DataOperation> {
     placeholderID: ID;
@@ -66,4 +70,3 @@ interface Orchestrator {
     viewer: Viewer;
 }
 export declare function setEdgeTypeInGroup<T extends string>(orchestrator: Orchestrator, inputEnumValue: string, id1: ID, id2: ID, nodeType: string, m: Map<T, string>): Promise<void>;
-export {};

package/action/action.js

@@ -1,14 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setEdgeTypeInGroup = exports.saveBuilderX = exports.saveBuilder = exports.WriteOperation = void 0;
+const base_1 = require("../core/base");
+Object.defineProperty(exports, "WriteOperation", { enumerable: true, get: function () { return base_1.WriteOperation; } });
 const ent_1 = require("../core/ent");
 const logger_1 = require("../core/logger");
-var WriteOperation;
-(function (WriteOperation) {
-    WriteOperation["Insert"] = "insert";
-    WriteOperation["Edit"] = "edit";
-    WriteOperation["Delete"] = "delete";
-})(WriteOperation = exports.WriteOperation || (exports.WriteOperation = {}));
 async function saveBuilder(builder) {
     await saveBuilderImpl(builder, false);
 }

package/action/orchestrator.d.ts

@@ -49,6 +49,7 @@ export declare class Orchestrator<TEnt extends Ent<TViewer>, TInput extends Data
     private disableTransformations;
     private memoizedGetFields;
     constructor(options: OrchestratorOptions<TEnt, TInput, TViewer, TExistingEnt>);
+    __getOptions(): OrchestratorOptions<any, any, any, any>;
     private addEdge;
     setDisableTransformations(val: boolean): void;
     addInboundEdge<T2 extends Ent>(id1: ID | Builder<T2, any>, edgeType: string, nodeType: string, options?: AssocEdgeInputOptions): void;

package/action/orchestrator.js

@@ -88,6 +88,10 @@ class Orchestrator {
         this.existingEnt = this.options.builder.existingEnt;
         this.memoizedGetFields = (0, memoizee_1.default)(this.getFieldsInfo.bind(this));
     }
+    // don't type this because we don't care
+    __getOptions() {
+        return this.options;
+    }
     addEdge(edge, op) {
         this.edgeSet.add(edge.edgeType);
         let m1 = this.edges.get(edge.edgeType) || new Map();
@@ -607,8 +611,12 @@ class Orchestrator {
         // build up data to be saved...
         let data = {};
         let logValues = {};
+        let needsFullDataChecks = [];
         for (const [fieldName, field] of schemaFields) {
             let value = editedFields.get(fieldName);
+            if (field.validateWithFullData) {
+                needsFullDataChecks.push(fieldName);
+            }
             if (value === undefined && op === action_1.WriteOperation.Insert) {
                 // null allowed
                 value = this.defaultFieldsByFieldName[fieldName];
@@ -626,6 +634,21 @@ class Orchestrator {
                 logValues[dbKey] = field.logValue(value);
             }
         }
+        for (const fieldName of needsFullDataChecks) {
+            const field = schemaFields.get(fieldName);
+            let value = editedFields.get(fieldName);
+            // @ts-ignore...
+            // type hackery because it's hard
+            const v = await field.validateWithFullData(value, this.options.builder);
+            if (!v) {
+                if (value === undefined) {
+                    errors.push(new Error(`field ${fieldName} set to undefined when it can't be nullable`));
+                }
+                else {
+                    errors.push(new Error(`field ${fieldName} set to null when it can't be nullable`));
+                }
+            }
+        }
         //  we ignored default values while editing.
         // if we're editing and there's data, add default values
         if (op === action_1.WriteOperation.Edit && this.hasData(data)) {

package/core/base.d.ts

@@ -5,12 +5,12 @@ export interface Loader<T, V> {
     loadMany?(keys: T[]): Promise<(V | null)[]>;
     clearAll(): any;
 }
-interface LoaderWithLoadMany<T, V> extends Loader<T, V> {
-    loadMany(keys: T[]): Promise<(V | null)[]>;
+export interface LoaderWithLoadMany<T, V> extends Loader<T, V> {
+    loadMany(keys: T[]): Promise<V[]>;
 }
-export interface LoaderFactory<T, V> {
+export interface LoaderFactory<K, V> {
     name: string;
-    createLoader(context?: Context): Loader<T, V>;
+    createLoader(context?: Context): Loader<K, V>;
 }
 interface LoaderFactoryWithLoaderMany<T, V> extends LoaderFactory<T, V> {
     createLoader(context?: Context): LoaderWithLoadMany<T, V>;
@@ -25,12 +25,12 @@ export interface PrimableLoader<T, V> extends Loader<T, V> {
 }
 interface cache {
     getLoader<T, V>(name: string, create: () => Loader<T, V>): Loader<T, V>;
+    getLoaderWithLoadMany<T, V>(name: string, create: () => LoaderWithLoadMany<T, V>): LoaderWithLoadMany<T, V>;
     getCachedRows(options: queryOptions): Data[] | null;
     getCachedRow(options: queryOptions): Data | null;
     primeCache(options: queryOptions, rows: Data[]): void;
     primeCache(options: queryOptions, rows: Data): void;
     clearCache(): void;
-    getEntCache(): Map<string, Ent | Error | null>;
 }
 interface queryOptions {
     fields: string[];
@@ -143,4 +143,9 @@ export interface PrivacyPolicyRule<TEnt extends Ent = Ent, TViewer = Viewer> {
 export interface PrivacyPolicy<TEnt extends Ent = Ent, TViewer = Viewer> {
     rules: PrivacyPolicyRule<TEnt, TViewer>[];
 }
+export declare enum WriteOperation {
+    Insert = "insert",
+    Edit = "edit",
+    Delete = "delete"
+}
 export {};

package/core/base.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DenyWithReason = exports.Deny = exports.Skip = exports.Allow = void 0;
+exports.WriteOperation = exports.DenyWithReason = exports.Deny = exports.Skip = exports.Allow = void 0;
 // Privacy
 var privacyResult;
 (function (privacyResult) {
@@ -53,3 +53,9 @@ function DenyWithReason(e) {
     };
 }
 exports.DenyWithReason = DenyWithReason;
+var WriteOperation;
+(function (WriteOperation) {
+    WriteOperation["Insert"] = "insert";
+    WriteOperation["Edit"] = "edit";
+    WriteOperation["Delete"] = "delete";
+})(WriteOperation = exports.WriteOperation || (exports.WriteOperation = {}));

package/core/context.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { Viewer, Data, Loader, Ent } from "./base";
+import { Viewer, Data, Loader, LoaderWithLoadMany } from "./base";
 import { IncomingMessage, ServerResponse } from "http";
 import * as clause from "./clause";
 import { Context } from "./base";
@@ -11,17 +11,17 @@ export interface RequestContext<TViewer extends Viewer = Viewer> extends Context
 }
 export declare class ContextCache {
     loaders: Map<string, Loader<any, any>>;
+    loaderWithLoadMany: Map<string, LoaderWithLoadMany<any, any>>;
     getLoader<T, V>(name: string, create: () => Loader<T, V>): Loader<T, V>;
+    getLoaderWithLoadMany<T, V>(name: string, create: () => LoaderWithLoadMany<T, V>): LoaderWithLoadMany<T, V>;
     private itemMap;
     private listMap;
-    private entCache;
     private getkey;
     getCachedRows(options: queryOptions): Data[] | null;
     getCachedRow(options: queryOptions): Data | null;
     primeCache(options: queryOptions, rows: Data[]): void;
     primeCache(options: queryOptions, rows: Data): void;
     clearCache(): void;
-    getEntCache(): Map<string, Error | Ent<any> | null>;
 }
 interface queryOptions {
     fields: string[];

package/core/context.js

@@ -5,10 +5,11 @@ 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();
-        this.entCache = new Map();
     }
     getLoader(name, create) {
         let l = this.loaders.get(name);
@@ -20,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) {
@@ -80,13 +91,15 @@ 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();
-        this.entCache.clear();
-    }
-    getEntCache() {
-        return this.entCache;
     }
 }
 exports.ContextCache = ContextCache;

package/core/ent.d.ts

@@ -225,7 +225,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<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, options: LoadEntOptions<TEnt, TViewer>, row: Data | null): Promise<TEnt | null>;
+export declare function applyPrivacyPolicyForRow<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, options: LoadEntOptions<TEnt, TViewer>, row: Data): Promise<TEnt | null>;
 export declare function applyPrivacyPolicyForRows<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, rows: Data[], options: LoadEntOptions<TEnt, TViewer>): Promise<Map<ID, TEnt>>;
 export declare function getEdgeTypeInGroup<T extends string>(viewer: Viewer, id1: ID, id2: ID, m: Map<T, string>): Promise<[T, AssocEdge] | undefined>;
 export {};

package/core/ent.js

@@ -57,6 +57,34 @@ class cacheMap {
         return this.m.clear();
     }
 }
+class entCacheMap {
+    constructor(viewer, options) {
+        this.viewer = viewer;
+        this.options = options;
+        this.m = new Map();
+        this.logEnabled = false;
+        this.logEnabled = (0, logger_1.logEnabled)("cache");
+    }
+    get(id) {
+        const ret = this.m.get(id);
+        if (this.logEnabled && ret) {
+            const key = getEntKey(this.viewer, id, this.options);
+            (0, logger_1.log)("cache", {
+                "ent-cache-hit": key,
+            });
+        }
+        return ret;
+    }
+    set(key, value) {
+        return this.m.set(key, value);
+    }
+    delete(key) {
+        return this.m.delete(key);
+    }
+    clear() {
+        return this.m.clear();
+    }
+}
 function createDataLoader(options) {
     const loaderOptions = {};
     // if query logging is enabled, we should log what's happening with loader
@@ -87,60 +115,116 @@ function createDataLoader(options) {
         return result;
     }, loaderOptions);
 }
-function getEntKey(viewer, id, options) {
-    return `${viewer.instanceKey()}:${options.loaderFactory.name}:${id}`;
-}
-exports.getEntKey = getEntKey;
-// fetches the ent from cache if cache exists.
-function entFromCacheMaybe(viewer, id, options) {
-    const cache = viewer.context?.cache?.getEntCache();
-    if (!cache) {
-        return {};
-    }
-    const key = getEntKey(viewer, id, options);
-    const r = cache.get(key);
-    if (r !== undefined) {
-        (0, logger_1.log)("cache", {
-            "ent-cache-hit": key,
-        });
+// used to wrap errors that would eventually be thrown in ents
+// not an Error because DataLoader automatically rejects that
+class ErrorWrapper {
+    constructor(error) {
+        this.error = error;
     }
-    return {
-        key,
-        ent: r instanceof Error ? undefined : r,
-        error: r instanceof Error ? r : undefined,
-        cache,
-    };
 }
-// Ent accessors
-async function applyPrivacyPolicyForRowAndStoreInCache(viewer, options, row, info) {
-    const ent = await applyPrivacyPolicyForRow(viewer, options, row);
-    if (info.cache && info.key) {
-        info.cache.set(info.key, ent);
-    }
-    return ent instanceof Error ? null : ent;
+function createEntLoader(viewer, options, map) {
+    // share the cache across loaders even if we create a new instance
+    const loaderOptions = {};
+    loaderOptions.cacheMap = map;
+    return new dataloader_1.default(async (ids) => {
+        if (!ids.length) {
+            return [];
+        }
+        let result = [];
+        const loader = options.loaderFactory.createLoader(viewer.context);
+        const rows = await loader.loadMany(ids);
+        // this is a loader which should return the same order based on passed-in ids
+        // so let's depend on that...
+        for (let idx = 0; idx < rows.length; idx++) {
+            const row = rows[idx];
+            // db error
+            if (row instanceof Error) {
+                result[idx] = row;
+                continue;
+            }
+            else if (!row) {
+                result[idx] = new ErrorWrapper(new Error(`couldn't find row for value ${ids[idx]}`));
+            }
+            else {
+                const r = await applyPrivacyPolicyForRowImpl(viewer, options, row);
+                if (r instanceof Error) {
+                    result[idx] = new ErrorWrapper(r);
+                }
+                else {
+                    result[idx] = r;
+                }
+            }
+        }
+        return result;
+    }, loaderOptions);
 }
-async function applyPrivacyPolicyForRowAndStoreInCacheX(viewer, options, row, info) {
-    const ent = await applyPrivacyPolicyForRowImpl(viewer, options, row);
-    if (info.cache && info.key) {
-        info.cache.set(info.key, ent);
+class EntLoader {
+    constructor(viewer, options) {
+        this.viewer = viewer;
+        this.options = options;
+        this.map = new entCacheMap(viewer, options);
+        this.loader = createEntLoader(this.viewer, this.options, this.map);
     }
-    if (ent instanceof Error) {
-        throw ent;
+    getMap() {
+        return this.map;
     }
-    if (ent === null) {
-        throw new Error(`applyPrivacyPolicyForRowImpl returned null when it shouldn't. ent error`);
+    async load(id) {
+        return this.loader.load(id);
+    }
+    async loadMany(ids) {
+        return this.loader.loadMany(ids);
+    }
+    prime(id, ent) {
+        this.loader.prime(id, ent);
+    }
+    clear(id) {
+        this.loader.clear(id);
+    }
+    clearAll() {
+        this.loader.clearAll();
     }
-    return ent;
 }
-async function loadEnt(viewer, id, options) {
-    const info = entFromCacheMaybe(viewer, id, options);
-    if (info.ent !== undefined) {
-        return info.ent;
+function getEntLoader(viewer, options) {
+    if (!viewer.context?.cache) {
+        return new EntLoader(viewer, options);
     }
-    const row = await options.loaderFactory.createLoader(viewer.context).load(id);
-    return applyPrivacyPolicyForRowAndStoreInCache(viewer, options, row, info);
+    const name = `ent-loader:${viewer.instanceKey()}:${options.loaderFactory.name}`;
+    return viewer.context.cache.getLoaderWithLoadMany(name, () => new EntLoader(viewer, options));
+}
+function getEntKey(viewer, id, options) {
+    return `${viewer.instanceKey()}:${options.loaderFactory.name}:${id}`;
+}
+exports.getEntKey = getEntKey;
+async function loadEnt(viewer, id, options) {
+    const r = await getEntLoader(viewer, options).load(id);
+    return r instanceof ErrorWrapper ? null : r;
 }
 exports.loadEnt = loadEnt;
+async function applyPrivacyPolicyForRowAndStoreInEntLoader(viewer, row, options, 
+// can pass in loader when calling this for multi-id cases...
+loader) {
+    if (!loader) {
+        loader = getEntLoader(viewer, options);
+    }
+    // TODO every row.id needs to be audited...
+    // https://github.com/lolopinto/ent/issues/1064
+    const id = row.id;
+    // we should check the ent loader cache to see if this is already there
+    // TODO hmm... we eventually need a custom data-loader for this too so that it's all done correctly if there's a complicated fetch deep down in graphql
+    const result = loader.getMap().get(id);
+    if (result !== undefined) {
+        return result;
+    }
+    const r = await applyPrivacyPolicyForRowImpl(viewer, options, row);
+    if (r instanceof Error) {
+        loader.prime(id, new ErrorWrapper(r));
+        return new ErrorWrapper(r);
+    }
+    else {
+        loader.prime(id, r);
+        return r;
+    }
+}
 // this is the same implementation-wise (right now) as loadEnt. it's just clearer that it's not loaded via ID.
 // used for load via email address etc
 async function loadEntViaKey(viewer, key, options) {
@@ -150,29 +234,16 @@ async function loadEntViaKey(viewer, key, options) {
     if (!row) {
         return null;
     }
-    // TODO every row.id needs to be audited...
-    // https://github.com/lolopinto/ent/issues/1064
-    const info = entFromCacheMaybe(viewer, row.id, options);
-    if (info.ent !== undefined) {
-        return info.ent;
-    }
-    return applyPrivacyPolicyForRowAndStoreInCache(viewer, options, row, info);
+    const r = await applyPrivacyPolicyForRowAndStoreInEntLoader(viewer, row, options);
+    return r instanceof ErrorWrapper ? null : r;
 }
 exports.loadEntViaKey = loadEntViaKey;
 async function loadEntX(viewer, id, options) {
-    const info = entFromCacheMaybe(viewer, id, options);
-    if (info.error !== undefined) {
-        throw info.error;
-    }
-    if (info.ent !== undefined && info.ent !== null) {
-        return info.ent;
-    }
-    const row = await options.loaderFactory.createLoader(viewer.context).load(id);
-    if (!row) {
-        // todo make this better
-        throw new Error(`${options.loaderFactory.name}: couldn't find row for value ${id}`);
+    const r = await getEntLoader(viewer, options).load(id);
+    if (r instanceof ErrorWrapper) {
+        throw r.error;
     }
-    return applyPrivacyPolicyForRowAndStoreInCacheX(viewer, options, row, info);
+    return r;
 }
 exports.loadEntX = loadEntX;
 async function loadEntXViaKey(viewer, key, options) {
@@ -183,14 +254,11 @@ async function loadEntXViaKey(viewer, key, options) {
         // todo make this better
         throw new Error(`${options.loaderFactory.name}: couldn't find row for value ${key}`);
     }
-    const info = entFromCacheMaybe(viewer, row.id, options);
-    if (info.error !== undefined) {
-        throw info.error;
-    }
-    if (info.ent !== undefined && info.ent !== null) {
-        return info.ent;
+    const r = await applyPrivacyPolicyForRowAndStoreInEntLoader(viewer, row, options);
+    if (r instanceof ErrorWrapper) {
+        throw r.error;
     }
-    return applyPrivacyPolicyForRowAndStoreInCacheX(viewer, options, row, info);
+    return r;
 }
 exports.loadEntXViaKey = loadEntXViaKey;
 /**
@@ -203,6 +271,9 @@ async function loadEntFromClause(viewer, options, clause) {
         context: viewer.context,
     };
     const row = await loadRow(rowOptions);
+    if (row === null) {
+        return null;
+    }
     return applyPrivacyPolicyForRow(viewer, options, row);
 }
 exports.loadEntFromClause = loadEntFromClause;
@@ -228,62 +299,15 @@ async function loadEnts(viewer, options, ...ids) {
     }
     // result
     let m = new Map();
-    const cache = viewer.context?.cache?.getEntCache();
-    let toFetch = [];
-    if (cache) {
-        for (const id of ids) {
-            const key = getEntKey(viewer, id, options);
-            const ent = cache.get(key);
-            if (ent !== undefined) {
-                (0, logger_1.log)("cache", {
-                    "ent-cache-hit": key,
-                });
-                if (ent === null) {
-                    // TODO this should return null if not loadable...
-                    // https://github.com/lolopinto/ent/issues/1070
-                    continue;
-                }
-                // @ts-ignore
-                m.set(id, ent);
-            }
-            else {
-                toFetch.push(id);
-            }
+    const ret = await getEntLoader(viewer, options).loadMany(ids);
+    for (const r of ret) {
+        if (r instanceof Error) {
+            throw r;
         }
-    }
-    else {
-        toFetch = ids;
-    }
-    // all in ent cache!
-    if (!toFetch.length) {
-        return m;
-    }
-    const l = options.loaderFactory.createLoader(viewer.context);
-    const rows = await l.loadMany(toFetch);
-    let rows2 = [];
-    for (const row of rows) {
-        if (!row) {
+        if (r instanceof ErrorWrapper) {
             continue;
         }
-        if (row instanceof Error) {
-            throw row;
-        }
-        rows2.push(row);
-    }
-    const m2 = await applyPrivacyPolicyForRows(viewer, rows2, options);
-    for (const row of rows2) {
-        const id = row[options.loaderFactory.options?.key || "id"];
-        const ent = m2.get(id);
-        if (cache) {
-            // put back in cache...
-            // store null for rows that can't be seen
-            cache.set(getEntKey(viewer, id, options), ent ?? null);
-        }
-        if (ent !== undefined) {
-            // TODO this should return null if not loadable...?
-            // TODO https://github.com/lolopinto/ent/issues/1070
-            m.set(id, ent);
-        }
+        m.set(r.id, r);
     }
     return m;
 }
@@ -320,23 +344,16 @@ exports.loadEntsFromClause = loadEntsFromClause;
 async function loadCustomEnts(viewer, options, query) {
     const rows = await loadCustomData(options, query, viewer.context);
     const result = new Array(rows.length);
+    if (!rows.length) {
+        return [];
+    }
+    const entLoader = getEntLoader(viewer, options);
     await Promise.all(rows.map(async (row, idx) => {
-        // TODO what if key is different
-        // TODO https://github.com/lolopinto/ent/issues/1064
-        const info = entFromCacheMaybe(viewer, row.id, options);
-        if (info.ent !== undefined) {
-            if (info.ent === null) {
-                // we're done here
-                return;
-            }
-            // @ts-ignore
-            result[idx] = info.ent;
+        const r = await applyPrivacyPolicyForRowAndStoreInEntLoader(viewer, row, options, entLoader);
+        if (r instanceof ErrorWrapper) {
             return;
         }
-        const privacyEnt = await applyPrivacyPolicyForRowAndStoreInCache(viewer, options, row, info);
-        if (privacyEnt) {
-            result[idx] = privacyEnt;
-        }
+        result[idx] = r;
     }));
     // filter ents that aren't visible because of privacy
     return result.filter((r) => r !== undefined);
@@ -457,14 +474,11 @@ exports.loadDerivedEntX = loadDerivedEntX;
 // everything calls into this two so should be fine
 // TODO is there a smarter way to not instantiate two objects here?
 async function applyPrivacyPolicyForEnt(viewer, ent, data, fieldPrivacyOptions) {
-    if (ent) {
-        const error = await (0, privacy_1.applyPrivacyPolicyImpl)(viewer, ent.getPrivacyPolicy(), ent);
-        if (error === null) {
-            return doFieldPrivacy(viewer, ent, data, fieldPrivacyOptions);
-        }
-        return error;
+    const error = await (0, privacy_1.applyPrivacyPolicyImpl)(viewer, ent.getPrivacyPolicy(), ent);
+    if (error === null) {
+        return doFieldPrivacy(viewer, ent, data, fieldPrivacyOptions);
     }
-    return null;
+    return error;
 }
 async function applyPrivacyPolicyForEntX(viewer, ent, data, options) {
     const r = await applyPrivacyPolicyForEnt(viewer, ent, data, options);
@@ -1505,9 +1519,6 @@ async function applyPrivacyPolicyForRow(viewer, options, row) {
 }
 exports.applyPrivacyPolicyForRow = applyPrivacyPolicyForRow;
 async function applyPrivacyPolicyForRowImpl(viewer, options, row) {
-    if (!row) {
-        return null;
-    }
     const ent = new options.ent(viewer, row);
     return applyPrivacyPolicyForEnt(viewer, ent, row, options);
 }

package/core/loaders/object_loader.d.ts

@@ -11,7 +11,7 @@ export declare class ObjectLoader<T> implements Loader<T, Data | null> {
     private initPrime;
     load(key: T): Promise<Data | null>;
     clearAll(): void;
-    loadMany(keys: T[]): Promise<Data[]>;
+    loadMany(keys: T[]): Promise<Array<Data | null>>;
     prime(data: Data): void;
     primeAll(data: Data): void;
 }
@@ -24,6 +24,6 @@ export declare class ObjectLoaderFactory<T> implements LoaderFactory<T, Data | n
     private toPrime;
     constructor(options: ObjectLoaderOptions);
     createLoader(context?: Context): ObjectLoader<T>;
-    addToPrime(factory: ObjectLoaderFactory<T>): void;
+    addToPrime(factory: ObjectLoaderFactory<T>): this;
 }
 export {};

package/core/loaders/object_loader.js

@@ -29,6 +29,47 @@ const clause = __importStar(require("../clause"));
 const logger_1 = require("../logger");
 const loader_1 = require("./loader");
 const memoizee_1 = __importDefault(require("memoizee"));
+async function loadRowsForLoader(options, ids, context) {
+    let col = options.key;
+    let cls = clause.In(col, ...ids);
+    if (options.clause) {
+        let optionClause;
+        if (typeof options.clause === "function") {
+            optionClause = options.clause();
+        }
+        else {
+            optionClause = options.clause;
+        }
+        if (optionClause) {
+            cls = clause.And(cls, optionClause);
+        }
+    }
+    const rowOptions = {
+        ...options,
+        clause: cls,
+        context,
+    };
+    let m = new Map();
+    let result = [];
+    for (let i = 0; i < ids.length; i++) {
+        result.push(null);
+        // store the index....
+        m.set(ids[i], i);
+    }
+    const rows = await (0, ent_1.loadRows)(rowOptions);
+    for (const row of rows) {
+        const id = row[col];
+        if (id === undefined) {
+            throw new Error(`need to query for column ${col} when using an object loader because the query may not be sorted and we need the id to maintain sort order`);
+        }
+        const idx = m.get(id);
+        if (idx === undefined) {
+            throw new Error(`malformed query. got ${id} back but didn't query for it`);
+        }
+        result[idx] = row;
+    }
+    return result;
+}
 // optional clause...
 // so ObjectLoaderFactory and createDataLoader need to take a new optional field which is a clause that's always added here
 // and we need a disableTransform which skips loader completely and uses loadRow...
@@ -42,45 +83,8 @@ function createDataLoader(options) {
         if (!ids.length) {
             return [];
         }
-        let col = options.key;
-        let cls = clause.In(col, ...ids);
-        if (options.clause) {
-            let optionClause;
-            if (typeof options.clause === "function") {
-                optionClause = options.clause();
-            }
-            else {
-                optionClause = options.clause;
-            }
-            if (optionClause) {
-                cls = clause.And(cls, optionClause);
-            }
-        }
-        const rowOptions = {
-            ...options,
-            clause: cls,
-        };
-        let m = new Map();
-        let result = [];
-        for (let i = 0; i < ids.length; i++) {
-            result.push(null);
-            // store the index....
-            m.set(ids[i], i);
-        }
         // context not needed because we're creating a loader which has its own cache which is being used here
-        const rows = await (0, ent_1.loadRows)(rowOptions);
-        for (const row of rows) {
-            const id = row[col];
-            if (id === undefined) {
-                throw new Error(`need to query for column ${col} when using an object loader because the query may not be sorted and we need the id to maintain sort order`);
-            }
-            const idx = m.get(id);
-            if (idx === undefined) {
-                throw new Error(`malformed query. got ${id} back but didn't query for it`);
-            }
-            result[idx] = row;
-        }
-        return result;
+        return loadRowsForLoader(options, ids);
     }, loaderOptions);
 }
 class ObjectLoader {
@@ -147,7 +151,7 @@ class ObjectLoader {
             clause: cls,
             context: this.context,
         };
-        return await (0, ent_1.loadRow)(rowOptions);
+        return (0, ent_1.loadRow)(rowOptions);
     }
     clearAll() {
         this.loader && this.loader.clearAll();
@@ -156,25 +160,7 @@ class ObjectLoader {
         if (this.loader) {
             return await this.loader.loadMany(keys);
         }
-        let cls = clause.In(this.options.key, ...keys);
-        if (this.options.clause) {
-            let optionClause;
-            if (typeof this.options.clause === "function") {
-                optionClause = this.options.clause();
-            }
-            else {
-                optionClause = this.options.clause;
-            }
-            if (optionClause) {
-                cls = clause.And(cls, optionClause);
-            }
-        }
-        const rowOptions = {
-            ...this.options,
-            clause: cls,
-            context: this.context,
-        };
-        return await (0, ent_1.loadRows)(rowOptions);
+        return loadRowsForLoader(this.options, keys, this.context);
     }
     prime(data) {
         // we have this data from somewhere else, prime it in the c
@@ -225,6 +211,7 @@ class ObjectLoaderFactory {
     // because there's usually self references here
     addToPrime(factory) {
         this.toPrime.push(factory);
+        return this;
     }
 }
 exports.ObjectLoaderFactory = ObjectLoaderFactory;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.1.0-alpha81",
+  "version": "0.1.0-alpha87",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",

package/schema/field.d.ts

@@ -131,8 +131,6 @@ export interface EnumOptions extends FieldOptions {
     graphQLType?: string;
     createEnumType?: boolean;
 }
-export interface StringEnumOptions extends EnumOptions {
-}
 /**
  * @deprecated Use StringEnumField
  */
@@ -147,6 +145,11 @@ export declare class EnumField extends BaseField implements Field {
 }
 export declare class StringEnumField extends EnumField {
 }
+export interface PolymorphicStringEnumOptions extends EnumOptions {
+    parentFieldToValidate: string;
+}
+export interface StringEnumOptions extends EnumOptions {
+}
 export declare function EnumType(options: StringEnumOptions): EnumField;
 declare type IntEnumMap = {
     [key: string]: number;

package/schema/field.js

@@ -24,6 +24,7 @@ const luxon_1 = require("luxon");
 const snake_case_1 = require("snake-case");
 const util_1 = require("util");
 const uuid_1 = require("uuid");
+const base_1 = require("../core/base");
 const db_1 = __importStar(require("../core/db"));
 const schema_1 = require("./schema");
 class BaseField {
@@ -68,21 +69,22 @@ class UUIDField extends BaseField {
             if (typeof polymorphic === "object" && polymorphic.types) {
                 // an enum with types validated here
                 return {
-                    [name]: EnumType({
+                    [name]: PolymorphicStringEnumType({
                         values: polymorphic.types,
                         hideFromGraphQL: true,
                         derivedWhenEmbedded: true,
                         nullable: this.options?.nullable,
+                        parentFieldToValidate: fieldName,
                     }),
                 };
             }
             else {
-                // just a string field...
                 return {
-                    [name]: StringType({
+                    [name]: PolymorphicStringType({
                         hideFromGraphQL: true,
                         derivedWhenEmbedded: true,
                         nullable: this.options?.nullable,
+                        parentFieldToValidate: fieldName,
                     }),
                 };
             }
@@ -311,6 +313,33 @@ class StringField extends BaseField {
     }
 }
 exports.StringField = StringField;
+function validatePolymorphicTypeWithFullData(val, b, field) {
+    const input = b.getInput();
+    const inputKey = b.orchestrator.__getOptions().fieldInfo[field].inputKey;
+    const v = input[inputKey];
+    if (val === null) {
+        // if this is being set to null, ok if v is also null
+        return v === null;
+    }
+    // if this is not being set, ok if v is not being set
+    if (val === undefined && b.operation === base_1.WriteOperation.Insert) {
+        return v === undefined;
+    }
+    return true;
+}
+class PolymorphicStringField extends StringField {
+    constructor(opts) {
+        super(opts);
+        this.opts = opts;
+    }
+    validateWithFullData(val, b) {
+        return validatePolymorphicTypeWithFullData(val, b, this.opts.parentFieldToValidate);
+    }
+}
+function PolymorphicStringType(opts) {
+    let result = new PolymorphicStringField(opts);
+    return Object.assign(result, opts);
+}
 function StringType(options) {
     let result = new StringField(options);
     const options2 = { ...options };
@@ -556,6 +585,19 @@ exports.EnumField = EnumField;
 class StringEnumField extends EnumField {
 }
 exports.StringEnumField = StringEnumField;
+class PolymorphicStringEnumField extends StringEnumField {
+    constructor(opts) {
+        super(opts);
+        this.opts = opts;
+    }
+    validateWithFullData(val, b) {
+        return validatePolymorphicTypeWithFullData(val, b, this.opts.parentFieldToValidate);
+    }
+}
+function PolymorphicStringEnumType(options) {
+    let result = new PolymorphicStringEnumField(options);
+    return Object.assign(result, options);
+}
 function EnumType(options) {
     let result = new StringEnumField(options);
     return Object.assign(result, options);

package/schema/schema.d.ts

@@ -217,6 +217,7 @@ export interface PolymorphicOptions {
 export interface Field extends FieldOptions {
     type: Type;
     valid?(val: any): Promise<boolean> | boolean;
+    validateWithFullData?(val: any, builder: Builder<any>): boolean | Promise<boolean>;
     format?(val: any, nested?: boolean): any;
     logValue(val: any): any;
 }

package/testutils/builder.js

@@ -137,7 +137,8 @@ function getFieldInfo(value) {
     for (const [k, f] of fields) {
         ret[k] = {
             dbCol: (0, schema_2.getStorageKey)(f, k),
-            inputKey: (0, camel_case_1.camelCase)(k),
+            // in tests (anything using SimpleBuilder), make it be the same as the fieldName
+            inputKey: k,
         };
     }
     return ret;