@ff00ff/mammoth - npm Package Compare versions

Comparing version 1.0.0-rc.6 to 1.0.0-rc.7

.build/data-types.d.ts

@@ -7,2 +7,3 @@ export declare const dataType: <T>(dataType: string) => import("./column").ColumnDefinition<T, false, false>;
 export declare const timestamptz: () => import("./column").ColumnDefinition<Date, false, false>;
+export declare const boolean: () => import("./column").ColumnDefinition<boolean, false, false>;
 export declare const citext: () => import("./column").ColumnDefinition<string, false, false>;
@@ -9,0 +10,0 @@ export declare const caseInsensitiveText: () => import("./column").ColumnDefinition<string, false, false>;

.build/data-types.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.time = exports.date = exports.timestamp = exports.timestampWithoutTimeZone = exports.jsonb = exports.json = exports.smallserial = exports.bigserial = exports.serial = exports.decimal = exports.caseInsensitiveText = exports.citext = exports.timestamptz = exports.timestampWithTimeZone = exports.integer = exports.text = exports.uuid = exports.dataType = void 0;
+exports.time = exports.date = exports.timestamp = exports.timestampWithoutTimeZone = exports.jsonb = exports.json = exports.smallserial = exports.bigserial = exports.serial = exports.decimal = exports.caseInsensitiveText = exports.citext = exports.boolean = exports.timestamptz = exports.timestampWithTimeZone = exports.integer = exports.text = exports.uuid = exports.dataType = void 0;
 const column_1 = require("./column");
@@ -11,2 +11,3 @@ exports.dataType = (dataType) => column_1.makeColumnDefinition(dataType);
 exports.timestamptz = () => column_1.makeColumnDefinition(`timestamp with time zone`);
+exports.boolean = () => column_1.makeColumnDefinition(`boolean`);
 exports.citext = () => column_1.makeColumnDefinition(`citext`);
@@ -13,0 +14,0 @@ exports.caseInsensitiveText = () => column_1.makeColumnDefinition(`citext`);

.build/delete.d.ts

 import { Token } from './tokens';
 import type { GetReturning, QueryExecutorFn, ResultType } from './types';
 import type { Table, TableDefinition } from './table';
-import type { Condition } from './condition';
+import { Expression } from './expression';
 import { Query } from './query';
@@ -20,3 +20,3 @@ import type { ResultSet } from './result-set';
     using(...fromItems: Table<any, any>[]): DeleteQuery<T, Returning>;
-    where(condition: Condition): DeleteQuery<T, Returning>;
+    where(condition: Expression<boolean, boolean, string>): DeleteQuery<T, Returning>;
     whereCurrentOf(cursorName: string): DeleteQuery<T, Returning>;
@@ -23,0 +23,0 @@ returning<C1 extends keyof (T extends Table<string, infer Columns> ? Columns : never)>(column1: C1): DeleteQuery<T, GetReturning<T extends Table<string, infer Columns> ? Columns : never, C1>>;

.build/expression.d.ts

@@ -0,4 +1,3 @@
+import { BooleanQuery, Query, SpecificQuery } from './query';
 import { Token } from './tokens';
-import { Condition } from './condition';
-import { Query } from './query';
 export declare class Expression<DataType, IsNotNull extends boolean, Name extends string> {
@@ -13,32 +12,40 @@ private readonly tokens;
     private getDataTypeTokens;
+    private toGroup;
+    or<Q extends Query<any>>(expression: Expression<boolean, any, any> | BooleanQuery<Q>): DefaultExpression<boolean>;
+    and<Q extends Query<any>>(expression: Expression<boolean, any, any> | BooleanQuery<Q>): DefaultExpression<boolean>;
+    andNotExists(expression: Expression<any, any, any> | Query<any>): DefaultExpression<boolean>;
+    andExists(expression: Expression<any, any, any> | Query<any>): DefaultExpression<boolean>;
     as<AliasName extends string>(name: AliasName): Expression<DataType, IsNotNull, AliasName>;
-    isNull(): Condition;
-    isNotNull(): Condition;
-    asc(): Expression<DataType, IsNotNull, '?column?'>;
-    desc(): Expression<DataType, IsNotNull, '?column?'>;
-    nullsFirst(): Expression<DataType, IsNotNull, '?column?'>;
-    nullsLast(): Expression<DataType, IsNotNull, '?column?'>;
-    in(array: DataType[] | Expression<DataType, IsNotNull, any> | Query<any>): Condition;
-    notIn(array: DataType[] | Expression<DataType, IsNotNull, any> | Query<any>): Condition;
-    plus(value: DataType | Expression<DataType, IsNotNull, any>): Expression<DataType, IsNotNull, '?column?'>;
-    minus(value: DataType | Expression<DataType, IsNotNull, any>): Expression<DataType, IsNotNull, '?column?'>;
-    multiply(value: DataType | Expression<DataType, IsNotNull, any>): Expression<DataType, IsNotNull, '?column?'>;
-    divide(value: DataType | Expression<DataType, IsNotNull, any>): Expression<DataType, IsNotNull, '?column?'>;
-    modulo(value: DataType | Expression<DataType, IsNotNull, any>): Expression<DataType, IsNotNull, '?column?'>;
-    concat(value: DataType | Expression<DataType, IsNotNull, any>): Expression<DataType, IsNotNull, '?column?'>;
-    between(a: DataType, b: DataType): Condition;
-    betweenSymmetric(a: DataType, b: DataType): Condition;
-    isDistinctFrom(a: DataType): Condition;
-    isNotDistinctFrom(a: DataType): Condition;
-    like(value: DataType): Condition;
-    ilike(value: DataType): Condition;
-    eq(value: DataType | Expression<DataType, IsNotNull, any> | Query<any>): Condition;
-    ne(value: DataType | Expression<DataType, IsNotNull, any> | Query<any>): Condition;
-    gt(value: DataType | Expression<DataType, IsNotNull, any> | Query<any>): Condition;
-    gte(value: DataType | Expression<DataType, IsNotNull, any> | Query<any>): Condition;
-    lt(value: DataType | Expression<DataType, IsNotNull, any> | Query<any>): Condition;
-    lte(value: DataType | Expression<DataType, IsNotNull, any> | Query<any>): Condition;
-    orderBy(...expressions: Expression<any, any, any>[]): Expression<DataType, IsNotNull, '?column?'>;
+    isNull(): DefaultExpression<boolean>;
+    isNotNull(): DefaultExpression<boolean>;
+    asc(): DefaultExpression<DataType, IsNotNull>;
+    desc(): DefaultExpression<DataType, IsNotNull>;
+    nullsFirst(): DefaultExpression<DataType, IsNotNull>;
+    nullsLast(): DefaultExpression<DataType, IsNotNull>;
+    in<Q extends Query<any>>(array: DataType[] | Expression<DataType, IsNotNull, any> | SpecificQuery<DataType, Q>): DefaultExpression<boolean>;
+    notIn(array: DataType[] | Expression<DataType, IsNotNull, any> | Query<any>): DefaultExpression<boolean>;
+    plus(value: DataType | Expression<DataType, IsNotNull, any>): DefaultExpression<DataType, IsNotNull>;
+    minus(value: DataType | Expression<DataType, IsNotNull, any>): DefaultExpression<DataType, IsNotNull>;
+    multiply(value: DataType | Expression<DataType, IsNotNull, any>): DefaultExpression<DataType, IsNotNull>;
+    divide(value: DataType | Expression<DataType, IsNotNull, any>): DefaultExpression<DataType, IsNotNull>;
+    modulo(value: DataType | Expression<DataType, IsNotNull, any>): DefaultExpression<DataType, IsNotNull>;
+    concat(value: DataType | Expression<DataType, IsNotNull, any>): DefaultExpression<DataType, IsNotNull>;
+    between(a: DataType, b: DataType): DefaultExpression<boolean>;
+    betweenSymmetric(a: DataType, b: DataType): DefaultExpression<boolean>;
+    isDistinctFrom(a: DataType): DefaultExpression<boolean>;
+    isNotDistinctFrom(a: DataType): DefaultExpression<boolean>;
+    like(value: DataType): DefaultExpression<boolean>;
+    ilike(value: DataType): DefaultExpression<boolean>;
+    eq<Q extends Query<any>>(value: DataType | Expression<DataType, boolean, any> | SpecificQuery<DataType, Q>): DefaultExpression<boolean>;
+    ne<Q extends Query<any>>(value: DataType | Expression<DataType, boolean, any> | SpecificQuery<DataType, Q>): DefaultExpression<boolean>;
+    gt<Q extends Query<any>>(value: DataType | Expression<DataType, boolean, any> | SpecificQuery<DataType, Q>): DefaultExpression<boolean>;
+    gte<Q extends Query<any>>(value: DataType | Expression<DataType, boolean, any> | SpecificQuery<DataType, Q>): DefaultExpression<boolean>;
+    lt<Q extends Query<any>>(value: DataType | Expression<DataType, boolean, any> | SpecificQuery<DataType, Q>): DefaultExpression<boolean>;
+    lte<Q extends Query<any>>(value: DataType | Expression<DataType, boolean, any> | SpecificQuery<DataType, Q>): DefaultExpression<boolean>;
+    orderBy(...expressions: Expression<any, any, any>[]): DefaultExpression<DataType, IsNotNull>;
     /** @internal */
     toTokens(includeAlias?: boolean): Token[];
 }
+export declare class DefaultExpression<DataType, IsNotNull extends boolean = true> extends Expression<DataType, IsNotNull, '?column?'> {
+    constructor(tokens: Token[]);
+}

.build/expression.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Expression = void 0;
+exports.DefaultExpression = exports.Expression = void 0;
+const query_1 = require("./query");
 const tokens_1 = require("./tokens");
-const condition_1 = require("./condition");
-const query_1 = require("./query");
+class Explain {
+}
 class Expression {
@@ -29,2 +30,42 @@ constructor(tokens, name, nameIsAlias = false) {
     }
+    toGroup(expression) {
+        const newTokens = expression.toTokens();
+        // Anything above 3 means we need to start grouping this in ( and ).
+        if (newTokens.length > 3) {
+            return new tokens_1.GroupToken(newTokens);
+        }
+        return new tokens_1.CollectionToken(newTokens);
+    }
+    // TODO: only include
+    // or: DataType extends boolean
+    //   ? (expression: Expression<boolean, boolean, string>) => void
+    //   : Explain<
+    //       'Expression#or() is only available on boolean expressions. Is this a boolean expression?'
+    //     > = (() => {
+    //   //
+    // }) as any;
+    or(expression) {
+        return new DefaultExpression([...this.tokens, new tokens_1.StringToken(`OR`), this.toGroup(expression)]);
+    }
+    and(expression) {
+        return new DefaultExpression([
+            ...this.tokens,
+            new tokens_1.StringToken(`AND`),
+            this.toGroup(expression),
+        ]);
+    }
+    andNotExists(expression) {
+        return new DefaultExpression([
+            ...this.tokens,
+            new tokens_1.StringToken(`AND NOT EXISTS`),
+            this.toGroup(expression),
+        ]);
+    }
+    andExists(expression) {
+        return new DefaultExpression([
+            ...this.tokens,
+            new tokens_1.StringToken(`AND EXISTS`),
+            this.toGroup(expression),
+        ]);
+    }
     as(name) {
@@ -37,22 +78,22 @@ if (this.tokens.length > 2) {
     isNull() {
-        return condition_1.makeCondition([...this.tokens, new tokens_1.StringToken(`IS NULL`)]);
+        return new DefaultExpression([...this.tokens, new tokens_1.StringToken(`IS NULL`)]);
     }
     isNotNull() {
-        return condition_1.makeCondition([...this.tokens, new tokens_1.StringToken(`IS NOT NULL`)]);
+        return new DefaultExpression([...this.tokens, new tokens_1.StringToken(`IS NOT NULL`)]);
     }
     asc() {
-        return new Expression([...this.tokens, new tokens_1.StringToken(`ASC`)], '?column?');
+        return new DefaultExpression([...this.tokens, new tokens_1.StringToken(`ASC`)]);
     }
     desc() {
-        return new Expression([...this.tokens, new tokens_1.StringToken(`DESC`)], '?column?');
+        return new DefaultExpression([...this.tokens, new tokens_1.StringToken(`DESC`)]);
     }
     nullsFirst() {
-        return new Expression([...this.tokens, new tokens_1.StringToken(`NULLS FIRST`)], '?column?');
+        return new DefaultExpression([...this.tokens, new tokens_1.StringToken(`NULLS FIRST`)]);
     }
     nullsLast() {
-        return new Expression([...this.tokens, new tokens_1.StringToken(`NULLS LAST`)], '?column?');
+        return new DefaultExpression([...this.tokens, new tokens_1.StringToken(`NULLS LAST`)]);
     }
     in(array) {
         if (array && ('toTokens' in array || array instanceof query_1.Query)) {
-            return condition_1.makeCondition([
+            return new DefaultExpression([
                 ...this.tokens,
@@ -64,3 +105,3 @@ new tokens_1.StringToken(`IN`),
         else {
-            return condition_1.makeCondition([
+            return new DefaultExpression([
                 ...this.tokens,
@@ -76,3 +117,3 @@ new tokens_1.StringToken(`IN`),
         if (array && ('toTokens' in array || array instanceof query_1.Query)) {
-            return condition_1.makeCondition([
+            return new DefaultExpression([
                 ...this.tokens,
@@ -84,3 +125,3 @@ new tokens_1.StringToken(`NOT IN`),
         else {
-            return condition_1.makeCondition([
+            return new DefaultExpression([
                 ...this.tokens,
@@ -95,21 +136,45 @@ new tokens_1.StringToken(`NOT IN`),
     plus(value) {
-        return new Expression([...this.tokens, new tokens_1.StringToken(`+`), ...this.getDataTypeTokens(value)], '?column?');
+        return new DefaultExpression([
+            ...this.tokens,
+            new tokens_1.StringToken(`+`),
+            ...this.getDataTypeTokens(value),
+        ]);
     }
     minus(value) {
-        return new Expression([...this.tokens, new tokens_1.StringToken(`-`), ...this.getDataTypeTokens(value)], '?column?');
+        return new DefaultExpression([
+            ...this.tokens,
+            new tokens_1.StringToken(`-`),
+            ...this.getDataTypeTokens(value),
+        ]);
     }
     multiply(value) {
-        return new Expression([...this.tokens, new tokens_1.StringToken(`*`), ...this.getDataTypeTokens(value)], '?column?');
+        return new DefaultExpression([
+            ...this.tokens,
+            new tokens_1.StringToken(`*`),
+            ...this.getDataTypeTokens(value),
+        ]);
     }
     divide(value) {
-        return new Expression([...this.tokens, new tokens_1.StringToken(`/`), ...this.getDataTypeTokens(value)], '?column?');
+        return new DefaultExpression([
+            ...this.tokens,
+            new tokens_1.StringToken(`/`),
+            ...this.getDataTypeTokens(value),
+        ]);
     }
     modulo(value) {
-        return new Expression([...this.tokens, new tokens_1.StringToken(`%`), ...this.getDataTypeTokens(value)], '?column?');
+        return new DefaultExpression([
+            ...this.tokens,
+            new tokens_1.StringToken(`%`),
+            ...this.getDataTypeTokens(value),
+        ]);
     }
     concat(value) {
-        return new Expression([...this.tokens, new tokens_1.StringToken(`||`), ...this.getDataTypeTokens(value)], '?column?');
+        return new DefaultExpression([
+            ...this.tokens,
+            new tokens_1.StringToken(`||`),
+            ...this.getDataTypeTokens(value),
+        ]);
     }
     between(a, b) {
-        return condition_1.makeCondition([
+        return new DefaultExpression([
             ...this.tokens,
@@ -123,3 +188,3 @@ new tokens_1.StringToken(`BETWEEN`),
     betweenSymmetric(a, b) {
-        return condition_1.makeCondition([
+        return new DefaultExpression([
             ...this.tokens,
@@ -133,3 +198,3 @@ new tokens_1.StringToken(`BETWEEN SYMMETRIC`),
     isDistinctFrom(a) {
-        return condition_1.makeCondition([
+        return new DefaultExpression([
             ...this.tokens,
@@ -141,3 +206,3 @@ new tokens_1.StringToken(`IS DISTINCT FROM`),
     isNotDistinctFrom(a) {
-        return condition_1.makeCondition([
+        return new DefaultExpression([
             ...this.tokens,
@@ -149,31 +214,63 @@ new tokens_1.StringToken(`IS NOT DISTINCT FROM`),
     like(value) {
-        return condition_1.makeCondition([...this.tokens, new tokens_1.StringToken(`LIKE`), new tokens_1.ParameterToken(value)]);
+        return new DefaultExpression([
+            ...this.tokens,
+            new tokens_1.StringToken(`LIKE`),
+            new tokens_1.ParameterToken(value),
+        ]);
     }
     ilike(value) {
-        return condition_1.makeCondition([...this.tokens, new tokens_1.StringToken(`ILIKE`), new tokens_1.ParameterToken(value)]);
+        return new DefaultExpression([
+            ...this.tokens,
+            new tokens_1.StringToken(`ILIKE`),
+            new tokens_1.ParameterToken(value),
+        ]);
     }
     eq(value) {
-        return condition_1.makeCondition([...this.tokens, new tokens_1.StringToken(`=`), ...this.getDataTypeTokens(value)]);
+        return new DefaultExpression([
+            ...this.tokens,
+            new tokens_1.StringToken(`=`),
+            ...this.getDataTypeTokens(value),
+        ]);
     }
     ne(value) {
-        return condition_1.makeCondition([...this.tokens, new tokens_1.StringToken(`<>`), ...this.getDataTypeTokens(value)]);
+        return new DefaultExpression([
+            ...this.tokens,
+            new tokens_1.StringToken(`<>`),
+            ...this.getDataTypeTokens(value),
+        ]);
     }
     gt(value) {
-        return condition_1.makeCondition([...this.tokens, new tokens_1.StringToken(`>`), ...this.getDataTypeTokens(value)]);
+        return new DefaultExpression([
+            ...this.tokens,
+            new tokens_1.StringToken(`>`),
+            ...this.getDataTypeTokens(value),
+        ]);
     }
     gte(value) {
-        return condition_1.makeCondition([...this.tokens, new tokens_1.StringToken(`>=`), ...this.getDataTypeTokens(value)]);
+        return new DefaultExpression([
+            ...this.tokens,
+            new tokens_1.StringToken(`>=`),
+            ...this.getDataTypeTokens(value),
+        ]);
     }
     lt(value) {
-        return condition_1.makeCondition([...this.tokens, new tokens_1.StringToken(`<`), ...this.getDataTypeTokens(value)]);
+        return new DefaultExpression([
+            ...this.tokens,
+            new tokens_1.StringToken(`<`),
+            ...this.getDataTypeTokens(value),
+        ]);
     }
     lte(value) {
-        return condition_1.makeCondition([...this.tokens, new tokens_1.StringToken(`<=`), ...this.getDataTypeTokens(value)]);
+        return new DefaultExpression([
+            ...this.tokens,
+            new tokens_1.StringToken(`<=`),
+            ...this.getDataTypeTokens(value),
+        ]);
     }
     orderBy(...expressions) {
-        return new Expression([
+        return new DefaultExpression([
             ...this.tokens,
             new tokens_1.StringToken(`ORDER BY`),
             new tokens_1.SeparatorToken(',', expressions.map((expression) => new tokens_1.CollectionToken(expression.toTokens()))),
-        ], '?column?');
+        ]);
     }
@@ -191,1 +288,7 @@ /** @internal */
 exports.Expression = Expression;
+class DefaultExpression extends Expression {
+    constructor(tokens) {
+        super(tokens, '?column?');
+    }
+}
+exports.DefaultExpression = DefaultExpression;

.build/insert.d.ts

@@ -6,3 +6,2 @@ import { Token } from './tokens';
 import { Column } from './column';
-import { Condition } from './condition';
 import { DeleteQuery } from './delete';
@@ -34,3 +33,3 @@ import { Expression } from './expression';
     returning<C1 extends keyof TableColumns, C2 extends keyof TableColumns, C3 extends keyof TableColumns, C4 extends keyof TableColumns, C5 extends keyof TableColumns, C6 extends keyof TableColumns, C7 extends keyof TableColumns, C8 extends keyof TableColumns, C9 extends keyof TableColumns, C10 extends keyof TableColumns>(column1: C1, column2: C2, column3: C3, column4: C4, column5: C5, column6: C6, column7: C7, column8: C8, column9: C9, column10: C10): InsertQuery<T, GetReturning<TableColumns, C1> & GetReturning<TableColumns, C2> & GetReturning<TableColumns, C3> & GetReturning<TableColumns, C4> & GetReturning<TableColumns, C5> & GetReturning<TableColumns, C6> & GetReturning<TableColumns, C7> & GetReturning<TableColumns, C8> & GetReturning<TableColumns, C9> & GetReturning<TableColumns, C10>>;
-    where(condition: Condition): InsertQuery<T, number, T extends Table<any, infer Columns> ? Columns : never>;
+    where(expression: Expression<boolean, boolean, string>): InsertQuery<T, number, T extends Table<any, infer Columns> ? Columns : never>;
     onConflictOnConstraint(constraintName: string): {
@@ -37,0 +36,0 @@ doNothing(): InsertQuery<T, number, T extends Table<any, infer Columns> ? Columns : never>;

.build/insert.js

@@ -46,7 +46,7 @@ "use strict";
     }
-    where(condition) {
+    where(expression) {
         return new InsertQuery(this.queryExecutor, this.returningKeys, this.table, this.resultType, [
             ...this.tokens,
             new tokens_1.StringToken(`WHERE`),
-            ...condition.toTokens(),
+            ...expression.toTokens(),
         ]);
@@ -53,0 +53,0 @@ }

.build/query.d.ts

@@ -0,2 +1,7 @@
+import { ResultSet } from './result-set';
 import { Token } from './tokens';
+export declare type SpecificQuery<DataType, Q extends Query<any>, Result = ResultSet<Q, false>> = Result extends {
+    [K in keyof Result]: DataType | undefined;
+} ? Q : never;
+export declare type BooleanQuery<Q extends Query<any>> = SpecificQuery<boolean, Q>;
 export declare abstract class Query<Returning> {
@@ -3,0 +8,0 @@ private _queryBrand;

.build/query.js

 "use strict";
-// This is used so we can capture the Returning of every different query type without having to
-// specify every query seperately. The private property is used to simulate a nominal type so only
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -5,0 +3,0 @@ exports.Query = void 0;

.build/select.d.ts

 import { Token } from './tokens';
 import { Table, TableDefinition } from './table';
 import { Column } from './column';
-import { Condition } from './condition';
 import { Expression } from './expression';
@@ -52,7 +51,7 @@ import { Query } from './query';
     toTokens(): Token[];
-    on(joinCondition: Condition): SelectQuery<Columns>;
+    on(joinCondition: Expression<boolean, boolean, string>): SelectQuery<Columns>;
     using(...columns: Column<any, any, any, any, any, any>[]): SelectQuery<Columns>;
-    where(condition: Condition): SelectQuery<Columns>;
+    where(condition: Expression<boolean, boolean, string>): SelectQuery<Columns>;
     groupBy(...expressions: Expression<any, any, any>[]): SelectQuery<Columns>;
-    having(...conditions: Condition[]): SelectQuery<Columns>;
+    having(...conditions: Expression<boolean, boolean, string>[]): SelectQuery<Columns>;
     window(): SelectQuery<Columns>;
@@ -59,0 +58,0 @@ orderBy(...expressions: Expression<any, any, any>[]): SelectQuery<Columns>;

.build/sql-functions.d.ts

@@ -1,3 +0,2 @@
-import { Condition } from './condition';
-import { Expression } from './expression';
+import { DefaultExpression, Expression } from './expression';
 import { Query } from './query';
@@ -17,10 +16,12 @@ export declare const stringAgg: (expression: Expression<string, boolean, any>, delimiter: string, ...orderBy: Expression<any, any, any>[]) => Expression<string, false, 'stringAgg'>;
 export declare const xmlagg: <DataType>(expression: Expression<DataType, boolean, any>) => Expression<number, false, "xmlagg">;
-export declare const not: (condition: Condition) => Condition;
-export declare const and: (condition: Condition) => Condition;
-export declare const or: (condition: Condition) => Condition;
-export declare const group: (condition: Condition) => Condition;
+export declare const not: (expression: Expression<boolean, boolean, string>) => DefaultExpression<boolean, true>;
+export declare const and: (expression: Expression<boolean, boolean, string>) => DefaultExpression<boolean, true>;
+export declare const or: (expression: Expression<boolean, boolean, string>) => DefaultExpression<boolean, true>;
+export declare const group: (expression: Expression<boolean, boolean, string>) => DefaultExpression<boolean, true>;
 export declare const any: <T>(array: T[]) => Expression<T, true, "?column?">;
 export declare const now: () => Expression<Date, true, "now">;
-export declare const exists: (expression: Expression<any, any, any> | Query<any>) => Condition;
-export declare const notExists: (expression: Expression<any, any, any> | Query<any>) => Condition;
+export declare const exists: (expression: Expression<any, any, any> | Query<any>) => DefaultExpression<boolean>;
+export declare const andNotExists: (expression: Expression<any, any, any> | Query<any>) => DefaultExpression<boolean>;
+export declare const andExists: (expression: Expression<any, any, any> | Query<any>) => DefaultExpression<boolean>;
+export declare const notExists: (expression: Expression<any, any, any> | Query<any>) => DefaultExpression<boolean>;
 export declare const coalesce: <DataType>(...expressions: (DataType | Expression<DataType, boolean, any>)[]) => Expression<DataType, true, "coalesce">;

.build/sql-functions.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.coalesce = exports.notExists = exports.exists = exports.now = exports.any = exports.group = exports.or = exports.and = exports.not = exports.xmlagg = exports.sum = exports.avg = exports.max = exports.min = exports.count = exports.arrayAgg = exports.every = exports.boolOr = exports.boolAnd = exports.bitOr = exports.bitAnd = exports.stringAgg = void 0;
+exports.coalesce = exports.notExists = exports.andExists = exports.andNotExists = exports.exists = exports.now = exports.any = exports.group = exports.or = exports.and = exports.not = exports.xmlagg = exports.sum = exports.avg = exports.max = exports.min = exports.count = exports.arrayAgg = exports.every = exports.boolOr = exports.boolAnd = exports.bitOr = exports.bitAnd = exports.stringAgg = void 0;
 const tokens_1 = require("./tokens");
-const condition_1 = require("./condition");
 const expression_1 = require("./expression");
@@ -44,10 +43,12 @@ exports.stringAgg = (expression, delimiter, ...orderBy) => {
 exports.xmlagg = (expression) => new expression_1.Expression([new tokens_1.StringToken(`xmlagg`), new tokens_1.GroupToken(expression.toTokens())], 'xmlagg');
-exports.not = (condition) => condition_1.makeCondition([new tokens_1.StringToken(`NOT`), new tokens_1.GroupToken(condition.toTokens())]);
-exports.and = (condition) => condition_1.makeCondition([new tokens_1.StringToken(`AND`), new tokens_1.GroupToken(condition.toTokens())]);
-exports.or = (condition) => condition_1.makeCondition([new tokens_1.StringToken(`OR`), new tokens_1.GroupToken(condition.toTokens())]);
-exports.group = (condition) => condition_1.makeCondition([new tokens_1.GroupToken(condition.toTokens())]);
+exports.not = (expression) => new expression_1.DefaultExpression([new tokens_1.StringToken(`NOT`), new tokens_1.GroupToken(expression.toTokens())]);
+exports.and = (expression) => new expression_1.DefaultExpression([new tokens_1.StringToken(`AND`), new tokens_1.GroupToken(expression.toTokens())]);
+exports.or = (expression) => new expression_1.DefaultExpression([new tokens_1.StringToken(`OR`), new tokens_1.GroupToken(expression.toTokens())]);
+exports.group = (expression) => new expression_1.DefaultExpression([new tokens_1.GroupToken(expression.toTokens())]);
 exports.any = (array) => new expression_1.Expression([new tokens_1.StringToken(`ANY`), new tokens_1.GroupToken([new tokens_1.ParameterToken(array)])], '?column?');
 exports.now = () => new expression_1.Expression([new tokens_1.StringToken(`NOW()`)], 'now');
-exports.exists = (expression) => condition_1.makeCondition([new tokens_1.StringToken(`EXISTS`), new tokens_1.GroupToken(expression.toTokens())]);
-exports.notExists = (expression) => condition_1.makeCondition([new tokens_1.StringToken(`NOT EXISTS`), new tokens_1.GroupToken(expression.toTokens())]);
+exports.exists = (expression) => new expression_1.DefaultExpression([new tokens_1.StringToken(`EXISTS`), new tokens_1.GroupToken(expression.toTokens())]);
+exports.andNotExists = (expression) => new expression_1.DefaultExpression([new tokens_1.StringToken(`AND NOT EXISTS`), new tokens_1.GroupToken(expression.toTokens())]);
+exports.andExists = (expression) => new expression_1.DefaultExpression([new tokens_1.StringToken(`AND EXISTS`), new tokens_1.GroupToken(expression.toTokens())]);
+exports.notExists = (expression) => new expression_1.DefaultExpression([new tokens_1.StringToken(`NOT EXISTS`), new tokens_1.GroupToken(expression.toTokens())]);
 exports.coalesce = (...expressions) => {
@@ -54,0 +55,0 @@ return new expression_1.Expression([

.build/update.d.ts

 import { Token } from './tokens';
 import { GetReturning, QueryExecutorFn, ResultType } from './types';
 import { Column } from './column';
-import { Condition } from './condition';
 import { Expression } from './expression';
@@ -20,3 +19,3 @@ import { Query } from './query';
     then(onFulfilled?: ((value: Returning extends number ? Returning : ResultSet<UpdateQuery<T, Returning>, false>[]) => any | PromiseLike<any>) | undefined | null, onRejected?: ((reason: any) => void | PromiseLike<void>) | undefined | null): Promise<any>;
-    where(condition: Condition): UpdateQuery<T, Returning>;
+    where(condition: Expression<boolean, boolean, string>): UpdateQuery<T, Returning>;
     whereCurrentOf(cursorName: string): UpdateQuery<T, number, T extends Table<any, infer Columns> ? Columns : never>;
@@ -23,0 +22,0 @@ from(fromItem: Table<any, any>): UpdateQuery<T, Returning>;

package.json

 {
   "name": "@ff00ff/mammoth",
   "license": "MIT",
-  "version": "1.0.0-rc.6",
+  "version": "1.0.0-rc.7",
   "main": "./.build/index.js",
@@ -22,5 +22,5 @@ "types": "./.build/index.d.ts",
     "@types/jest": "^26.0.14",
-    "@types/node": "^14.11.2",
+    "@types/node": "^14.11.8",
     "dts-jest": "^23.3.0",
-    "jest": "^26.4.2",
+    "jest": "^26.5.3",
     "prettier": "^2.1.2",
@@ -27,0 +27,0 @@ "ts-jest": "^26.4.1",

README.md

@@ -10,3 +10,3 @@ ![Mammoth](https://s3-eu-west-1.amazonaws.com/mammoth-static.ff00ff.nl/mammoth-logo.png)
 ```
-npm i @ff00ff/mammoth@1.0.0-rc.6
+npm i @ff00ff/mammoth@1.0.0-rc.7
 ```
@@ -13,0 +13,0 @@

No alert changes

Improved metrics

Total package byte prevSize

121681

increased by2.19%

Lines of code

1943

increased by3.79%

Worsened metrics

Number of package files

51

decreased by-3.77%

No dependency changes