@snowtop/ent 0.0.36 → 0.0.39-alpha4

package/action/action.d.ts

@@ -1,6 +1,7 @@
 import { Ent, EntConstructor, Viewer, ID, Data, PrivacyPolicy, Context } 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",
@@ -50,6 +51,7 @@ export interface Action<T extends Ent> {
     observers?: Observer<T>[];
     validators?: Validator<T>[];
     getInput(): Data;
+    transformWrite?: (stmt: UpdateOperation<T>) => Promise<TransformedUpdateOperation<T>> | TransformedUpdateOperation<T> | undefined;
     valid(): Promise<boolean>;
     validX(): Promise<void>;
     viewerForEntLoad?(data: Data): Viewer | Promise<Viewer>;

package/action/orchestrator.d.ts

@@ -41,8 +41,12 @@ export declare class Orchestrator<T extends Ent> {
     viewer: Viewer;
     private defaultFieldsByFieldName;
     private defaultFieldsByTSName;
+    private actualOperation;
+    private existingEnt?;
+    private disableTransformations;
     constructor(options: OrchestratorOptions<T, Data>);
     private addEdge;
+    setDisableTransformations(val: boolean): void;
     addInboundEdge<T2 extends Ent>(id1: ID | Builder<T2>, edgeType: string, nodeType: string, options?: AssocEdgeInputOptions): void;
     addOutboundEdge<T2 extends Ent>(id2: ID | Builder<T2>, edgeType: string, nodeType: string, options?: AssocEdgeInputOptions): void;
     removeInboundEdge(id1: ID, edgeType: string): void;
@@ -54,6 +58,8 @@ export declare class Orchestrator<T extends Ent> {
     private buildEdgeOps;
     private throwError;
     private getEntForPrivacyPolicy;
+    private getSQLStatementOperation;
+    private getWriteOpForSQLStamentOp;
     private validate;
     private triggers;
     private validators;

package/action/orchestrator.js

@@ -62,6 +62,8 @@ class Orchestrator {
         this.defaultFieldsByFieldName = {};
         this.defaultFieldsByTSName = {};
         this.viewer = options.viewer;
+        this.actualOperation = this.options.operation;
+        this.existingEnt = this.options.builder.existingEnt;
     }
     addEdge(edge, op) {
         this.edgeSet.add(edge.edgeType);
@@ -80,6 +82,9 @@ class Orchestrator {
         m1.set(op, m2);
         this.edges.set(edge.edgeType, m1);
     }
+    setDisableTransformations(val) {
+        this.disableTransformations = val;
+    }
     addInboundEdge(id1, edgeType, nodeType, options) {
         this.addEdge(new edgeInputData({
             id: id1,
@@ -135,24 +140,27 @@ class Orchestrator {
     }
     buildMainOp() {
         // this assumes we have validated fields
-        switch (this.options.operation) {
+        switch (this.actualOperation) {
             case action_1.WriteOperation.Delete:
-                return new ent_1.DeleteNodeOperation(this.options.builder.existingEnt.id, {
+                return new ent_1.DeleteNodeOperation(this.existingEnt.id, {
                     tableName: this.options.tableName,
                 });
             default:
+                if (this.actualOperation === action_1.WriteOperation.Edit && !this.existingEnt) {
+                    throw new Error(`existing ent required with operation ${this.actualOperation}`);
+                }
                 const opts = {
                     fields: this.validatedFields,
                     tableName: this.options.tableName,
                     fieldsToResolve: this.fieldsToResolve,
                     key: this.options.key,
-                    ent: this.options.loaderOptions.ent,
+                    loadEntOptions: this.options.loaderOptions,
                     placeholderID: this.options.builder.placeholderID,
                 };
                 if (this.logValues) {
                     opts.fieldsToLog = this.logValues;
                 }
-                this.mainOp = new ent_1.EditNodeOperation(opts, this.options.builder.existingEnt);
+                this.mainOp = new ent_1.EditNodeOperation(opts, this.existingEnt);
                 return this.mainOp;
         }
     }
@@ -219,35 +227,57 @@ class Orchestrator {
         if (!privacyPolicy || !action) {
             throw new Error(`shouldn't get here if no privacyPolicy for action`);
         }
-        if (this.options.operation === action_1.WriteOperation.Insert) {
+        if (this.actualOperation === action_1.WriteOperation.Insert) {
             return new EntCannotCreateEntError(privacyPolicy, action);
         }
-        else if (this.options.operation === action_1.WriteOperation.Edit) {
-            return new EntCannotEditEntError(privacyPolicy, action, this.options.builder.existingEnt);
+        else if (this.actualOperation === action_1.WriteOperation.Edit) {
+            return new EntCannotEditEntError(privacyPolicy, action, this.existingEnt);
         }
-        return new EntCannotDeleteEntError(privacyPolicy, action, this.options.builder.existingEnt);
+        return new EntCannotDeleteEntError(privacyPolicy, action, this.existingEnt);
     }
     getEntForPrivacyPolicy(editedData) {
-        if (this.options.operation !== action_1.WriteOperation.Insert) {
-            return this.options.builder.existingEnt;
+        if (this.actualOperation !== action_1.WriteOperation.Insert) {
+            return this.existingEnt;
         }
         // we create an unsafe ent to be used for privacy policies
         return new this.options.builder.ent(this.options.builder.viewer, editedData);
     }
+    getSQLStatementOperation() {
+        switch (this.actualOperation) {
+            case action_1.WriteOperation.Edit:
+                return schema_1.SQLStatementOperation.Update;
+            case action_1.WriteOperation.Insert:
+                return schema_1.SQLStatementOperation.Insert;
+            case action_1.WriteOperation.Delete:
+                return schema_1.SQLStatementOperation.Delete;
+        }
+    }
+    getWriteOpForSQLStamentOp(op) {
+        switch (op) {
+            case schema_1.SQLStatementOperation.Update:
+                return action_1.WriteOperation.Edit;
+            case schema_1.SQLStatementOperation.Insert:
+                return action_1.WriteOperation.Insert;
+            case schema_1.SQLStatementOperation.Update:
+                return action_1.WriteOperation.Delete;
+            default:
+                throw new Error("invalid path");
+        }
+    }
     async validate() {
         // existing ent required for edit or delete operations
-        switch (this.options.operation) {
+        switch (this.actualOperation) {
             case action_1.WriteOperation.Delete:
             case action_1.WriteOperation.Edit:
-                if (!this.options.builder.existingEnt) {
-                    throw new Error("existing ent required with operation");
+                if (!this.existingEnt) {
+                    throw new Error(`existing ent required with operation ${this.actualOperation}`);
                 }
         }
         const action = this.options.action;
         const builder = this.options.builder;
         // future optimization: can get schemaFields to memoize based on different values
         const schemaFields = (0, schema_1.getFields)(this.options.schema);
-        let editedData = this.getFieldsWithDefaultValues(builder, schemaFields, action);
+        let editedData = await this.getFieldsWithDefaultValues(builder, schemaFields, action);
         // this runs in following phases:
         // * set default fields and pass to builder so the value can be checked by triggers/observers/validators
         // * privacy policy (use unsafe ent if we have it)
@@ -300,18 +330,66 @@ class Orchestrator {
     isBuilder(val) {
         return val.placeholderID !== undefined;
     }
-    getFieldsWithDefaultValues(builder, schemaFields, action) {
+    async getFieldsWithDefaultValues(builder, schemaFields, action) {
         const editedFields = this.options.editedFields();
         let data = {};
         let defaultData = {};
         let input = action?.getInput() || {};
         let updateInput = false;
+        // transformations
+        // if action transformations. always do it
+        // if disable transformations set, don't do schema transform and just do the right thing
+        // else apply schema tranformation if it exists
+        let transformed;
+        if (action?.transformWrite) {
+            transformed = await action.transformWrite({
+                viewer: builder.viewer,
+                op: this.getSQLStatementOperation(),
+                data: editedFields,
+                existingEnt: this.existingEnt,
+            });
+        }
+        else if (!this.disableTransformations) {
+            transformed = (0, schema_1.getTransformedUpdateOp)(this.options.schema, {
+                viewer: builder.viewer,
+                op: this.getSQLStatementOperation(),
+                data: editedFields,
+                existingEnt: this.existingEnt,
+            });
+        }
+        if (transformed) {
+            if (transformed.data) {
+                updateInput = true;
+                for (const k in transformed.data) {
+                    let field = schemaFields.get(k);
+                    if (!field) {
+                        throw new Error(`tried to transform field with unknown field ${k}`);
+                    }
+                    let val = transformed.data[k];
+                    if (field.format) {
+                        val = field.format(transformed.data[k]);
+                    }
+                    let dbKey = field.storageKey || (0, snake_case_1.snakeCase)(field.name);
+                    data[dbKey] = val;
+                    this.defaultFieldsByTSName[(0, camel_case_1.camelCase)(k)] = val;
+                    // hmm do we need this?
+                    // TODO how to do this for local tests?
+                    //          this.defaultFieldsByFieldName[k] = val;
+                }
+            }
+            this.actualOperation = this.getWriteOpForSQLStamentOp(transformed.op);
+            if (transformed.existingEnt) {
+                this.existingEnt = transformed.existingEnt;
+            }
+        }
+        // transforming before doing default fields so that we don't create a new id
+        // and anything that depends on the type of operations knows what it is
         for (const [fieldName, field] of schemaFields) {
             let value = editedFields.get(fieldName);
             let defaultValue = undefined;
             let dbKey = field.storageKey || (0, snake_case_1.snakeCase)(field.name);
             if (value === undefined) {
-                if (this.options.operation === action_1.WriteOperation.Insert) {
+                if (this.actualOperation === action_1.WriteOperation.Insert) {
                     if (field.defaultToViewerOnCreate && field.defaultValueOnCreate) {
                         throw new Error(`cannot set both defaultToViewerOnCreate and defaultValueOnCreate`);
                     }
@@ -326,7 +404,7 @@ class Orchestrator {
                     }
                 }
                 if (field.defaultValueOnEdit &&
-                    this.options.operation === action_1.WriteOperation.Edit) {
+                    this.actualOperation === action_1.WriteOperation.Edit) {
                     defaultValue = field.defaultValueOnEdit(builder, input);
                 }
             }
@@ -374,7 +452,7 @@ class Orchestrator {
                 // not setting server default as we're depending on the database handling that.
                 // server default allowed
                 field.serverDefault === undefined &&
-                this.options.operation === action_1.WriteOperation.Insert) {
+                this.actualOperation === action_1.WriteOperation.Insert) {
                 throw new Error(`required field ${field.name} not set`);
             }
         }
@@ -406,7 +484,7 @@ class Orchestrator {
         return value;
     }
     async formatAndValidateFields(schemaFields) {
-        const op = this.options.operation;
+        const op = this.actualOperation;
         if (op === action_1.WriteOperation.Delete) {
             return;
         }
@@ -494,7 +572,7 @@ class Orchestrator {
         const viewer = await this.viewerForEntLoad(row);
         const ent = await (0, ent_1.applyPrivacyPolicyForRow)(viewer, this.options.loaderOptions, row);
         if (!ent) {
-            if (this.options.operation == action_1.WriteOperation.Insert) {
+            if (this.actualOperation == action_1.WriteOperation.Insert) {
                 throw new Error(`was able to create ent but not load it`);
             }
             else {

package/core/base.d.ts

@@ -62,6 +62,7 @@ export interface SelectBaseDataOptions extends DataOptions {
 }
 export interface SelectDataOptions extends SelectBaseDataOptions {
     key: string;
+    clause?: clause.Clause;
 }
 export interface QueryableDataOptions extends SelectBaseDataOptions, QueryDataOptions {
 }

package/core/clause.d.ts

@@ -12,8 +12,10 @@ declare class simpleClause implements Clause {
     protected col: string;
     private value;
     private op;
-    constructor(col: string, value: any, op: string);
+    private handleSqliteNull?;
+    constructor(col: string, value: any, op: string, handleSqliteNull?: Clause | undefined);
     clause(idx: number): string;
+    private sqliteNull;
     values(): any[];
     logValues(): any[];
     instanceKey(): string;
@@ -27,8 +29,8 @@ declare class compositeClause implements Clause {
     logValues(): any[];
     instanceKey(): string;
 }
-export declare function Eq(col: string, value: any): simpleClause;
-export declare function NotEq(col: string, value: any): simpleClause;
+export declare function Eq(col: string, value: any): Clause;
+export declare function NotEq(col: string, value: any): Clause;
 export declare function Greater(col: string, value: any): simpleClause;
 export declare function Less(col: string, value: any): simpleClause;
 export declare function GreaterEq(col: string, value: any): simpleClause;

package/core/clause.js

@@ -22,7 +22,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.sensitiveValue = exports.In = exports.Or = exports.And = exports.LessEq = exports.GreaterEq = exports.Less = exports.Greater = exports.NotEq = exports.Eq = void 0;
 const db_1 = __importStar(require("./db"));
 function isSensitive(val) {
-    return (typeof val === "object" && val.logValue !== undefined);
+    return (val !== null &&
+        typeof val === "object" &&
+        val.logValue !== undefined);
 }
 function rawValue(val) {
     if (isSensitive(val)) {
@@ -31,33 +33,94 @@ function rawValue(val) {
     return val;
 }
 class simpleClause {
-    constructor(col, value, op) {
+    constructor(col, value, op, handleSqliteNull) {
         this.col = col;
         this.value = value;
         this.op = op;
+        this.handleSqliteNull = handleSqliteNull;
     }
     clause(idx) {
+        const sqliteClause = this.sqliteNull();
+        if (sqliteClause) {
+            return sqliteClause.clause(idx);
+        }
         if (db_1.default.getDialect() === db_1.Dialect.Postgres) {
             return `${this.col} ${this.op} $${idx}`;
         }
         return `${this.col} ${this.op} ?`;
     }
+    sqliteNull() {
+        if (!this.handleSqliteNull) {
+            return;
+        }
+        const dialect = db_1.default.getDialect();
+        if (this.value !== null || dialect !== db_1.Dialect.SQLite) {
+            return;
+        }
+        return this.handleSqliteNull;
+    }
     values() {
+        const sqliteClause = this.sqliteNull();
+        if (sqliteClause) {
+            return sqliteClause.values();
+        }
         if (isSensitive(this.value)) {
             return [this.value.value()];
         }
         return [this.value];
     }
     logValues() {
+        const sqliteClause = this.sqliteNull();
+        if (sqliteClause) {
+            return sqliteClause.logValues();
+        }
         if (isSensitive(this.value)) {
             return [this.value.logValue()];
         }
         return [this.value];
     }
     instanceKey() {
+        const sqliteClause = this.sqliteNull();
+        if (sqliteClause) {
+            return sqliteClause.instanceKey();
+        }
         return `${this.col}${this.op}${rawValue(this.value)}`;
     }
 }
+class isNullClause {
+    constructor(col) {
+        this.col = col;
+    }
+    clause(idx) {
+        return `${this.col} IS NULL`;
+    }
+    values() {
+        return [];
+    }
+    logValues() {
+        return [];
+    }
+    instanceKey() {
+        return `${this.col} IS NULL`;
+    }
+}
+class isNotNullClause {
+    constructor(col) {
+        this.col = col;
+    }
+    clause(idx) {
+        return `${this.col} IS NOT NULL`;
+    }
+    values() {
+        return [];
+    }
+    logValues() {
+        return [];
+    }
+    instanceKey() {
+        return `${this.col} IS NOT NULL`;
+    }
+}
 class inClause {
     constructor(col, value) {
         this.col = col;
@@ -146,11 +209,11 @@ class compositeClause {
     }
 }
 function Eq(col, value) {
-    return new simpleClause(col, value, "=");
+    return new simpleClause(col, value, "=", new isNullClause(col));
 }
 exports.Eq = Eq;
 function NotEq(col, value) {
-    return new simpleClause(col, value, "!=");
+    return new simpleClause(col, value, "!=", new isNotNullClause(col));
 }
 exports.NotEq = NotEq;
 function Greater(col, value) {

package/core/config.d.ts

@@ -1,12 +1,21 @@
 /// <reference types="node" />
 import { Database, DBDict } from "./db";
 declare type logType = "query" | "warn" | "info" | "error" | "debug";
+declare enum graphqlMutationName {
+    NOUN_VERB = "NounVerb",
+    VERB_NOUN = "VerbNoun"
+}
+declare enum graphQLFieldFormat {
+    LOWER_CAMEL = "lowerCamel",
+    SNAKE_CASE = "snake_case"
+}
 export interface Config {
     dbConnectionString?: string;
     dbFile?: string;
     db?: Database | DBDict;
     log?: logType | logType[];
     codegen?: CodegenConfig;
+    customGraphQLJSONPath?: string;
 }
 interface CodegenConfig {
     defaultEntPolicy?: PrivacyConfig;
@@ -17,6 +26,8 @@ interface CodegenConfig {
     generatedHeader?: string;
     disableBase64Encoding?: boolean;
     generateRootResolvers?: boolean;
+    defaultGraphQLMutationName?: graphqlMutationName;
+    defaultGraphQLFieldFormat?: graphQLFieldFormat;
 }
 interface PrettierConfig {
     custom?: boolean;

package/core/config.js

@@ -28,6 +28,18 @@ const js_yaml_1 = require("js-yaml");
 const db_1 = __importDefault(require("./db"));
 const path = __importStar(require("path"));
 const logger_1 = require("./logger");
+// ent.config.ts eventually. for now ent.yml
+// or ent.yml?
+var graphqlMutationName;
+(function (graphqlMutationName) {
+    graphqlMutationName["NOUN_VERB"] = "NounVerb";
+    graphqlMutationName["VERB_NOUN"] = "VerbNoun";
+})(graphqlMutationName || (graphqlMutationName = {}));
+var graphQLFieldFormat;
+(function (graphQLFieldFormat) {
+    graphQLFieldFormat["LOWER_CAMEL"] = "lowerCamel";
+    graphQLFieldFormat["SNAKE_CASE"] = "snake_case";
+})(graphQLFieldFormat || (graphQLFieldFormat = {}));
 function setConfig(cfg) {
     if (cfg.log) {
         (0, logger_1.setLogLevels)(cfg.log);

package/core/ent.d.ts

@@ -1,5 +1,5 @@
 import { Queryer, SyncQueryer } from "./db";
-import { Viewer, Ent, ID, LoadRowsOptions, LoadRowOptions, Data, DataOptions, QueryableDataOptions, EditRowOptions, LoadEntOptions, LoadCustomEntOptions, EdgeQueryableDataOptions, Context, SelectBaseDataOptions, CreateRowOptions, QueryDataOptions, EntConstructor } from "./base";
+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 * as clause from "./clause";
 import { Builder } from "../action";
@@ -51,7 +51,7 @@ export interface DataOperation<T extends Ent = Ent> {
 }
 export interface EditNodeOptions<T extends Ent> extends EditRowOptions {
     fieldsToResolve: string[];
-    ent: EntConstructor<T>;
+    loadEntOptions: LoadEntOptions<T>;
     placeholderID?: ID;
 }
 export declare class EditNodeOperation<T extends Ent> implements DataOperation {

package/core/ent.js

@@ -84,8 +84,54 @@ function createDataLoader(options) {
         return result;
     }, loaderOptions);
 }
+// TODO probably delete since we're going to generate it now
+// instead of passing this here.
+// async function doPerformQuery<T extends Ent>(
+//   viewer: Viewer,
+//   id: ID,
+//   options: LoadEntOptions<T>,
+// ): Promise<Data | null> {
+//   let newClause: clause.Clause | undefined = undefined;
+//   if (options.schema) {
+//     const schema = getSchema(options.schema);
+//     if (schema.patterns) {
+//       for (const p of schema.patterns) {
+//         if (p.transformRead) {
+//           newClause = p.transformRead({
+//             op: QueryOperation.Select,
+//             clause: clause.Eq("id", id),
+//           });
+//         }
+//       }
+//     }
+//   }
+//   // we want a loader if possible . we don't want this to slow
+//   // things down...
+//   // id = x and deleted_at == null
+//   if (newClause) {
+//     // loader
+//     //    return loadRow({});
+//     // TODO
+//   }
+//   // we want a deleted_at loader...
+//   return options.loaderFactory.createLoader(viewer.context).load(id);
+// }
 // Ent accessors
 async function loadEnt(viewer, id, options) {
+    let newClause;
+    // if (options.schema) {
+    //   const schema = getSchema(options.schema);
+    //   if (schema.patterns) {
+    //     for (const p of schema.patterns) {
+    //       if (p.transformRead) {
+    //         newClause = p.transformRead({
+    //           op: QueryOperation.Select,
+    //           clause: clause.Eq("id", id),
+    //         });
+    //       }
+    //     }
+    //   }
+    // }
     const row = await options.loaderFactory.createLoader(viewer.context).load(id);
     return await applyPrivacyPolicyForRow(viewer, options, row);
 }
@@ -434,6 +480,8 @@ class EditNodeOperation {
         };
         if (this.existingEnt) {
             if (this.hasData(options.fields)) {
+                // even this with returning * doesn't work if transformed...
+                // we can have a transformed flag to see if it should be returned?
                 this.row = await editRow(queryer, options, this.existingEnt.id, "RETURNING *");
             }
             else {
@@ -445,20 +493,27 @@ class EditNodeOperation {
         }
     }
     reloadRow(queryer, id, options) {
+        // TODO this isn'talways an ObjectLoader. should throw or figure out a way to get query
+        // and run this on its own...
+        const loader = this.options.loadEntOptions.loaderFactory.createLoader(options.context);
+        const opts = loader.getOptions();
+        let cls = clause.Eq(options.key, id);
+        if (opts.clause) {
+            cls = clause.And(opts.clause, cls);
+        }
         const query = buildQuery({
-            fields: ["*"],
+            fields: opts.fields.length ? opts.fields : ["*"],
             tableName: options.tableName,
-            clause: clause.Eq(options.key, id),
+            clause: cls,
         });
         // special case log here because we're not going through any of the normal
         // methods here because those are async and this is sync
         // this is the only place we're doing this so only handling here
         logQuery(query, [id]);
         const r = queryer.querySync(query, [id]);
-        if (r.rows.length !== 1) {
-            throw new Error(`couldn't reload row for ${id}`);
+        if (r.rows.length === 1) {
+            this.row = r.rows[0];
         }
-        this.row = r.rows[0];
     }
     performWriteSync(queryer, context) {
         let options = {
@@ -487,7 +542,7 @@ class EditNodeOperation {
         if (!this.row) {
             return null;
         }
-        return new this.options.ent(viewer, this.row);
+        return new this.options.loadEntOptions.ent(viewer, this.row);
     }
 }
 exports.EditNodeOperation = EditNodeOperation;

package/core/loaders/assoc_edge_loader.js

@@ -162,7 +162,6 @@ class AssocEdgeLoaderFactory {
         return this.createConfigurableLoader({}, context);
     }
     isConstructor(edgeCtr) {
-        // not constructor
         return (edgeCtr.prototype &&
             edgeCtr.prototype.constructor &&
             edgeCtr.prototype.constructor.name.length > 0);

package/core/loaders/object_loader.d.ts

@@ -7,6 +7,7 @@ export declare class ObjectLoader<T> implements Loader<T, Data | null> {
     private primedLoaders;
     private memoizedInitPrime;
     constructor(options: SelectDataOptions, context?: Context | undefined, toPrime?: ObjectLoaderFactory<T>[] | undefined);
+    getOptions(): SelectDataOptions;
     private initPrime;
     load(key: T): Promise<Data | null>;
     clearAll(): void;

package/core/loaders/object_loader.js

@@ -29,6 +29,9 @@ const clause = __importStar(require("../clause"));
 const logger_1 = require("../logger");
 const loader_1 = require("./loader");
 const memoizee_1 = __importDefault(require("memoizee"));
+// 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...
 function createDataLoader(options) {
     const loaderOptions = {};
     // if query logging is enabled, we should log what's happening with loader
@@ -40,9 +43,13 @@ function createDataLoader(options) {
             return [];
         }
         let col = options.key;
+        let cls = clause.In(col, ...ids);
+        if (options.clause) {
+            cls = clause.And(options.clause, cls);
+        }
         const rowOptions = {
             ...options,
-            clause: clause.In(col, ...ids),
+            clause: cls,
         };
         let m = new Map();
         let result = [];
@@ -77,6 +84,9 @@ class ObjectLoader {
         }
         this.memoizedInitPrime = (0, memoizee_1.default)(this.initPrime.bind(this));
     }
+    getOptions() {
+        return this.options;
+    }
     initPrime() {
         if (!this.context || !this.toPrime) {
             return;
@@ -107,9 +117,13 @@ class ObjectLoader {
             }
             return result;
         }
+        let cls = clause.Eq(this.options.key, key);
+        if (this.options.clause) {
+            cls = clause.And(this.options.clause, cls);
+        }
         const rowOptions = {
             ...this.options,
-            clause: clause.Eq(this.options.key, key),
+            clause: cls,
             context: this.context,
         };
         return await (0, ent_1.loadRow)(rowOptions);
@@ -121,9 +135,13 @@ class ObjectLoader {
         if (this.loader) {
             return await this.loader.loadMany(keys);
         }
+        let cls = clause.In(this.options.key, ...keys);
+        if (this.options.clause) {
+            cls = clause.And(this.options.clause, cls);
+        }
         const rowOptions = {
             ...this.options,
-            clause: clause.In(this.options.key, ...keys),
+            clause: cls,
             context: this.context,
         };
         return await (0, ent_1.loadRows)(rowOptions);
@@ -142,7 +160,7 @@ class ObjectLoaderFactory {
     constructor(options) {
         this.options = options;
         this.toPrime = [];
-        this.name = `${options.tableName}:${options.key}`;
+        this.name = `${options.tableName}:${options.key}:${options.clause?.instanceKey() || ""}`;
     }
     createLoader(context) {
         return (0, loader_1.getLoader)(this, () => {