@snowtop/ent 0.0.37 → 0.0.39-alpha14

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?: <T2 extends Ent>(stmt: UpdateOperation<T2>) => Promise<TransformedUpdateOperation<T2>> | TransformedUpdateOperation<T2> | undefined;
     valid(): Promise<boolean>;
     validX(): Promise<void>;
     viewerForEntLoad?(data: Data): Viewer | Promise<Viewer>;

package/action/orchestrator.d.ts

@@ -12,7 +12,7 @@ export interface OrchestratorOptions<T extends Ent, TData extends Data> {
     builder: Builder<T>;
     action?: Action<T>;
     schema: SchemaInputType;
-    editedFields(): Map<string, any>;
+    editedFields(): Map<string, any> | Promise<Map<string, any>>;
     updateInput?: (data: TData) => void;
 }
 interface edgeInputDataOpts {
@@ -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

@@ -4,7 +4,6 @@ exports.EntChangeset = exports.Orchestrator = exports.edgeDirection = void 0;
 const ent_1 = require("../core/ent");
 const schema_1 = require("../schema/schema");
 const action_1 = require("../action");
-const snake_case_1 = require("snake-case");
 const camel_case_1 = require("camel-case");
 const privacy_1 = require("../core/privacy");
 const executor_1 = require("./executor");
@@ -62,6 +61,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 +81,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 +139,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 +226,58 @@ 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);
+        const editedFields = await this.options.editedFields();
+        let editedData = await this.getFieldsWithDefaultValues(builder, schemaFields, editedFields, 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)
@@ -264,8 +294,12 @@ class Orchestrator {
             await this.triggers(action, builder, triggers);
         }
         let validators = action?.validators || [];
+        // TODO not ideal we're calling this twice. fix...
+        // TODO add core test for softe delete with soft_delete package duplicated?
+        // to confirm it works and things like this don't break it.
+        const editedFields2 = await this.options.editedFields();
         await Promise.all([
-            this.formatAndValidateFields(schemaFields),
+            this.formatAndValidateFields(schemaFields, editedFields2),
             this.validators(validators, action, builder),
         ]);
     }
@@ -300,18 +334,65 @@ class Orchestrator {
     isBuilder(val) {
         return val.placeholderID !== undefined;
     }
-    getFieldsWithDefaultValues(builder, schemaFields, action) {
-        const editedFields = this.options.editedFields();
+    async getFieldsWithDefaultValues(builder, schemaFields, editedFields, action) {
         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 = (0, schema_1.getStorageKey)(field);
+                    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);
+            let dbKey = (0, schema_1.getStorageKey)(field);
             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 +407,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 +455,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`);
             }
         }
@@ -405,12 +486,11 @@ class Orchestrator {
         }
         return value;
     }
-    async formatAndValidateFields(schemaFields) {
-        const op = this.options.operation;
+    async formatAndValidateFields(schemaFields, editedFields) {
+        const op = this.actualOperation;
         if (op === action_1.WriteOperation.Delete) {
             return;
         }
-        const editedFields = this.options.editedFields();
         // build up data to be saved...
         let data = {};
         let logValues = {};
@@ -420,7 +500,7 @@ class Orchestrator {
                 // null allowed
                 value = this.defaultFieldsByFieldName[fieldName];
             }
-            let dbKey = field.storageKey || (0, snake_case_1.snakeCase)(field.name);
+            let dbKey = (0, schema_1.getStorageKey)(field);
             value = await this.transformFieldValue(field, dbKey, value);
             if (value !== undefined) {
                 data[dbKey] = value;
@@ -433,7 +513,7 @@ class Orchestrator {
             for (const fieldName in this.defaultFieldsByFieldName) {
                 const defaultValue = this.defaultFieldsByFieldName[fieldName];
                 let field = schemaFields.get(fieldName);
-                let dbKey = field.storageKey || (0, snake_case_1.snakeCase)(field.name);
+                let dbKey = (0, schema_1.getStorageKey)(field);
                 // no value, let's just default
                 if (data[dbKey] === undefined) {
                     const value = await this.transformFieldValue(field, dbKey, defaultValue);
@@ -494,7 +574,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 {
 }
@@ -88,9 +89,11 @@ interface LoadableEntOptions<T extends Ent> {
     ent: EntConstructor<T>;
 }
 export interface LoadEntOptions<T extends Ent> extends LoadableEntOptions<T>, SelectBaseDataOptions {
+    fieldPrivacy?: Map<string, PrivacyPolicy>;
 }
 export interface LoadCustomEntOptions<T extends Ent> extends SelectBaseDataOptions {
     ent: EntConstructor<T>;
+    fieldPrivacy?: Map<string, PrivacyPolicy>;
 }
 export interface LoaderInfo {
     tableName: string;

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,14 +29,33 @@ 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 ArrayEq(col: string, value: any): Clause;
+export declare function ArrayNotEq(col: string, value: any): Clause;
+export declare function ArrayGreater(col: string, value: any): Clause;
+export declare function ArrayLess(col: string, value: any): Clause;
+export declare function ArrayGreaterEq(col: string, value: any): Clause;
+export declare function ArrayLessEq(col: string, value: any): Clause;
+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;
 export declare function LessEq(col: string, value: any): simpleClause;
 export declare function And(...args: Clause[]): compositeClause;
+export declare function AndOptional(...args: (Clause | undefined)[]): Clause;
 export declare function Or(...args: Clause[]): compositeClause;
 export declare function In(col: string, ...values: any): Clause;
+interface TsQuery {
+    language: "english" | "french" | "german" | "simple";
+    value: string;
+}
+export declare function TsQuery(col: string, val: string | TsQuery): Clause;
+export declare function PlainToTsQuery(col: string, val: string | TsQuery): Clause;
+export declare function PhraseToTsQuery(col: string, val: string | TsQuery): Clause;
+export declare function WebsearchToTsQuery(col: string, val: string | TsQuery): Clause;
+export declare function TsVectorColTsQuery(col: string, val: string | TsQuery): Clause;
+export declare function TsVectorPlainToTsQuery(col: string, val: string | TsQuery): Clause;
+export declare function TsVectorPhraseToTsQuery(col: string, val: string | TsQuery): Clause;
+export declare function TsVectorWebsearchToTsQuery(col: string, val: string | TsQuery): Clause;
 export declare function sensitiveValue(val: any): SensitiveValue;
 export {};

package/core/clause.js

@@ -19,10 +19,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 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;
+exports.sensitiveValue = exports.TsVectorWebsearchToTsQuery = exports.TsVectorPhraseToTsQuery = exports.TsVectorPlainToTsQuery = exports.TsVectorColTsQuery = exports.WebsearchToTsQuery = exports.PhraseToTsQuery = exports.PlainToTsQuery = exports.TsQuery = exports.In = exports.Or = exports.AndOptional = exports.And = exports.LessEq = exports.GreaterEq = exports.Less = exports.Greater = exports.NotEq = exports.Eq = exports.ArrayLessEq = exports.ArrayGreaterEq = exports.ArrayLess = exports.ArrayGreater = exports.ArrayNotEq = exports.ArrayEq = 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,17 +33,105 @@ 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 || this.value !== null) {
+            return;
+        }
+        if (db_1.default.getDialect() !== 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 arraySimpleClause {
+    constructor(col, value, op) {
+        this.col = col;
+        this.value = value;
+        this.op = op;
+    }
+    clause(idx) {
+        if (db_1.default.getDialect() === db_1.Dialect.Postgres) {
+            return `$${idx} ${this.op} ANY(${this.col})`;
+        }
+        return `${this.col} ${this.op} ?`;
+    }
     values() {
         if (isSensitive(this.value)) {
             return [this.value.value()];
@@ -145,12 +235,100 @@ class compositeClause {
         return keys.join(this.sep);
     }
 }
+class tsQueryClause {
+    constructor(col, val, tsVectorCol) {
+        this.col = col;
+        this.val = val;
+        this.tsVectorCol = tsVectorCol;
+    }
+    isTsQuery(val) {
+        return typeof val !== "string";
+    }
+    getInfo() {
+        if (this.isTsQuery(this.val)) {
+            return { value: this.val.value, language: this.val.language };
+        }
+        return {
+            language: "english",
+            value: this.val,
+        };
+    }
+    clause(idx) {
+        const { language } = this.getInfo();
+        if (db_1.Dialect.Postgres === db_1.default.getDialect()) {
+            if (this.tsVectorCol) {
+                return `to_tsvector(${this.col}) @@ ${this.getFunction()}('${language}', $${idx})`;
+            }
+            return `${this.col} @@ ${this.getFunction()}('${language}', $${idx})`;
+        }
+        // FYI this doesn't actually work for sqlite since different
+        return `${this.col} @@ ${this.getFunction()}('${language}', ?)`;
+    }
+    values() {
+        const { value } = this.getInfo();
+        return [value];
+    }
+    logValues() {
+        const { value } = this.getInfo();
+        return [value];
+    }
+    getFunction() {
+        return "to_tsquery";
+    }
+    instanceKey() {
+        const { language, value } = this.getInfo();
+        if (this.tsVectorCol) {
+            return `to_tsvector(${this.col})@@${this.getFunction()}:${language}:${value}`;
+        }
+        return `${this.col}@@${this.getFunction()}:${language}:${value}`;
+    }
+}
+class plainToTsQueryClause extends tsQueryClause {
+    getFunction() {
+        return "plainto_tsquery";
+    }
+}
+class phraseToTsQueryClause extends tsQueryClause {
+    getFunction() {
+        return "phraseto_tsquery";
+    }
+}
+class websearchTosQueryClause extends tsQueryClause {
+    getFunction() {
+        return "websearch_to_tsquery";
+    }
+}
+// TODO we need to check sqlite version...
+function ArrayEq(col, value) {
+    return new arraySimpleClause(col, value, "=");
+}
+exports.ArrayEq = ArrayEq;
+function ArrayNotEq(col, value) {
+    return new arraySimpleClause(col, value, "!=");
+}
+exports.ArrayNotEq = ArrayNotEq;
+function ArrayGreater(col, value) {
+    return new arraySimpleClause(col, value, ">");
+}
+exports.ArrayGreater = ArrayGreater;
+function ArrayLess(col, value) {
+    return new arraySimpleClause(col, value, "<");
+}
+exports.ArrayLess = ArrayLess;
+function ArrayGreaterEq(col, value) {
+    return new arraySimpleClause(col, value, ">=");
+}
+exports.ArrayGreaterEq = ArrayGreaterEq;
+function ArrayLessEq(col, value) {
+    return new arraySimpleClause(col, value, "<=");
+}
+exports.ArrayLessEq = ArrayLessEq;
 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) {
@@ -173,6 +351,15 @@ function And(...args) {
     return new compositeClause(args, " AND ");
 }
 exports.And = And;
+function AndOptional(...args) {
+    // @ts-ignore
+    let filtered = args.filter((v) => v !== undefined);
+    if (filtered.length === 1) {
+        return filtered[0];
+    }
+    return And(...filtered);
+}
+exports.AndOptional = AndOptional;
 function Or(...args) {
     return new compositeClause(args, " OR ");
 }
@@ -182,6 +369,60 @@ function In(col, ...values) {
     return new inClause(col, values);
 }
 exports.In = In;
+// if string defaults to english
+// https://www.postgresql.org/docs/current/textsearch-controls.html#TEXTSEARCH-PARSING-QUERIES
+// to_tsquery
+// plainto_tsquery
+// phraseto_tsquery;
+// websearch_to_tsquery
+function TsQuery(col, val) {
+    return new tsQueryClause(col, val);
+}
+exports.TsQuery = TsQuery;
+function PlainToTsQuery(col, val) {
+    return new plainToTsQueryClause(col, val);
+}
+exports.PlainToTsQuery = PlainToTsQuery;
+function PhraseToTsQuery(col, val) {
+    return new phraseToTsQueryClause(col, val);
+}
+exports.PhraseToTsQuery = PhraseToTsQuery;
+function WebsearchToTsQuery(col, val) {
+    return new websearchTosQueryClause(col, val);
+}
+exports.WebsearchToTsQuery = WebsearchToTsQuery;
+// TsVectorColTsQuery is used when the column is not a tsvector field e.g.
+// when there's an index just on the field and is not a combination of multiple fields
+function TsVectorColTsQuery(col, val) {
+    return new tsQueryClause(col, val, true);
+}
+exports.TsVectorColTsQuery = TsVectorColTsQuery;
+// TsVectorPlainToTsQuery is used when the column is not a tsvector field e.g.
+// when there's an index just on the field and is not a combination of multiple fields
+// TODO do these 4 need TsQuery because would be nice to have language?
+// it seems to default to the config of the column
+function TsVectorPlainToTsQuery(col, val) {
+    return new plainToTsQueryClause(col, val, true);
+}
+exports.TsVectorPlainToTsQuery = TsVectorPlainToTsQuery;
+// TsVectorPhraseToTsQuery is used when the column is not a tsvector field e.g.
+// when there's an index just on the field and is not a combination of multiple fields
+function TsVectorPhraseToTsQuery(col, val) {
+    return new phraseToTsQueryClause(col, val, true);
+}
+exports.TsVectorPhraseToTsQuery = TsVectorPhraseToTsQuery;
+// TsVectorWebsearchToTsQuery is used when the column is not a tsvector field e.g.
+// when there's an index just on the field and is not a combination of multiple fields
+function TsVectorWebsearchToTsQuery(col, val) {
+    return new websearchTosQueryClause(col, val, true);
+}
+exports.TsVectorWebsearchToTsQuery = TsVectorWebsearchToTsQuery;
+// TODO would be nice to support this with building blocks but not supporting for now
+// AND: foo & bar,
+// OR: foo | bar
+// followed by: foo <-> bar
+// NOT: !foo
+// starts_with: theo:*
 // wrap a query in the db with this to ensure that it doesn't show up in the logs
 // e.g. if querying for password, SSN, etc
 // we'll pass the right fields to query and log something along the lines of `****`