@bessemer/cornerstone 0.5.29 → 0.5.31

package/dist/expression/core-expression.d.ts

@@ -0,0 +1,42 @@
+import { Expression } from '@bessemer/cornerstone/expression';
+import { BasicType } from '@bessemer/cornerstone/types';
+import { Signatures } from '@bessemer/cornerstone';
+export declare const ValueExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<unknown, [value: unknown], {
+    value: unknown;
+}>;
+export declare const VariableExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<{}, [name: string], Expression<{}> & {
+    name: string;
+}>;
+export declare const NotExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<boolean, [value: Expression<boolean>], Expression<boolean> & {
+    value: Expression<boolean>;
+}>;
+export declare const AndExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<boolean, [operands: Expression<boolean>[]], Expression<boolean> & {
+    operands: Expression<boolean>[];
+}>;
+export declare const OrExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<boolean, [operands: Expression<boolean>[]], Expression<boolean> & {
+    operands: Expression<boolean>[];
+}>;
+export declare const EqualsExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<boolean, [operands: Expression<Signatures.Signable>[]], Expression<boolean> & {
+    operands: Expression<Signatures.Signable>[];
+}>;
+export declare const ContainsExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<boolean, [collection: Expression<Signatures.Signable[]>, operands: Expression<Signatures.Signable>[]], Expression<boolean> & {
+    collection: Expression<Signatures.Signable[]>;
+    operands: Expression<Signatures.Signable>[];
+}>;
+export declare const LessThanExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<boolean, [left: Expression<BasicType>, right: Expression<BasicType>], Expression<boolean> & {
+    left: Expression<BasicType>;
+    right: Expression<BasicType>;
+}>;
+export declare const LessThanOrEqualExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<boolean, [left: Expression<BasicType>, right: Expression<BasicType>], Expression<boolean> & {
+    left: Expression<BasicType>;
+    right: Expression<BasicType>;
+}>;
+export declare const GreaterThanExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<boolean, [left: Expression<BasicType>, right: Expression<BasicType>], Expression<boolean> & {
+    left: Expression<BasicType>;
+    right: Expression<BasicType>;
+}>;
+export declare const GreaterThanOrEqualExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<boolean, [left: Expression<BasicType>, right: Expression<BasicType>], Expression<boolean> & {
+    left: Expression<BasicType>;
+    right: Expression<BasicType>;
+}>;
+//# sourceMappingURL=core-expression.d.ts.map

package/dist/expression/core-expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-expression.d.ts","sourceRoot":"","sources":["../../src/expression/core-expression.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAA;AAC7D,OAAO,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAA;AACvD,OAAO,EAAkC,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAGlF,eAAO,MAAM,eAAe;;EAQ1B,CAAA;AAEF,eAAO,MAAM,kBAAkB;;EAU7B,CAAA;AAEF,eAAO,MAAM,aAAa;;EAQxB,CAAA;AAEF,eAAO,MAAM,aAAa;;EAUxB,CAAA;AAEF,eAAO,MAAM,YAAY;;EAUvB,CAAA;AAEF,eAAO,MAAM,gBAAgB;;EAe3B,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;EAU7B,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;EAQ7B,CAAA;AAEF,eAAO,MAAM,yBAAyB;;;EAQpC,CAAA;AAEF,eAAO,MAAM,qBAAqB;;;EAQhC,CAAA;AAEF,eAAO,MAAM,4BAA4B;;;EAQvC,CAAA"}

package/dist/expression/core-expression.js

@@ -0,0 +1,129 @@
+// src/expression/core-expression.ts
+import { defineExpression } from "@bessemer/cornerstone/expression/internal";
+import { Arrays, Objects, Preconditions, Signatures } from "@bessemer/cornerstone";
+var ValueExpression = defineExpression({
+  expressionKey: "Value",
+  builder: (value) => {
+    return { value };
+  },
+  resolver: ({ value }, evaluate, context) => {
+    return value;
+  }
+});
+var VariableExpression = defineExpression({
+  expressionKey: "Variable",
+  builder: (name) => {
+    return { name };
+  },
+  resolver: ({ name }, evaluate, context) => {
+    const value = context.variables[name];
+    Preconditions.isPresent(value);
+    return value;
+  }
+});
+var NotExpression = defineExpression({
+  expressionKey: "Not",
+  builder: (value) => {
+    return { value };
+  },
+  resolver: (expression, evaluate) => {
+    return !evaluate(expression.value);
+  }
+});
+var AndExpression = defineExpression({
+  expressionKey: "And",
+  builder: (operands) => {
+    return { operands };
+  },
+  resolver: (expression, evaluate) => {
+    const values = expression.operands.map((it) => evaluate(it));
+    const falseValue = values.find((it) => !it);
+    return Objects.isNil(falseValue);
+  }
+});
+var OrExpression = defineExpression({
+  expressionKey: "Or",
+  builder: (operands) => {
+    return { operands };
+  },
+  resolver: (expression, evaluate) => {
+    const values = expression.operands.map((it) => evaluate(it));
+    const trueValue = values.find((it) => it);
+    return Objects.isPresent(trueValue);
+  }
+});
+var EqualsExpression = defineExpression({
+  expressionKey: "Equals",
+  builder: (operands) => {
+    return { operands };
+  },
+  resolver: (expression, evaluate) => {
+    const values = expression.operands.map((it) => evaluate(it)).map(Signatures.sign);
+    if (values.length === 0) {
+      return true;
+    }
+    const first = values[0];
+    return values.every((val) => val === first);
+  }
+});
+var ContainsExpression = defineExpression({
+  expressionKey: "Contains",
+  builder: (collection, operands) => {
+    return { collection, operands };
+  },
+  resolver: (expression, evaluate) => {
+    const collection = evaluate(expression.collection);
+    const values = expression.operands.map((it) => evaluate(it));
+    return Arrays.containsAll(collection, values);
+  }
+});
+var LessThanExpression = defineExpression({
+  expressionKey: "Basic.LessThan",
+  builder: (left, right) => {
+    return { left, right };
+  },
+  resolver: ({ left, right }, evaluate) => {
+    return evaluate(left) < evaluate(right);
+  }
+});
+var LessThanOrEqualExpression = defineExpression({
+  expressionKey: "Basic.LessThanOrEqual",
+  builder: (left, right) => {
+    return { left, right };
+  },
+  resolver: ({ left, right }, evaluate) => {
+    return evaluate(left) <= evaluate(right);
+  }
+});
+var GreaterThanExpression = defineExpression({
+  expressionKey: "Basic.GreaterThan",
+  builder: (left, right) => {
+    return { left, right };
+  },
+  resolver: ({ left, right }, evaluate) => {
+    return evaluate(left) > evaluate(right);
+  }
+});
+var GreaterThanOrEqualExpression = defineExpression({
+  expressionKey: "Basic.GreaterThanOrEqual",
+  builder: (left, right) => {
+    return { left, right };
+  },
+  resolver: ({ left, right }, evaluate) => {
+    return evaluate(left) >= evaluate(right);
+  }
+});
+export {
+  AndExpression,
+  ContainsExpression,
+  EqualsExpression,
+  GreaterThanExpression,
+  GreaterThanOrEqualExpression,
+  LessThanExpression,
+  LessThanOrEqualExpression,
+  NotExpression,
+  OrExpression,
+  ValueExpression,
+  VariableExpression
+};
+//# sourceMappingURL=core-expression.js.map

package/dist/expression/core-expression.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/expression/core-expression.ts"],"sourcesContent":["import { defineExpression } from '@bessemer/cornerstone/expression/internal'\nimport { Expression } from '@bessemer/cornerstone/expression'\nimport { BasicType } from '@bessemer/cornerstone/types'\nimport { Arrays, Objects, Preconditions, Signatures } from '@bessemer/cornerstone'\nimport { Signable } from '@bessemer/cornerstone/signature'\n\nexport const ValueExpression = defineExpression({\n  expressionKey: 'Value',\n  builder: (value: unknown) => {\n    return { value }\n  },\n  resolver: ({ value }, evaluate, context) => {\n    return value\n  },\n})\n\nexport const VariableExpression = defineExpression({\n  expressionKey: 'Variable',\n  builder: (name: string) => {\n    return { name }\n  },\n  resolver: ({ name }, evaluate, context) => {\n    const value = context.variables[name]\n    Preconditions.isPresent(value)\n    return value\n  },\n})\n\nexport const NotExpression = defineExpression({\n  expressionKey: 'Not',\n  builder: (value: Expression<boolean>) => {\n    return { value }\n  },\n  resolver: (expression, evaluate) => {\n    return !evaluate(expression.value)\n  },\n})\n\nexport const AndExpression = defineExpression({\n  expressionKey: 'And',\n  builder: (operands: Array<Expression<boolean>>) => {\n    return { operands }\n  },\n  resolver: (expression, evaluate) => {\n    const values = expression.operands.map((it) => evaluate(it))\n    const falseValue = values.find((it) => !it)\n    return Objects.isNil(falseValue)\n  },\n})\n\nexport const OrExpression = defineExpression({\n  expressionKey: 'Or',\n  builder: (operands: Array<Expression<boolean>>) => {\n    return { operands }\n  },\n  resolver: (expression, evaluate) => {\n    const values = expression.operands.map((it) => evaluate(it))\n    const trueValue = values.find((it) => it)\n    return Objects.isPresent(trueValue)\n  },\n})\n\nexport const EqualsExpression = defineExpression({\n  expressionKey: 'Equals',\n  builder: (operands: Array<Expression<Signable>>) => {\n    return { operands }\n  },\n  resolver: (expression, evaluate) => {\n    const values = expression.operands.map((it) => evaluate(it)).map(Signatures.sign)\n\n    if (values.length === 0) {\n      return true\n    }\n\n    const first = values[0]\n    return values.every((val) => val === first)\n  },\n})\n\nexport const ContainsExpression = defineExpression({\n  expressionKey: 'Contains',\n  builder: (collection: Expression<Array<Signable>>, operands: Array<Expression<Signable>>) => {\n    return { collection, operands }\n  },\n  resolver: (expression, evaluate) => {\n    const collection = evaluate(expression.collection)\n    const values = expression.operands.map((it) => evaluate(it))\n    return Arrays.containsAll(collection, values)\n  },\n})\n\nexport const LessThanExpression = defineExpression({\n  expressionKey: 'Basic.LessThan',\n  builder: (left: Expression<BasicType>, right: Expression<BasicType>) => {\n    return { left, right }\n  },\n  resolver: ({ left, right }, evaluate) => {\n    return evaluate(left) < evaluate(right)\n  },\n})\n\nexport const LessThanOrEqualExpression = defineExpression({\n  expressionKey: 'Basic.LessThanOrEqual',\n  builder: (left: Expression<BasicType>, right: Expression<BasicType>) => {\n    return { left, right }\n  },\n  resolver: ({ left, right }, evaluate) => {\n    return evaluate(left) <= evaluate(right)\n  },\n})\n\nexport const GreaterThanExpression = defineExpression({\n  expressionKey: 'Basic.GreaterThan',\n  builder: (left: Expression<BasicType>, right: Expression<BasicType>) => {\n    return { left, right }\n  },\n  resolver: ({ left, right }, evaluate) => {\n    return evaluate(left) > evaluate(right)\n  },\n})\n\nexport const GreaterThanOrEqualExpression = defineExpression({\n  expressionKey: 'Basic.GreaterThanOrEqual',\n  builder: (left: Expression<BasicType>, right: Expression<BasicType>) => {\n    return { left, right }\n  },\n  resolver: ({ left, right }, evaluate) => {\n    return evaluate(left) >= evaluate(right)\n  },\n})\n"],"mappings":"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","names":[]}

package/dist/expression/expression-mapper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expression-mapper.d.ts","sourceRoot":"","sources":["../../src/expression/expression-mapper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAA;AAMnF,KAAK,kBAAkB,CAAC,cAAc,EAAE,WAAW,EAAE,WAAW,IAAI,CAClE,UAAU,EAAE,cAAc,EAC1B,GAAG,EAAE,CAAC,UAAU,EAAE,UAAU,CAAC,OAAO,CAAC,KAAK,WAAW,EACrD,OAAO,EAAE,WAAW,KACjB,WAAW,CAAA;AAEhB,qBAAa,gBAAgB,CAAC,WAAW,EAAE,WAAW;IACpD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAoE;IAEhG,GAAG,CAAC,UAAU,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,WAAW,GAAG,WAAW;IAqBvE,QAAQ,CAAC,cAAc,EACrB,UAAU,EAAE,oBAAoB,CAAC,GAAG,EAAE,GAAG,EAAE,cAAc,CAAC,EAC1D,QAAQ,EAAE,kBAAkB,CAAC,cAAc,EAAE,WAAW,EAAE,WAAW,CAAC,GACrE,IAAI;CAGR"}
+{"version":3,"file":"expression-mapper.d.ts","sourceRoot":"","sources":["../../src/expression/expression-mapper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAA;AAOnF,KAAK,kBAAkB,CAAC,cAAc,EAAE,WAAW,EAAE,WAAW,IAAI,CAClE,UAAU,EAAE,cAAc,EAC1B,GAAG,EAAE,CAAC,UAAU,EAAE,UAAU,CAAC,OAAO,CAAC,KAAK,WAAW,EACrD,OAAO,EAAE,WAAW,KACjB,WAAW,CAAA;AAEhB,qBAAa,gBAAgB,CAAC,WAAW,EAAE,WAAW;IACpD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAoE;IAEhG,GAAG,CAAC,UAAU,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,WAAW,GAAG,WAAW;IAqBvE,QAAQ,CAAC,cAAc,EACrB,UAAU,EAAE,oBAAoB,CAAC,GAAG,EAAE,GAAG,EAAE,cAAc,CAAC,EAC1D,QAAQ,EAAE,kBAAkB,CAAC,cAAc,EAAE,WAAW,EAAE,WAAW,CAAC,GACrE,IAAI;CAGR"}

package/dist/expression/expression-mapper.js

@@ -1,7 +1,8 @@
 // src/expression/expression-mapper.ts
 import { isExpression } from "@bessemer/cornerstone/expression/internal";
 import { Preconditions } from "@bessemer/cornerstone";
-import { value, ValueExpression } from "@bessemer/cornerstone/expression/expression";
+import { value } from "@bessemer/cornerstone/expression/expression";
+import { ValueExpression } from "@bessemer/cornerstone/expression/core-expression";
 var ExpressionMapper = class {
   resolverMap = {};
   map(expression, context) {

package/dist/expression/expression-mapper.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/expression/expression-mapper.ts"],"sourcesContent":["import { Expression, ExpressionDefinition } from '@bessemer/cornerstone/expression'\nimport { Dictionary } from '@bessemer/cornerstone/types'\nimport { isExpression } from '@bessemer/cornerstone/expression/internal'\nimport { Preconditions } from '@bessemer/cornerstone'\nimport { value, ValueExpression } from '@bessemer/cornerstone/expression/expression'\n\ntype ExpressionResolver<ExpressionType, MappingType, ContextType> = (\n  expression: ExpressionType,\n  map: (expression: Expression<unknown>) => MappingType,\n  context: ContextType\n) => MappingType\n\nexport class ExpressionMapper<MappingType, ContextType> {\n  private readonly resolverMap: Dictionary<ExpressionResolver<any, MappingType, ContextType>> = {}\n\n  map(expression: Expression<unknown>, context: ContextType): MappingType {\n    if (isExpression(expression)) {\n      const resolver = this.resolverMap[expression.expressionKey]\n      Preconditions.isPresent(\n        resolver,\n        `Illegal Argument - Attempted to map unknown expression: ${expression.expressionKey}. You must register(...) a handler for this expression type.`\n      )\n\n      return resolver(expression, (expression) => this.map(expression, context), context)\n    } else {\n      const resolver = this.resolverMap[ValueExpression.expressionKey]\n      Preconditions.isPresent(\n        resolver,\n        `Illegal Argument - Attempted to map unknown expression: ${ValueExpression.expressionKey}. You must register(...) a handler for this expression type.`\n      )\n\n      const valueExpression = value(expression)\n      return resolver(valueExpression, (expression) => this.map(expression, context), context)\n    }\n  }\n\n  register<ExpressionType>(\n    definition: ExpressionDefinition<any, any, ExpressionType>,\n    resolver: ExpressionResolver<ExpressionType, MappingType, ContextType>\n  ): void {\n    this.resolverMap[definition.expressionKey] = resolver\n  }\n}\n"],"mappings":";AAEA,SAAS,oBAAoB;AAC7B,SAAS,qBAAqB;AAC9B,SAAS,OAAO,uBAAuB;AAQhC,IAAM,mBAAN,MAAiD;AAAA,EACrC,cAA6E,CAAC;AAAA,EAE/F,IAAI,YAAiC,SAAmC;AACtE,QAAI,aAAa,UAAU,GAAG;AAC5B,YAAM,WAAW,KAAK,YAAY,WAAW,aAAa;AAC1D,oBAAc;AAAA,QACZ;AAAA,QACA,2DAA2D,WAAW,aAAa;AAAA,MACrF;AAEA,aAAO,SAAS,YAAY,CAACA,gBAAe,KAAK,IAAIA,aAAY,OAAO,GAAG,OAAO;AAAA,IACpF,OAAO;AACL,YAAM,WAAW,KAAK,YAAY,gBAAgB,aAAa;AAC/D,oBAAc;AAAA,QACZ;AAAA,QACA,2DAA2D,gBAAgB,aAAa;AAAA,MAC1F;AAEA,YAAM,kBAAkB,MAAM,UAAU;AACxC,aAAO,SAAS,iBAAiB,CAACA,gBAAe,KAAK,IAAIA,aAAY,OAAO,GAAG,OAAO;AAAA,IACzF;AAAA,EACF;AAAA,EAEA,SACE,YACA,UACM;AACN,SAAK,YAAY,WAAW,aAAa,IAAI;AAAA,EAC/C;AACF;","names":["expression"]}
+{"version":3,"sources":["../../src/expression/expression-mapper.ts"],"sourcesContent":["import { Expression, ExpressionDefinition } from '@bessemer/cornerstone/expression'\nimport { Dictionary } from '@bessemer/cornerstone/types'\nimport { isExpression } from '@bessemer/cornerstone/expression/internal'\nimport { Preconditions } from '@bessemer/cornerstone'\nimport { value } from '@bessemer/cornerstone/expression/expression'\nimport { ValueExpression } from '@bessemer/cornerstone/expression/core-expression'\n\ntype ExpressionResolver<ExpressionType, MappingType, ContextType> = (\n  expression: ExpressionType,\n  map: (expression: Expression<unknown>) => MappingType,\n  context: ContextType\n) => MappingType\n\nexport class ExpressionMapper<MappingType, ContextType> {\n  private readonly resolverMap: Dictionary<ExpressionResolver<any, MappingType, ContextType>> = {}\n\n  map(expression: Expression<unknown>, context: ContextType): MappingType {\n    if (isExpression(expression)) {\n      const resolver = this.resolverMap[expression.expressionKey]\n      Preconditions.isPresent(\n        resolver,\n        `Illegal Argument - Attempted to map unknown expression: ${expression.expressionKey}. You must register(...) a handler for this expression type.`\n      )\n\n      return resolver(expression, (expression) => this.map(expression, context), context)\n    } else {\n      const resolver = this.resolverMap[ValueExpression.expressionKey]\n      Preconditions.isPresent(\n        resolver,\n        `Illegal Argument - Attempted to map unknown expression: ${ValueExpression.expressionKey}. You must register(...) a handler for this expression type.`\n      )\n\n      const valueExpression = value(expression)\n      return resolver(valueExpression, (expression) => this.map(expression, context), context)\n    }\n  }\n\n  register<ExpressionType>(\n    definition: ExpressionDefinition<any, any, ExpressionType>,\n    resolver: ExpressionResolver<ExpressionType, MappingType, ContextType>\n  ): void {\n    this.resolverMap[definition.expressionKey] = resolver\n  }\n}\n"],"mappings":";AAEA,SAAS,oBAAoB;AAC7B,SAAS,qBAAqB;AAC9B,SAAS,aAAa;AACtB,SAAS,uBAAuB;AAQzB,IAAM,mBAAN,MAAiD;AAAA,EACrC,cAA6E,CAAC;AAAA,EAE/F,IAAI,YAAiC,SAAmC;AACtE,QAAI,aAAa,UAAU,GAAG;AAC5B,YAAM,WAAW,KAAK,YAAY,WAAW,aAAa;AAC1D,oBAAc;AAAA,QACZ;AAAA,QACA,2DAA2D,WAAW,aAAa;AAAA,MACrF;AAEA,aAAO,SAAS,YAAY,CAACA,gBAAe,KAAK,IAAIA,aAAY,OAAO,GAAG,OAAO;AAAA,IACpF,OAAO;AACL,YAAM,WAAW,KAAK,YAAY,gBAAgB,aAAa;AAC/D,oBAAc;AAAA,QACZ;AAAA,QACA,2DAA2D,gBAAgB,aAAa;AAAA,MAC1F;AAEA,YAAM,kBAAkB,MAAM,UAAU;AACxC,aAAO,SAAS,iBAAiB,CAACA,gBAAe,KAAK,IAAIA,aAAY,OAAO,GAAG,OAAO;AAAA,IACzF;AAAA,EACF;AAAA,EAEA,SACE,YACA,UACM;AACN,SAAK,YAAY,WAAW,aAAa,IAAI;AAAA,EAC/C;AACF;","names":["expression"]}

package/dist/expression/expression.d.ts

@@ -2,8 +2,10 @@ import { EvaluateExpression, Expression, ExpressionContext, ExpressionDefinition
 import { Signatures } from '@bessemer/cornerstone';
 import { Signable } from '@bessemer/cornerstone/signature';
 import { UnknownRecord } from 'type-fest';
+import { ExpressionMapper } from '@bessemer/cornerstone/expression/expression-mapper';
 export declare const evaluate: <T>(expression: Expression<T>, context: ExpressionContext) => T;
 export declare const evaluateDefault: <T>(expression: Expression<T>) => T;
+export declare const map: <MappingType, ContextType>(expression: Expression<unknown>, mapper: ExpressionMapper<MappingType, ContextType>, context: ContextType) => MappingType;
 export declare const evaluator: (context: ExpressionContext) => EvaluateExpression;
 export declare const defaultEvaluator: () => EvaluateExpression;
 export declare const defaultContext: () => ExpressionContext;
@@ -11,44 +13,38 @@ export declare const dereference: <ReturnType, ArgumentType extends Array<unknow
 export declare const parameterizedVariable: <ValueType, ParameterType extends Array<Signable>>(name: string) => ParameterizedVariable<ValueType, ParameterType>;
 export declare const buildVariable: <T>(variable: ExpressionVariable<T>, value: T) => UnknownRecord;
 export declare const reference: <ReturnType, ArgumentType extends Array<unknown>, ExpressionType extends Expression<ReturnType>>(expressionDefinition: ExpressionDefinition<ReturnType, ArgumentType, ExpressionType>) => ExpressionReference<ReturnType, ArgumentType>;
-export declare const ValueExpression: ExpressionDefinition<unknown, [value: unknown], {
-    value: unknown;
-}>;
 export declare const value: <T>(value: T) => Expression<T>;
-export declare const VariableExpression: ExpressionDefinition<{}, [name: string], Expression<{}> & {
-    name: string;
-}>;
 export declare const variable: <T>(name: string) => ExpressionVariable<T>;
-export declare const NotExpression: ExpressionDefinition<boolean, [value: Expression<boolean>], Expression<boolean> & {
-    value: Expression<boolean>;
-}>;
 export declare const not: (value: Expression<boolean>) => Expression<boolean> & {
     value: Expression<boolean>;
 };
-export declare const AndExpression: ExpressionDefinition<boolean, [operands: Expression<boolean>[]], Expression<boolean> & {
-    operands: Expression<boolean>[];
-}>;
 export declare const and: (operands: Expression<boolean>[]) => Expression<boolean> & {
     operands: Expression<boolean>[];
 };
-export declare const OrExpression: ExpressionDefinition<boolean, [operands: Expression<boolean>[]], Expression<boolean> & {
-    operands: Expression<boolean>[];
-}>;
 export declare const or: (operands: Expression<boolean>[]) => Expression<boolean> & {
     operands: Expression<boolean>[];
 };
-export declare const EqualsExpression: ExpressionDefinition<boolean, [operands: Expression<Signatures.Signable>[]], Expression<boolean> & {
-    operands: Expression<Signatures.Signable>[];
-}>;
 export declare const equals: (operands: Expression<Signatures.Signable>[]) => Expression<boolean> & {
     operands: Expression<Signatures.Signable>[];
 };
-export declare const ContainsExpression: ExpressionDefinition<boolean, [collection: Expression<Signatures.Signable[]>, operands: Expression<Signatures.Signable>[]], Expression<boolean> & {
-    collection: Expression<Signatures.Signable[]>;
-    operands: Expression<Signatures.Signable>[];
-}>;
 export declare const contains: (collection: Expression<Signatures.Signable[]>, operands: Expression<Signatures.Signable>[]) => Expression<boolean> & {
     collection: Expression<Signatures.Signable[]>;
     operands: Expression<Signatures.Signable>[];
 };
+export declare const lessThan: (left: Expression<import("../types").BasicType>, right: Expression<import("../types").BasicType>) => Expression<boolean> & {
+    left: Expression<import("../types").BasicType>;
+    right: Expression<import("../types").BasicType>;
+};
+export declare const lessThanOrEqual: (left: Expression<import("../types").BasicType>, right: Expression<import("../types").BasicType>) => Expression<boolean> & {
+    left: Expression<import("../types").BasicType>;
+    right: Expression<import("../types").BasicType>;
+};
+export declare const greaterThan: (left: Expression<import("../types").BasicType>, right: Expression<import("../types").BasicType>) => Expression<boolean> & {
+    left: Expression<import("../types").BasicType>;
+    right: Expression<import("../types").BasicType>;
+};
+export declare const greaterThanOrEqual: (left: Expression<import("../types").BasicType>, right: Expression<import("../types").BasicType>) => Expression<boolean> & {
+    left: Expression<import("../types").BasicType>;
+    right: Expression<import("../types").BasicType>;
+};
 //# sourceMappingURL=expression.d.ts.map

package/dist/expression/expression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expression.d.ts","sourceRoot":"","sources":["../../src/expression/expression.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,kBAAkB,EAClB,UAAU,EACV,iBAAiB,EACjB,oBAAoB,EACpB,mBAAmB,EACnB,kBAAkB,EAElB,qBAAqB,EAEtB,MAAM,kCAAkC,CAAA;AACzC,OAAO,EAAkC,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAClF,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAA;AAE1D,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAEzC,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,YAAY,UAAU,CAAC,CAAC,CAAC,EAAE,SAAS,iBAAiB,KAAG,CAEnF,CAAA;AAED,eAAO,MAAM,eAAe,GAAI,CAAC,EAAE,YAAY,UAAU,CAAC,CAAC,CAAC,KAAG,CAE9D,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,SAAS,iBAAiB,KAAG,kBAEtD,CAAA;AAED,eAAO,MAAM,gBAAgB,QAAO,kBAEnC,CAAA;AAED,eAAO,MAAM,cAAc,QAAO,iBAEjC,CAAA;AAED,eAAO,MAAM,WAAW,GAAI,UAAU,EAAE,YAAY,SAAS,KAAK,CAAC,OAAO,CAAC,EACzE,WAAW,mBAAmB,CAAC,UAAU,EAAE,YAAY,CAAC,EACxD,GAAG,MAAM,YAAY,KACpB,UAAU,CAAC,UAAU,CAEvB,CAAA;AAED,eAAO,MAAM,qBAAqB,GAAI,SAAS,EAAE,aAAa,SAAS,KAAK,CAAC,QAAQ,CAAC,EACpF,MAAM,MAAM,KACX,qBAAqB,CAAC,SAAS,EAAE,aAAa,CAOhD,CAAA;AAED,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,UAAU,kBAAkB,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,KAAG,aAE5E,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,UAAU,EAAE,YAAY,SAAS,KAAK,CAAC,OAAO,CAAC,EAAE,cAAc,SAAS,UAAU,CAAC,UAAU,CAAC,EACtH,sBAAsB,oBAAoB,CAAC,UAAU,EAAE,YAAY,EAAE,cAAc,CAAC,KACnF,mBAAmB,CAAC,UAAU,EAAE,YAAY,CAE9C,CAAA;AAED,eAAO,MAAM,eAAe;;EAQ1B,CAAA;AAEF,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,UAAU,CAAC,CAAC,CAE/C,CAAA;AAED,eAAO,MAAM,kBAAkB;;EAU7B,CAAA;AAEF,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,MAAM,MAAM,KAAG,kBAAkB,CAAC,CAAC,CAA8D,CAAA;AAE7H,eAAO,MAAM,aAAa;;EAQxB,CAAA;AAEF,eAAO,MAAM,GAAG;;CAAwB,CAAA;AAExC,eAAO,MAAM,aAAa;;EAUxB,CAAA;AAEF,eAAO,MAAM,GAAG;;CAAwB,CAAA;AAExC,eAAO,MAAM,YAAY;;EAUvB,CAAA;AAEF,eAAO,MAAM,EAAE;;CAAuB,CAAA;AAEtC,eAAO,MAAM,gBAAgB;;EAe3B,CAAA;AAEF,eAAO,MAAM,MAAM;;CAA2B,CAAA;AAE9C,eAAO,MAAM,kBAAkB;;;EAU7B,CAAA;AAEF,eAAO,MAAM,QAAQ;;;CAA6B,CAAA"}
+{"version":3,"file":"expression.d.ts","sourceRoot":"","sources":["../../src/expression/expression.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,kBAAkB,EAClB,UAAU,EACV,iBAAiB,EACjB,oBAAoB,EACpB,mBAAmB,EACnB,kBAAkB,EAElB,qBAAqB,EAEtB,MAAM,kCAAkC,CAAA;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAA;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAczC,OAAO,EAAE,gBAAgB,EAAE,MAAM,oDAAoD,CAAA;AAErF,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,YAAY,UAAU,CAAC,CAAC,CAAC,EAAE,SAAS,iBAAiB,KAAG,CAEnF,CAAA;AAED,eAAO,MAAM,eAAe,GAAI,CAAC,EAAE,YAAY,UAAU,CAAC,CAAC,CAAC,KAAG,CAE9D,CAAA;AAED,eAAO,MAAM,GAAG,GAAI,WAAW,EAAE,WAAW,EAC1C,YAAY,UAAU,CAAC,OAAO,CAAC,EAC/B,QAAQ,gBAAgB,CAAC,WAAW,EAAE,WAAW,CAAC,EAClD,SAAS,WAAW,KACnB,WAEF,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,SAAS,iBAAiB,KAAG,kBAEtD,CAAA;AAED,eAAO,MAAM,gBAAgB,QAAO,kBAEnC,CAAA;AAED,eAAO,MAAM,cAAc,QAAO,iBAEjC,CAAA;AAED,eAAO,MAAM,WAAW,GAAI,UAAU,EAAE,YAAY,SAAS,KAAK,CAAC,OAAO,CAAC,EACzE,WAAW,mBAAmB,CAAC,UAAU,EAAE,YAAY,CAAC,EACxD,GAAG,MAAM,YAAY,KACpB,UAAU,CAAC,UAAU,CAEvB,CAAA;AAED,eAAO,MAAM,qBAAqB,GAAI,SAAS,EAAE,aAAa,SAAS,KAAK,CAAC,QAAQ,CAAC,EACpF,MAAM,MAAM,KACX,qBAAqB,CAAC,SAAS,EAAE,aAAa,CAOhD,CAAA;AAED,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,UAAU,kBAAkB,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,KAAG,aAE5E,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,UAAU,EAAE,YAAY,SAAS,KAAK,CAAC,OAAO,CAAC,EAAE,cAAc,SAAS,UAAU,CAAC,UAAU,CAAC,EACtH,sBAAsB,oBAAoB,CAAC,UAAU,EAAE,YAAY,EAAE,cAAc,CAAC,KACnF,mBAAmB,CAAC,UAAU,EAAE,YAAY,CAE9C,CAAA;AAED,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,UAAU,CAAC,CAAC,CAE/C,CAAA;AAED,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,MAAM,MAAM,KAAG,kBAAkB,CAAC,CAAC,CAE9D,CAAA;AAED,eAAO,MAAM,GAAG;;CAAwB,CAAA;AAExC,eAAO,MAAM,GAAG;;CAAwB,CAAA;AAExC,eAAO,MAAM,EAAE;;CAAuB,CAAA;AAEtC,eAAO,MAAM,MAAM;;CAA2B,CAAA;AAE9C,eAAO,MAAM,QAAQ;;;CAA6B,CAAA;AAElD,eAAO,MAAM,QAAQ;;;CAA6B,CAAA;AAElD,eAAO,MAAM,eAAe;;;CAAoC,CAAA;AAEhE,eAAO,MAAM,WAAW;;;CAAgC,CAAA;AAExD,eAAO,MAAM,kBAAkB;;;CAAuC,CAAA"}

package/dist/expression/expression.js

@@ -2,18 +2,32 @@
 import { ExpressionEvaluator } from "@bessemer/cornerstone/expression/expression-evaluator";
 import {
   ArrayExpressions,
-  BasicExpressions,
   NumericExpressions,
   StringExpressions
 } from "@bessemer/cornerstone/expression";
-import { Arrays, Objects, Preconditions, Signatures } from "@bessemer/cornerstone";
-import { defineExpression } from "@bessemer/cornerstone/expression/internal";
+import { Signatures } from "@bessemer/cornerstone";
+import {
+  AndExpression,
+  ContainsExpression,
+  EqualsExpression,
+  GreaterThanExpression,
+  GreaterThanOrEqualExpression,
+  LessThanExpression,
+  LessThanOrEqualExpression,
+  NotExpression,
+  OrExpression,
+  ValueExpression,
+  VariableExpression
+} from "@bessemer/cornerstone/expression/core-expression";
 var evaluate = (expression, context) => {
   return new ExpressionEvaluator(DEFAULT_EXPRESSION_DEFINITIONS).evaluate(expression, context);
 };
 var evaluateDefault = (expression) => {
   return evaluate(expression, defaultContext());
 };
+var map = (expression, mapper, context) => {
+  return mapper.map(expression, context);
+};
 var evaluator = (context) => {
   return (it) => evaluate(it, context);
 };
@@ -40,91 +54,21 @@ var buildVariable = (variable2, value2) => {
 var reference = (expressionDefinition) => {
   return { expressionKey: expressionDefinition.expressionKey };
 };
-var ValueExpression = defineExpression({
-  expressionKey: "Value",
-  builder: (value2) => {
-    return { value: value2 };
-  },
-  resolver: ({ value: value2 }, evaluate2, context) => {
-    return value2;
-  }
-});
 var value = (value2) => {
   return ValueExpression.builder(value2);
 };
-var VariableExpression = defineExpression({
-  expressionKey: "Variable",
-  builder: (name) => {
-    return { name };
-  },
-  resolver: ({ name }, evaluate2, context) => {
-    const value2 = context.variables[name];
-    Preconditions.isPresent(value2);
-    return value2;
-  }
-});
-var variable = (name) => VariableExpression.builder(name);
-var NotExpression = defineExpression({
-  expressionKey: "Not",
-  builder: (value2) => {
-    return { value: value2 };
-  },
-  resolver: (expression, evaluate2) => {
-    return !evaluate2(expression.value);
-  }
-});
+var variable = (name) => {
+  return VariableExpression.builder(name);
+};
 var not = NotExpression.builder;
-var AndExpression = defineExpression({
-  expressionKey: "And",
-  builder: (operands) => {
-    return { operands };
-  },
-  resolver: (expression, evaluate2) => {
-    const values = expression.operands.map((it) => evaluate2(it));
-    const falseValue = values.find((it) => !it);
-    return Objects.isNil(falseValue);
-  }
-});
 var and = AndExpression.builder;
-var OrExpression = defineExpression({
-  expressionKey: "Or",
-  builder: (operands) => {
-    return { operands };
-  },
-  resolver: (expression, evaluate2) => {
-    const values = expression.operands.map((it) => evaluate2(it));
-    const trueValue = values.find((it) => it);
-    return Objects.isPresent(trueValue);
-  }
-});
 var or = OrExpression.builder;
-var EqualsExpression = defineExpression({
-  expressionKey: "Equals",
-  builder: (operands) => {
-    return { operands };
-  },
-  resolver: (expression, evaluate2) => {
-    const values = expression.operands.map((it) => evaluate2(it)).map(Signatures.sign);
-    if (values.length === 0) {
-      return true;
-    }
-    const first = values[0];
-    return values.every((val) => val === first);
-  }
-});
 var equals = EqualsExpression.builder;
-var ContainsExpression = defineExpression({
-  expressionKey: "Contains",
-  builder: (collection, operands) => {
-    return { collection, operands };
-  },
-  resolver: (expression, evaluate2) => {
-    const collection = evaluate2(expression.collection);
-    const values = expression.operands.map((it) => evaluate2(it));
-    return Arrays.containsAll(collection, values);
-  }
-});
 var contains = ContainsExpression.builder;
+var lessThan = LessThanExpression.builder;
+var lessThanOrEqual = LessThanOrEqualExpression.builder;
+var greaterThan = GreaterThanExpression.builder;
+var greaterThanOrEqual = GreaterThanOrEqualExpression.builder;
 var DEFAULT_EXPRESSION_DEFINITIONS = [
   ValueExpression,
   VariableExpression,
@@ -132,15 +76,15 @@ var DEFAULT_EXPRESSION_DEFINITIONS = [
   OrExpression,
   ContainsExpression,
   EqualsExpression,
-  BasicExpressions.LessThanExpression,
-  BasicExpressions.LessThanOrEqualExpression,
-  BasicExpressions.GreaterThanExpression,
-  BasicExpressions.GreaterThanOrEqualExpression,
+  LessThanExpression,
+  LessThanOrEqualExpression,
+  GreaterThanExpression,
+  GreaterThanOrEqualExpression,
   NumericExpressions.SumExpression,
   NumericExpressions.MultiplyExpression,
   NumericExpressions.FloorExpression,
   NumericExpressions.CeilingExpression,
-  NumericExpressions.BoundsExpression,
+  NumericExpressions.BoundExpression,
   NumericExpressions.RoundExpression,
   NumericExpressions.MaxExpression,
   NumericExpressions.MinExpression,
@@ -151,13 +95,6 @@ var DEFAULT_EXPRESSION_DEFINITIONS = [
   ArrayExpressions.FirstExpression
 ];
 export {
-  AndExpression,
-  ContainsExpression,
-  EqualsExpression,
-  NotExpression,
-  OrExpression,
-  ValueExpression,
-  VariableExpression,
   and,
   buildVariable,
   contains,
@@ -168,6 +105,11 @@ export {
   evaluate,
   evaluateDefault,
   evaluator,
+  greaterThan,
+  greaterThanOrEqual,
+  lessThan,
+  lessThanOrEqual,
+  map,
   not,
   or,
   parameterizedVariable,

package/dist/expression/expression.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/expression/expression.ts"],"sourcesContent":["import { ExpressionEvaluator } from '@bessemer/cornerstone/expression/expression-evaluator'\nimport {\n  ArrayExpressions,\n  BasicExpressions,\n  EvaluateExpression,\n  Expression,\n  ExpressionContext,\n  ExpressionDefinition,\n  ExpressionReference,\n  ExpressionVariable,\n  NumericExpressions,\n  ParameterizedVariable,\n  StringExpressions,\n} from '@bessemer/cornerstone/expression'\nimport { Arrays, Objects, Preconditions, Signatures } from '@bessemer/cornerstone'\nimport { Signable } from '@bessemer/cornerstone/signature'\nimport { defineExpression } from '@bessemer/cornerstone/expression/internal'\nimport { UnknownRecord } from 'type-fest'\n\nexport const evaluate = <T>(expression: Expression<T>, context: ExpressionContext): T => {\n  return new ExpressionEvaluator(DEFAULT_EXPRESSION_DEFINITIONS).evaluate(expression, context)\n}\n\nexport const evaluateDefault = <T>(expression: Expression<T>): T => {\n  return evaluate(expression, defaultContext())\n}\n\nexport const evaluator = (context: ExpressionContext): EvaluateExpression => {\n  return (it) => evaluate(it, context)\n}\n\nexport const defaultEvaluator = (): EvaluateExpression => {\n  return evaluator(defaultContext())\n}\n\nexport const defaultContext = (): ExpressionContext => {\n  return { variables: {} }\n}\n\nexport const dereference = <ReturnType, ArgumentType extends Array<unknown>>(\n  reference: ExpressionReference<ReturnType, ArgumentType>,\n  ...args: ArgumentType\n): Expression<ReturnType> => {\n  return new ExpressionEvaluator(DEFAULT_EXPRESSION_DEFINITIONS).dereference(reference, ...args)\n}\n\nexport const parameterizedVariable = <ValueType, ParameterType extends Array<Signable>>(\n  name: string\n): ParameterizedVariable<ValueType, ParameterType> => {\n  return {\n    apply(...parameters: ParameterType): ExpressionVariable<ValueType> {\n      const parameterString = parameters.map(Signatures.sign).join('.')\n      return variable(`${name}.${parameterString}`)\n    },\n  }\n}\n\nexport const buildVariable = <T>(variable: ExpressionVariable<T>, value: T): UnknownRecord => {\n  return { [variable.name]: value }\n}\n\nexport const reference = <ReturnType, ArgumentType extends Array<unknown>, ExpressionType extends Expression<ReturnType>>(\n  expressionDefinition: ExpressionDefinition<ReturnType, ArgumentType, ExpressionType>\n): ExpressionReference<ReturnType, ArgumentType> => {\n  return { expressionKey: expressionDefinition.expressionKey }\n}\n\nexport const ValueExpression = defineExpression({\n  expressionKey: 'Value',\n  builder: (value: unknown) => {\n    return { value }\n  },\n  resolver: ({ value }, evaluate, context) => {\n    return value\n  },\n})\n\nexport const value = <T>(value: T): Expression<T> => {\n  return ValueExpression.builder(value) as Expression<T>\n}\n\nexport const VariableExpression = defineExpression({\n  expressionKey: 'Variable',\n  builder: (name: string) => {\n    return { name }\n  },\n  resolver: ({ name }, evaluate, context) => {\n    const value = context.variables[name]\n    Preconditions.isPresent(value)\n    return value\n  },\n})\n\nexport const variable = <T>(name: string): ExpressionVariable<T> => VariableExpression.builder(name) as ExpressionVariable<T>\n\nexport const NotExpression = defineExpression({\n  expressionKey: 'Not',\n  builder: (value: Expression<boolean>) => {\n    return { value }\n  },\n  resolver: (expression, evaluate) => {\n    return !evaluate(expression.value)\n  },\n})\n\nexport const not = NotExpression.builder\n\nexport const AndExpression = defineExpression({\n  expressionKey: 'And',\n  builder: (operands: Array<Expression<boolean>>) => {\n    return { operands }\n  },\n  resolver: (expression, evaluate) => {\n    const values = expression.operands.map((it) => evaluate(it))\n    const falseValue = values.find((it) => !it)\n    return Objects.isNil(falseValue)\n  },\n})\n\nexport const and = AndExpression.builder\n\nexport const OrExpression = defineExpression({\n  expressionKey: 'Or',\n  builder: (operands: Array<Expression<boolean>>) => {\n    return { operands }\n  },\n  resolver: (expression, evaluate) => {\n    const values = expression.operands.map((it) => evaluate(it))\n    const trueValue = values.find((it) => it)\n    return Objects.isPresent(trueValue)\n  },\n})\n\nexport const or = OrExpression.builder\n\nexport const EqualsExpression = defineExpression({\n  expressionKey: 'Equals',\n  builder: (operands: Array<Expression<Signable>>) => {\n    return { operands }\n  },\n  resolver: (expression, evaluate) => {\n    const values = expression.operands.map((it) => evaluate(it)).map(Signatures.sign)\n\n    if (values.length === 0) {\n      return true\n    }\n\n    const first = values[0]\n    return values.every((val) => val === first)\n  },\n})\n\nexport const equals = EqualsExpression.builder\n\nexport const ContainsExpression = defineExpression({\n  expressionKey: 'Contains',\n  builder: (collection: Expression<Array<Signable>>, operands: Array<Expression<Signable>>) => {\n    return { collection, operands }\n  },\n  resolver: (expression, evaluate) => {\n    const collection = evaluate(expression.collection)\n    const values = expression.operands.map((it) => evaluate(it))\n    return Arrays.containsAll(collection, values)\n  },\n})\n\nexport const contains = ContainsExpression.builder\n\nconst DEFAULT_EXPRESSION_DEFINITIONS: Array<ExpressionDefinition<unknown, Array<any>, Expression<any>>> = [\n  ValueExpression,\n  VariableExpression,\n  AndExpression,\n  OrExpression,\n  ContainsExpression,\n  EqualsExpression,\n  BasicExpressions.LessThanExpression,\n  BasicExpressions.LessThanOrEqualExpression,\n  BasicExpressions.GreaterThanExpression,\n  BasicExpressions.GreaterThanOrEqualExpression,\n  NumericExpressions.SumExpression,\n  NumericExpressions.MultiplyExpression,\n  NumericExpressions.FloorExpression,\n  NumericExpressions.CeilingExpression,\n  NumericExpressions.BoundsExpression,\n  NumericExpressions.RoundExpression,\n  NumericExpressions.MaxExpression,\n  NumericExpressions.MinExpression,\n  StringExpressions.ConcatenateExpression,\n  StringExpressions.SubstringExpression,\n  StringExpressions.UppercaseExpression,\n  ArrayExpressions.ConcatenateExpression,\n  ArrayExpressions.FirstExpression,\n]\n"],"mappings":"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","names":["reference","variable","value","evaluate"]}
+{"version":3,"sources":["../../src/expression/expression.ts"],"sourcesContent":["import { ExpressionEvaluator } from '@bessemer/cornerstone/expression/expression-evaluator'\nimport {\n  ArrayExpressions,\n  EvaluateExpression,\n  Expression,\n  ExpressionContext,\n  ExpressionDefinition,\n  ExpressionReference,\n  ExpressionVariable,\n  NumericExpressions,\n  ParameterizedVariable,\n  StringExpressions,\n} from '@bessemer/cornerstone/expression'\nimport { Signatures } from '@bessemer/cornerstone'\nimport { Signable } from '@bessemer/cornerstone/signature'\nimport { UnknownRecord } from 'type-fest'\nimport {\n  AndExpression,\n  ContainsExpression,\n  EqualsExpression,\n  GreaterThanExpression,\n  GreaterThanOrEqualExpression,\n  LessThanExpression,\n  LessThanOrEqualExpression,\n  NotExpression,\n  OrExpression,\n  ValueExpression,\n  VariableExpression,\n} from '@bessemer/cornerstone/expression/core-expression'\nimport { ExpressionMapper } from '@bessemer/cornerstone/expression/expression-mapper'\n\nexport const evaluate = <T>(expression: Expression<T>, context: ExpressionContext): T => {\n  return new ExpressionEvaluator(DEFAULT_EXPRESSION_DEFINITIONS).evaluate(expression, context)\n}\n\nexport const evaluateDefault = <T>(expression: Expression<T>): T => {\n  return evaluate(expression, defaultContext())\n}\n\nexport const map = <MappingType, ContextType>(\n  expression: Expression<unknown>,\n  mapper: ExpressionMapper<MappingType, ContextType>,\n  context: ContextType\n): MappingType => {\n  return mapper.map(expression, context)\n}\n\nexport const evaluator = (context: ExpressionContext): EvaluateExpression => {\n  return (it) => evaluate(it, context)\n}\n\nexport const defaultEvaluator = (): EvaluateExpression => {\n  return evaluator(defaultContext())\n}\n\nexport const defaultContext = (): ExpressionContext => {\n  return { variables: {} }\n}\n\nexport const dereference = <ReturnType, ArgumentType extends Array<unknown>>(\n  reference: ExpressionReference<ReturnType, ArgumentType>,\n  ...args: ArgumentType\n): Expression<ReturnType> => {\n  return new ExpressionEvaluator(DEFAULT_EXPRESSION_DEFINITIONS).dereference(reference, ...args)\n}\n\nexport const parameterizedVariable = <ValueType, ParameterType extends Array<Signable>>(\n  name: string\n): ParameterizedVariable<ValueType, ParameterType> => {\n  return {\n    apply(...parameters: ParameterType): ExpressionVariable<ValueType> {\n      const parameterString = parameters.map(Signatures.sign).join('.')\n      return variable(`${name}.${parameterString}`)\n    },\n  }\n}\n\nexport const buildVariable = <T>(variable: ExpressionVariable<T>, value: T): UnknownRecord => {\n  return { [variable.name]: value }\n}\n\nexport const reference = <ReturnType, ArgumentType extends Array<unknown>, ExpressionType extends Expression<ReturnType>>(\n  expressionDefinition: ExpressionDefinition<ReturnType, ArgumentType, ExpressionType>\n): ExpressionReference<ReturnType, ArgumentType> => {\n  return { expressionKey: expressionDefinition.expressionKey }\n}\n\nexport const value = <T>(value: T): Expression<T> => {\n  return ValueExpression.builder(value) as Expression<T>\n}\n\nexport const variable = <T>(name: string): ExpressionVariable<T> => {\n  return VariableExpression.builder(name) as ExpressionVariable<T>\n}\n\nexport const not = NotExpression.builder\n\nexport const and = AndExpression.builder\n\nexport const or = OrExpression.builder\n\nexport const equals = EqualsExpression.builder\n\nexport const contains = ContainsExpression.builder\n\nexport const lessThan = LessThanExpression.builder\n\nexport const lessThanOrEqual = LessThanOrEqualExpression.builder\n\nexport const greaterThan = GreaterThanExpression.builder\n\nexport const greaterThanOrEqual = GreaterThanOrEqualExpression.builder\n\nconst DEFAULT_EXPRESSION_DEFINITIONS: Array<ExpressionDefinition<unknown, Array<any>, Expression<any>>> = [\n  ValueExpression,\n  VariableExpression,\n  AndExpression,\n  OrExpression,\n  ContainsExpression,\n  EqualsExpression,\n  LessThanExpression,\n  LessThanOrEqualExpression,\n  GreaterThanExpression,\n  GreaterThanOrEqualExpression,\n  NumericExpressions.SumExpression,\n  NumericExpressions.MultiplyExpression,\n  NumericExpressions.FloorExpression,\n  NumericExpressions.CeilingExpression,\n  NumericExpressions.BoundExpression,\n  NumericExpressions.RoundExpression,\n  NumericExpressions.MaxExpression,\n  NumericExpressions.MinExpression,\n  StringExpressions.ConcatenateExpression,\n  StringExpressions.SubstringExpression,\n  StringExpressions.UppercaseExpression,\n  ArrayExpressions.ConcatenateExpression,\n  ArrayExpressions.FirstExpression,\n]\n"],"mappings":";AAAA,SAAS,2BAA2B;AACpC;AAAA,EACE;AAAA,EAOA;AAAA,EAEA;AAAA,OACK;AACP,SAAS,kBAAkB;AAG3B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAGA,IAAM,WAAW,CAAI,YAA2B,YAAkC;AACvF,SAAO,IAAI,oBAAoB,8BAA8B,EAAE,SAAS,YAAY,OAAO;AAC7F;AAEO,IAAM,kBAAkB,CAAI,eAAiC;AAClE,SAAO,SAAS,YAAY,eAAe,CAAC;AAC9C;AAEO,IAAM,MAAM,CACjB,YACA,QACA,YACgB;AAChB,SAAO,OAAO,IAAI,YAAY,OAAO;AACvC;AAEO,IAAM,YAAY,CAAC,YAAmD;AAC3E,SAAO,CAAC,OAAO,SAAS,IAAI,OAAO;AACrC;AAEO,IAAM,mBAAmB,MAA0B;AACxD,SAAO,UAAU,eAAe,CAAC;AACnC;AAEO,IAAM,iBAAiB,MAAyB;AACrD,SAAO,EAAE,WAAW,CAAC,EAAE;AACzB;AAEO,IAAM,cAAc,CACzBA,eACG,SACwB;AAC3B,SAAO,IAAI,oBAAoB,8BAA8B,EAAE,YAAYA,YAAW,GAAG,IAAI;AAC/F;AAEO,IAAM,wBAAwB,CACnC,SACoD;AACpD,SAAO;AAAA,IACL,SAAS,YAA0D;AACjE,YAAM,kBAAkB,WAAW,IAAI,WAAW,IAAI,EAAE,KAAK,GAAG;AAChE,aAAO,SAAS,GAAG,IAAI,IAAI,eAAe,EAAE;AAAA,IAC9C;AAAA,EACF;AACF;AAEO,IAAM,gBAAgB,CAAIC,WAAiCC,WAA4B;AAC5F,SAAO,EAAE,CAACD,UAAS,IAAI,GAAGC,OAAM;AAClC;AAEO,IAAM,YAAY,CACvB,yBACkD;AAClD,SAAO,EAAE,eAAe,qBAAqB,cAAc;AAC7D;AAEO,IAAM,QAAQ,CAAIA,WAA4B;AACnD,SAAO,gBAAgB,QAAQA,MAAK;AACtC;AAEO,IAAM,WAAW,CAAI,SAAwC;AAClE,SAAO,mBAAmB,QAAQ,IAAI;AACxC;AAEO,IAAM,MAAM,cAAc;AAE1B,IAAM,MAAM,cAAc;AAE1B,IAAM,KAAK,aAAa;AAExB,IAAM,SAAS,iBAAiB;AAEhC,IAAM,WAAW,mBAAmB;AAEpC,IAAM,WAAW,mBAAmB;AAEpC,IAAM,kBAAkB,0BAA0B;AAElD,IAAM,cAAc,sBAAsB;AAE1C,IAAM,qBAAqB,6BAA6B;AAE/D,IAAM,iCAAoG;AAAA,EACxG;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,mBAAmB;AAAA,EACnB,mBAAmB;AAAA,EACnB,mBAAmB;AAAA,EACnB,mBAAmB;AAAA,EACnB,mBAAmB;AAAA,EACnB,mBAAmB;AAAA,EACnB,mBAAmB;AAAA,EACnB,mBAAmB;AAAA,EACnB,kBAAkB;AAAA,EAClB,kBAAkB;AAAA,EAClB,kBAAkB;AAAA,EAClB,iBAAiB;AAAA,EACjB,iBAAiB;AACnB;","names":["reference","variable","value"]}

package/dist/expression/numeric-expression.d.ts

@@ -1,5 +1,6 @@
 import { Expression } from '@bessemer/cornerstone/expression';
 import { Maths } from '@bessemer/cornerstone';
+import { Bounds } from '@bessemer/cornerstone/range';
 export declare const SumExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<number, [initialOperands: Expression<number>[]], Expression<number> & {
     operands: Expression<number>[];
 }>;
@@ -12,15 +13,13 @@ export declare const MultiplyExpression: import("@bessemer/cornerstone/expressio
 export declare const multiply: (initialOperands: Expression<number>[]) => Expression<number> & {
     operands: Expression<number>[];
 };
-export declare const BoundsExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<number, [value: Expression<number>, minimumThreshold: Expression<number> | null, maximumThreshold: Expression<number> | null], Expression<number> & {
+export declare const BoundExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<number, [value: Expression<number>, bounds: Bounds<Expression<number>>], Expression<number> & {
     value: Expression<number>;
-    minimumThreshold: Expression<number> | null;
-    maximumThreshold: Expression<number> | null;
+    bounds: Bounds<Expression<number>>;
 }>;
-export declare const bounds: (value: Expression<number>, minimumThreshold: Expression<number> | null, maximumThreshold: Expression<number> | null) => Expression<number> & {
+export declare const bound: (value: Expression<number>, bounds: Bounds<Expression<number>>) => Expression<number> & {
     value: Expression<number>;
-    minimumThreshold: Expression<number> | null;
-    maximumThreshold: Expression<number> | null;
+    bounds: Bounds<Expression<number>>;
 };
 export declare const FloorExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<number, [value: Expression<number>, minimumThreshold: Expression<number> | null], Expression<number> & {
     value: Expression<number>;

package/dist/expression/numeric-expression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"numeric-expression.d.ts","sourceRoot":"","sources":["../../src/expression/numeric-expression.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAA;AAC7D,OAAO,EAAE,KAAK,EAAW,MAAM,uBAAuB,CAAA;AAGtD,eAAO,MAAM,aAAa;;EAiBxB,CAAA;AAEF,eAAO,MAAM,GAAG;;CAAwB,CAAA;AAExC,eAAO,MAAM,kBAAkB;;EAiB7B,CAAA;AAEF,eAAO,MAAM,QAAQ;;CAA6B,CAAA;AAGlD,eAAO,MAAM,gBAAgB;;;;EAkB3B,CAAA;AAEF,eAAO,MAAM,MAAM;;;;CAA2B,CAAA;AAE9C,eAAO,MAAM,eAAe;;;EAc1B,CAAA;AAEF,eAAO,MAAM,KAAK;;;CAA0B,CAAA;AAE5C,eAAO,MAAM,iBAAiB;;;EAc5B,CAAA;AAEF,eAAO,MAAM,OAAO;;;CAA4B,CAAA;AAEhD,eAAO,MAAM,eAAe;;;;EAQ1B,CAAA;AAEF,eAAO,MAAM,KAAK;;;;CAA0B,CAAA;AAE5C,eAAO,MAAM,aAAa;;EAiBxB,CAAA;AAEF,eAAO,MAAM,GAAG;;CAAwB,CAAA;AAExC,eAAO,MAAM,aAAa;;EAiBxB,CAAA;AAEF,eAAO,MAAM,GAAG;;CAAwB,CAAA"}
+{"version":3,"file":"numeric-expression.d.ts","sourceRoot":"","sources":["../../src/expression/numeric-expression.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAA;AAC7D,OAAO,EAAE,KAAK,EAAW,MAAM,uBAAuB,CAAA;AAEtD,OAAO,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAA;AAEpD,eAAO,MAAM,aAAa;;EAiBxB,CAAA;AAEF,eAAO,MAAM,GAAG;;CAAwB,CAAA;AAExC,eAAO,MAAM,kBAAkB;;EAiB7B,CAAA;AAEF,eAAO,MAAM,QAAQ;;CAA6B,CAAA;AAElD,eAAO,MAAM,eAAe;;;EAmB1B,CAAA;AAEF,eAAO,MAAM,KAAK;;;CAA0B,CAAA;AAE5C,eAAO,MAAM,eAAe;;;EAc1B,CAAA;AAEF,eAAO,MAAM,KAAK;;;CAA0B,CAAA;AAE5C,eAAO,MAAM,iBAAiB;;;EAc5B,CAAA;AAEF,eAAO,MAAM,OAAO;;;CAA4B,CAAA;AAEhD,eAAO,MAAM,eAAe;;;;EAQ1B,CAAA;AAEF,eAAO,MAAM,KAAK;;;;CAA0B,CAAA;AAE5C,eAAO,MAAM,aAAa;;EAiBxB,CAAA;AAEF,eAAO,MAAM,GAAG;;CAAwB,CAAA;AAExC,eAAO,MAAM,aAAa;;EAiBxB,CAAA;AAEF,eAAO,MAAM,GAAG;;CAAwB,CAAA"}

package/dist/expression/numeric-expression.js

@@ -37,15 +37,15 @@ var MultiplyExpression = defineExpression({
   }
 });
 var multiply = MultiplyExpression.builder;
-var BoundsExpression = defineExpression({
-  expressionKey: "Numeric.Bounds",
-  builder: (value, minimumThreshold, maximumThreshold) => {
-    return { value, minimumThreshold, maximumThreshold };
+var BoundExpression = defineExpression({
+  expressionKey: "Numeric.Bound",
+  builder: (value, bounds) => {
+    return { value, bounds };
   },
   resolver: (expression, evaluate) => {
     let value = evaluate(expression.value);
-    const minimumThreshold = Objects.isPresent(expression.minimumThreshold) ? evaluate(expression.minimumThreshold) : null;
-    const maximumThreshold = Objects.isPresent(expression.maximumThreshold) ? evaluate(expression.maximumThreshold) : null;
+    const minimumThreshold = Objects.isPresent(expression.bounds[0]) ? evaluate(expression.bounds[0]) : null;
+    const maximumThreshold = Objects.isPresent(expression.bounds[1]) ? evaluate(expression.bounds[1]) : null;
     if (Objects.isPresent(minimumThreshold) && value < minimumThreshold) {
       value = minimumThreshold;
     }
@@ -55,7 +55,7 @@ var BoundsExpression = defineExpression({
     return value;
   }
 });
-var bounds = BoundsExpression.builder;
+var bound = BoundExpression.builder;
 var FloorExpression = defineExpression({
   expressionKey: "Numeric.Floor",
   builder: (value, minimumThreshold) => {
@@ -133,7 +133,7 @@ var MaxExpression = defineExpression({
 });
 var max = MaxExpression.builder;
 export {
-  BoundsExpression,
+  BoundExpression,
   CeilingExpression,
   FloorExpression,
   MaxExpression,
@@ -141,7 +141,7 @@ export {
   MultiplyExpression,
   RoundExpression,
   SumExpression,
-  bounds,
+  bound,
   ceiling,
   floor,
   max,

package/dist/expression/numeric-expression.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/expression/numeric-expression.ts"],"sourcesContent":["import { defineExpression, isType } from '@bessemer/cornerstone/expression/internal'\nimport { Expression } from '@bessemer/cornerstone/expression'\nimport { Maths, Objects } from '@bessemer/cornerstone'\nimport { RoundingMode } from '@bessemer/cornerstone/math'\n\nexport const SumExpression = defineExpression({\n  expressionKey: 'Numeric.Sum',\n  builder: (initialOperands: Array<Expression<number>>) => {\n    const operands: Array<Expression<number>> = initialOperands.flatMap((it) => {\n      if (isType(it, SumExpression)) {\n        return it.operands\n      } else {\n        return [it]\n      }\n    })\n\n    return { operands }\n  },\n  resolver: ({ operands }, evaluate) => {\n    const values = operands.map((it) => evaluate(it))\n    return values.reduce((x, y) => x + y, 0)\n  },\n})\n\nexport const sum = SumExpression.builder\n\nexport const MultiplyExpression = defineExpression({\n  expressionKey: 'Numeric.Multiply',\n  builder: (initialOperands: Array<Expression<number>>) => {\n    const operands: Array<Expression<number>> = initialOperands.flatMap((it) => {\n      if (isType(it, MultiplyExpression)) {\n        return it.operands\n      } else {\n        return [it]\n      }\n    })\n\n    return { operands }\n  },\n  resolver: ({ operands }, evaluate) => {\n    const values = operands.map((it) => evaluate(it))\n    return values.reduce((x, y) => x * y, 1)\n  },\n})\n\nexport const multiply = MultiplyExpression.builder\n\n// JOHN convert to using the Bounds type and maybe rename to indicate that this bounds the value rather than tests to see if it is in bounds?\nexport const BoundsExpression = defineExpression({\n  expressionKey: 'Numeric.Bounds',\n  builder: (value: Expression<number>, minimumThreshold: Expression<number> | null, maximumThreshold: Expression<number> | null) => {\n    return { value, minimumThreshold, maximumThreshold }\n  },\n  resolver: (expression, evaluate) => {\n    let value = evaluate(expression.value)\n    const minimumThreshold = Objects.isPresent(expression.minimumThreshold) ? evaluate(expression.minimumThreshold) : null\n    const maximumThreshold = Objects.isPresent(expression.maximumThreshold) ? evaluate(expression.maximumThreshold) : null\n    if (Objects.isPresent(minimumThreshold) && value < minimumThreshold) {\n      value = minimumThreshold\n    }\n    if (Objects.isPresent(maximumThreshold) && value > maximumThreshold) {\n      value = maximumThreshold\n    }\n\n    return value\n  },\n})\n\nexport const bounds = BoundsExpression.builder\n\nexport const FloorExpression = defineExpression({\n  expressionKey: 'Numeric.Floor',\n  builder: (value: Expression<number>, minimumThreshold: Expression<number> | null) => {\n    return { value, minimumThreshold }\n  },\n  resolver: (expression, evaluate) => {\n    let value = evaluate(expression.value)\n    const minimumThreshold = Objects.isPresent(expression.minimumThreshold) ? evaluate(expression.minimumThreshold) : null\n    if (Objects.isPresent(minimumThreshold) && value < minimumThreshold) {\n      value = minimumThreshold\n    }\n\n    return value\n  },\n})\n\nexport const floor = FloorExpression.builder\n\nexport const CeilingExpression = defineExpression({\n  expressionKey: 'Numeric.Ceiling',\n  builder: (value: Expression<number>, maximumThreshold: Expression<number> | null) => {\n    return { value, maximumThreshold }\n  },\n  resolver: (expression, evaluate) => {\n    let value = evaluate(expression.value)\n    const maximumThreshold = Objects.isPresent(expression.maximumThreshold) ? evaluate(expression.maximumThreshold) : null\n    if (Objects.isPresent(maximumThreshold) && value > maximumThreshold) {\n      value = maximumThreshold\n    }\n\n    return value\n  },\n})\n\nexport const ceiling = CeilingExpression.builder\n\nexport const RoundExpression = defineExpression({\n  expressionKey: 'Numeric.Round',\n  builder: (value: Expression<number>, scale: number, roundingMode: RoundingMode) => {\n    return { value, scale, roundingMode }\n  },\n  resolver: ({ value, scale, roundingMode }, evaluate) => {\n    return Maths.round(evaluate(value), scale, roundingMode)\n  },\n})\n\nexport const round = RoundExpression.builder\n\nexport const MinExpression = defineExpression({\n  expressionKey: 'Numeric.Min',\n  builder: (initialOperands: Array<Expression<number>>) => {\n    const operands: Array<Expression<number>> = initialOperands.flatMap((it) => {\n      if (isType(it, MinExpression)) {\n        return it.operands\n      } else {\n        return [it]\n      }\n    })\n\n    return { operands }\n  },\n  resolver: ({ operands }, evaluate) => {\n    const values = operands.map((it) => evaluate(it))\n    return Math.min(...values)\n  },\n})\n\nexport const min = MinExpression.builder\n\nexport const MaxExpression = defineExpression({\n  expressionKey: 'Numeric.Max',\n  builder: (initialOperands: Array<Expression<number>>) => {\n    const operands: Array<Expression<number>> = initialOperands.flatMap((it) => {\n      if (isType(it, MaxExpression)) {\n        return it.operands\n      } else {\n        return [it]\n      }\n    })\n\n    return { operands }\n  },\n  resolver: ({ operands }, evaluate) => {\n    const values = operands.map((it) => evaluate(it))\n    return Math.max(...values)\n  },\n})\n\nexport const max = MaxExpression.builder\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../../src/expression/numeric-expression.ts"],"sourcesContent":["import { defineExpression, isType } from '@bessemer/cornerstone/expression/internal'\nimport { Expression } from '@bessemer/cornerstone/expression'\nimport { Maths, Objects } from '@bessemer/cornerstone'\nimport { RoundingMode } from '@bessemer/cornerstone/math'\nimport { Bounds } from '@bessemer/cornerstone/range'\n\nexport const SumExpression = defineExpression({\n  expressionKey: 'Numeric.Sum',\n  builder: (initialOperands: Array<Expression<number>>) => {\n    const operands: Array<Expression<number>> = initialOperands.flatMap((it) => {\n      if (isType(it, SumExpression)) {\n        return it.operands\n      } else {\n        return [it]\n      }\n    })\n\n    return { operands }\n  },\n  resolver: ({ operands }, evaluate) => {\n    const values = operands.map((it) => evaluate(it))\n    return values.reduce((x, y) => x + y, 0)\n  },\n})\n\nexport const sum = SumExpression.builder\n\nexport const MultiplyExpression = defineExpression({\n  expressionKey: 'Numeric.Multiply',\n  builder: (initialOperands: Array<Expression<number>>) => {\n    const operands: Array<Expression<number>> = initialOperands.flatMap((it) => {\n      if (isType(it, MultiplyExpression)) {\n        return it.operands\n      } else {\n        return [it]\n      }\n    })\n\n    return { operands }\n  },\n  resolver: ({ operands }, evaluate) => {\n    const values = operands.map((it) => evaluate(it))\n    return values.reduce((x, y) => x * y, 1)\n  },\n})\n\nexport const multiply = MultiplyExpression.builder\n\nexport const BoundExpression = defineExpression({\n  expressionKey: 'Numeric.Bound',\n  builder: (value: Expression<number>, bounds: Bounds<Expression<number>>) => {\n    return { value, bounds }\n  },\n  resolver: (expression, evaluate) => {\n    let value = evaluate(expression.value)\n    const minimumThreshold = Objects.isPresent(expression.bounds[0]) ? evaluate(expression.bounds[0]) : null\n    const maximumThreshold = Objects.isPresent(expression.bounds[1]) ? evaluate(expression.bounds[1]) : null\n\n    if (Objects.isPresent(minimumThreshold) && value < minimumThreshold) {\n      value = minimumThreshold\n    }\n    if (Objects.isPresent(maximumThreshold) && value > maximumThreshold) {\n      value = maximumThreshold\n    }\n\n    return value\n  },\n})\n\nexport const bound = BoundExpression.builder\n\nexport const FloorExpression = defineExpression({\n  expressionKey: 'Numeric.Floor',\n  builder: (value: Expression<number>, minimumThreshold: Expression<number> | null) => {\n    return { value, minimumThreshold }\n  },\n  resolver: (expression, evaluate) => {\n    let value = evaluate(expression.value)\n    const minimumThreshold = Objects.isPresent(expression.minimumThreshold) ? evaluate(expression.minimumThreshold) : null\n    if (Objects.isPresent(minimumThreshold) && value < minimumThreshold) {\n      value = minimumThreshold\n    }\n\n    return value\n  },\n})\n\nexport const floor = FloorExpression.builder\n\nexport const CeilingExpression = defineExpression({\n  expressionKey: 'Numeric.Ceiling',\n  builder: (value: Expression<number>, maximumThreshold: Expression<number> | null) => {\n    return { value, maximumThreshold }\n  },\n  resolver: (expression, evaluate) => {\n    let value = evaluate(expression.value)\n    const maximumThreshold = Objects.isPresent(expression.maximumThreshold) ? evaluate(expression.maximumThreshold) : null\n    if (Objects.isPresent(maximumThreshold) && value > maximumThreshold) {\n      value = maximumThreshold\n    }\n\n    return value\n  },\n})\n\nexport const ceiling = CeilingExpression.builder\n\nexport const RoundExpression = defineExpression({\n  expressionKey: 'Numeric.Round',\n  builder: (value: Expression<number>, scale: number, roundingMode: RoundingMode) => {\n    return { value, scale, roundingMode }\n  },\n  resolver: ({ value, scale, roundingMode }, evaluate) => {\n    return Maths.round(evaluate(value), scale, roundingMode)\n  },\n})\n\nexport const round = RoundExpression.builder\n\nexport const MinExpression = defineExpression({\n  expressionKey: 'Numeric.Min',\n  builder: (initialOperands: Array<Expression<number>>) => {\n    const operands: Array<Expression<number>> = initialOperands.flatMap((it) => {\n      if (isType(it, MinExpression)) {\n        return it.operands\n      } else {\n        return [it]\n      }\n    })\n\n    return { operands }\n  },\n  resolver: ({ operands }, evaluate) => {\n    const values = operands.map((it) => evaluate(it))\n    return Math.min(...values)\n  },\n})\n\nexport const min = MinExpression.builder\n\nexport const MaxExpression = defineExpression({\n  expressionKey: 'Numeric.Max',\n  builder: (initialOperands: Array<Expression<number>>) => {\n    const operands: Array<Expression<number>> = initialOperands.flatMap((it) => {\n      if (isType(it, MaxExpression)) {\n        return it.operands\n      } else {\n        return [it]\n      }\n    })\n\n    return { operands }\n  },\n  resolver: ({ operands }, evaluate) => {\n    const values = operands.map((it) => evaluate(it))\n    return Math.max(...values)\n  },\n})\n\nexport const max = MaxExpression.builder\n"],"mappings":"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","names":[]}

package/dist/expression.d.ts

@@ -1,4 +1,3 @@
-import * as BasicExpressions from '@bessemer/cornerstone/expression/basic-expression';
 import * as NumericExpressions from '@bessemer/cornerstone/expression/numeric-expression';
 import * as StringExpressions from '@bessemer/cornerstone/expression/string-expression';
 import * as ArrayExpressions from '@bessemer/cornerstone/expression/array-expression';
@@ -6,7 +5,7 @@ import * as Expressions from '@bessemer/cornerstone/expression/expression';
 import { NominalType } from '@bessemer/cornerstone/types';
 import { Signable } from '@bessemer/cornerstone/signature';
 import { UnknownRecord } from 'type-fest';
-export { Expressions, BasicExpressions, NumericExpressions, StringExpressions, ArrayExpressions };
+export { Expressions, NumericExpressions, StringExpressions, ArrayExpressions };
 export type ExpressionKey<ReturnType, ArgumentType extends Array<unknown>> = NominalType<string, ['ExpressionKey', ReturnType, ArgumentType]>;
 export type Expression<ReturnType> = ReturnType | IExpression<ReturnType>;
 export interface IExpression<ReturnType> {

package/dist/expression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expression.d.ts","sourceRoot":"","sources":["../src/expression.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,gBAAgB,MAAM,mDAAmD,CAAA;AACrF,OAAO,KAAK,kBAAkB,MAAM,qDAAqD,CAAA;AACzF,OAAO,KAAK,iBAAiB,MAAM,oDAAoD,CAAA;AACvF,OAAO,KAAK,gBAAgB,MAAM,mDAAmD,CAAA;AACrF,OAAO,KAAK,WAAW,MAAM,6CAA6C,CAAA;AAC1E,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AACzD,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAA;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAEzC,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,CAAA;AAEjG,MAAM,MAAM,aAAa,CAAC,UAAU,EAAE,YAAY,SAAS,KAAK,CAAC,OAAO,CAAC,IAAI,WAAW,CAAC,MAAM,EAAE,CAAC,eAAe,EAAE,UAAU,EAAE,YAAY,CAAC,CAAC,CAAA;AAE7I,MAAM,MAAM,UAAU,CAAC,UAAU,IAAI,UAAU,GAAG,WAAW,CAAC,UAAU,CAAC,CAAA;AAEzE,MAAM,WAAW,WAAW,CAAC,UAAU;IACrC,aAAa,EAAE,aAAa,CAAC,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAA;CACzD;AAED,MAAM,WAAW,mBAAmB,CAAC,UAAU,EAAE,YAAY,SAAS,KAAK,CAAC,OAAO,CAAC;IAClF,aAAa,EAAE,aAAa,CAAC,UAAU,EAAE,YAAY,CAAC,CAAA;CACvD;AAED,MAAM,WAAW,kBAAkB,CAAC,UAAU,EAAE,YAAY,CAAE,SAAQ,mBAAmB,CAAC,UAAU,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;CAAG;AAE3I,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAA;AAEpE,MAAM,MAAM,oBAAoB,CAC9B,UAAU,EACV,YAAY,SAAS,KAAK,CAAC,OAAO,CAAC,EACnC,cAAc,SAAS,UAAU,CAAC,UAAU,CAAC,IAC3C,mBAAmB,CAAC,UAAU,EAAE,YAAY,CAAC,GAAG;IAClD,aAAa,EAAE,aAAa,CAAC,UAAU,EAAE,YAAY,CAAC,CAAA;IACtD,OAAO,EAAE,CAAC,GAAG,UAAU,EAAE,YAAY,KAAK,cAAc,CAAA;IACxD,QAAQ,EAAE,CAAC,UAAU,EAAE,cAAc,EAAE,QAAQ,EAAE,kBAAkB,EAAE,OAAO,EAAE,iBAAiB,KAAK,UAAU,CAAA;CAC/G,CAAA;AAED,MAAM,WAAW,kBAAkB,CAAC,CAAC,CAAE,SAAQ,WAAW,CAAC,CAAC,CAAC;IAC3D,aAAa,EAAE,UAAU,CAAA;IACzB,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,qBAAqB,CAAC,SAAS,EAAE,aAAa,SAAS,KAAK,CAAC,QAAQ,CAAC;IACrF,KAAK,CAAC,GAAG,UAAU,EAAE,aAAa,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAA;CACnE;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,SAAS,EAAE,aAAa,CAAA;CACzB,CAAA"}
+{"version":3,"file":"expression.d.ts","sourceRoot":"","sources":["../src/expression.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,kBAAkB,MAAM,qDAAqD,CAAA;AACzF,OAAO,KAAK,iBAAiB,MAAM,oDAAoD,CAAA;AACvF,OAAO,KAAK,gBAAgB,MAAM,mDAAmD,CAAA;AACrF,OAAO,KAAK,WAAW,MAAM,6CAA6C,CAAA;AAC1E,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AACzD,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAA;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAEzC,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,CAAA;AAE/E,MAAM,MAAM,aAAa,CAAC,UAAU,EAAE,YAAY,SAAS,KAAK,CAAC,OAAO,CAAC,IAAI,WAAW,CAAC,MAAM,EAAE,CAAC,eAAe,EAAE,UAAU,EAAE,YAAY,CAAC,CAAC,CAAA;AAE7I,MAAM,MAAM,UAAU,CAAC,UAAU,IAAI,UAAU,GAAG,WAAW,CAAC,UAAU,CAAC,CAAA;AAEzE,MAAM,WAAW,WAAW,CAAC,UAAU;IACrC,aAAa,EAAE,aAAa,CAAC,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAA;CACzD;AAED,MAAM,WAAW,mBAAmB,CAAC,UAAU,EAAE,YAAY,SAAS,KAAK,CAAC,OAAO,CAAC;IAClF,aAAa,EAAE,aAAa,CAAC,UAAU,EAAE,YAAY,CAAC,CAAA;CACvD;AAED,MAAM,WAAW,kBAAkB,CAAC,UAAU,EAAE,YAAY,CAAE,SAAQ,mBAAmB,CAAC,UAAU,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;CAAG;AAE3I,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAA;AAEpE,MAAM,MAAM,oBAAoB,CAC9B,UAAU,EACV,YAAY,SAAS,KAAK,CAAC,OAAO,CAAC,EACnC,cAAc,SAAS,UAAU,CAAC,UAAU,CAAC,IAC3C,mBAAmB,CAAC,UAAU,EAAE,YAAY,CAAC,GAAG;IAClD,aAAa,EAAE,aAAa,CAAC,UAAU,EAAE,YAAY,CAAC,CAAA;IACtD,OAAO,EAAE,CAAC,GAAG,UAAU,EAAE,YAAY,KAAK,cAAc,CAAA;IACxD,QAAQ,EAAE,CAAC,UAAU,EAAE,cAAc,EAAE,QAAQ,EAAE,kBAAkB,EAAE,OAAO,EAAE,iBAAiB,KAAK,UAAU,CAAA;CAC/G,CAAA;AAED,MAAM,WAAW,kBAAkB,CAAC,CAAC,CAAE,SAAQ,WAAW,CAAC,CAAC,CAAC;IAC3D,aAAa,EAAE,UAAU,CAAA;IACzB,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,qBAAqB,CAAC,SAAS,EAAE,aAAa,SAAS,KAAK,CAAC,QAAQ,CAAC;IACrF,KAAK,CAAC,GAAG,UAAU,EAAE,aAAa,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAA;CACnE;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,SAAS,EAAE,aAAa,CAAA;CACzB,CAAA"}

package/dist/expression.js

@@ -1,12 +1,10 @@
 // src/expression.ts
-import * as BasicExpressions from "@bessemer/cornerstone/expression/basic-expression";
 import * as NumericExpressions from "@bessemer/cornerstone/expression/numeric-expression";
 import * as StringExpressions from "@bessemer/cornerstone/expression/string-expression";
 import * as ArrayExpressions from "@bessemer/cornerstone/expression/array-expression";
 import * as Expressions from "@bessemer/cornerstone/expression/expression";
 export {
   ArrayExpressions,
-  BasicExpressions,
   Expressions,
   NumericExpressions,
   StringExpressions

package/dist/expression.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/expression.ts"],"sourcesContent":["import * as BasicExpressions from '@bessemer/cornerstone/expression/basic-expression'\nimport * as NumericExpressions from '@bessemer/cornerstone/expression/numeric-expression'\nimport * as StringExpressions from '@bessemer/cornerstone/expression/string-expression'\nimport * as ArrayExpressions from '@bessemer/cornerstone/expression/array-expression'\nimport * as Expressions from '@bessemer/cornerstone/expression/expression'\nimport { NominalType } from '@bessemer/cornerstone/types'\nimport { Signable } from '@bessemer/cornerstone/signature'\nimport { UnknownRecord } from 'type-fest'\n\nexport { Expressions, BasicExpressions, NumericExpressions, StringExpressions, ArrayExpressions }\n\nexport type ExpressionKey<ReturnType, ArgumentType extends Array<unknown>> = NominalType<string, ['ExpressionKey', ReturnType, ArgumentType]>\n\nexport type Expression<ReturnType> = ReturnType | IExpression<ReturnType>\n\nexport interface IExpression<ReturnType> {\n  expressionKey: ExpressionKey<ReturnType, Array<unknown>>\n}\n\nexport interface ExpressionReference<ReturnType, ArgumentType extends Array<unknown>> {\n  expressionKey: ExpressionKey<ReturnType, ArgumentType>\n}\n\nexport interface ReducingExpression<ReturnType, ArgumentType> extends ExpressionReference<ReturnType, [Array<Expression<ArgumentType>>]> {}\n\nexport type EvaluateExpression = <T>(expression: Expression<T>) => T\n\nexport type ExpressionDefinition<\n  ReturnType,\n  ArgumentType extends Array<unknown>,\n  ExpressionType extends Expression<ReturnType>\n> = ExpressionReference<ReturnType, ArgumentType> & {\n  expressionKey: ExpressionKey<ReturnType, ArgumentType>\n  builder: (...parameters: ArgumentType) => ExpressionType\n  resolver: (expression: ExpressionType, evaluate: EvaluateExpression, context: ExpressionContext) => ReturnType\n}\n\nexport interface ExpressionVariable<T> extends IExpression<T> {\n  expressionKey: 'Variable'\n  name: string\n}\n\nexport interface ParameterizedVariable<ValueType, ParameterType extends Array<Signable>> {\n  apply(...parameters: ParameterType): ExpressionVariable<ValueType>\n}\n\nexport type ExpressionContext = {\n  variables: UnknownRecord\n}\n"],"mappings":";AAAA,YAAY,sBAAsB;AAClC,YAAY,wBAAwB;AACpC,YAAY,uBAAuB;AACnC,YAAY,sBAAsB;AAClC,YAAY,iBAAiB;","names":[]}
+{"version":3,"sources":["../src/expression.ts"],"sourcesContent":["import * as NumericExpressions from '@bessemer/cornerstone/expression/numeric-expression'\nimport * as StringExpressions from '@bessemer/cornerstone/expression/string-expression'\nimport * as ArrayExpressions from '@bessemer/cornerstone/expression/array-expression'\nimport * as Expressions from '@bessemer/cornerstone/expression/expression'\nimport { NominalType } from '@bessemer/cornerstone/types'\nimport { Signable } from '@bessemer/cornerstone/signature'\nimport { UnknownRecord } from 'type-fest'\n\nexport { Expressions, NumericExpressions, StringExpressions, ArrayExpressions }\n\nexport type ExpressionKey<ReturnType, ArgumentType extends Array<unknown>> = NominalType<string, ['ExpressionKey', ReturnType, ArgumentType]>\n\nexport type Expression<ReturnType> = ReturnType | IExpression<ReturnType>\n\nexport interface IExpression<ReturnType> {\n  expressionKey: ExpressionKey<ReturnType, Array<unknown>>\n}\n\nexport interface ExpressionReference<ReturnType, ArgumentType extends Array<unknown>> {\n  expressionKey: ExpressionKey<ReturnType, ArgumentType>\n}\n\nexport interface ReducingExpression<ReturnType, ArgumentType> extends ExpressionReference<ReturnType, [Array<Expression<ArgumentType>>]> {}\n\nexport type EvaluateExpression = <T>(expression: Expression<T>) => T\n\nexport type ExpressionDefinition<\n  ReturnType,\n  ArgumentType extends Array<unknown>,\n  ExpressionType extends Expression<ReturnType>\n> = ExpressionReference<ReturnType, ArgumentType> & {\n  expressionKey: ExpressionKey<ReturnType, ArgumentType>\n  builder: (...parameters: ArgumentType) => ExpressionType\n  resolver: (expression: ExpressionType, evaluate: EvaluateExpression, context: ExpressionContext) => ReturnType\n}\n\nexport interface ExpressionVariable<T> extends IExpression<T> {\n  expressionKey: 'Variable'\n  name: string\n}\n\nexport interface ParameterizedVariable<ValueType, ParameterType extends Array<Signable>> {\n  apply(...parameters: ParameterType): ExpressionVariable<ValueType>\n}\n\nexport type ExpressionContext = {\n  variables: UnknownRecord\n}\n"],"mappings":";AAAA,YAAY,wBAAwB;AACpC,YAAY,uBAAuB;AACnC,YAAY,sBAAsB;AAClC,YAAY,iBAAiB;","names":[]}

package/dist/sql/sql-expression-parser.d.ts

@@ -0,0 +1,11 @@
+import { ExpressionMapper } from '@bessemer/cornerstone/expression/expression-mapper';
+import { Dictionary } from '@bessemer/cornerstone/types';
+import { SqlFragment, SqlParameterMap } from '@bessemer/cornerstone/sql';
+export type SqlExpressionParserContext = {
+    variables: Dictionary<string>;
+    parameters: SqlParameterMap;
+};
+export declare class SqlExpressionParser extends ExpressionMapper<SqlFragment, SqlExpressionParserContext> {
+}
+export declare const DefaultSqlExpressionParser: SqlExpressionParser;
+//# sourceMappingURL=sql-expression-parser.d.ts.map

package/dist/sql/sql-expression-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-expression-parser.d.ts","sourceRoot":"","sources":["../../src/sql/sql-expression-parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oDAAoD,CAAA;AAErF,OAAO,EAAa,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAenE,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAExE,MAAM,MAAM,0BAA0B,GAAG;IACvC,SAAS,EAAE,UAAU,CAAC,MAAM,CAAC,CAAA;IAC7B,UAAU,EAAE,eAAe,CAAA;CAC5B,CAAA;AACD,qBAAa,mBAAoB,SAAQ,gBAAgB,CAAC,WAAW,EAAE,0BAA0B,CAAC;CAAG;AAErG,eAAO,MAAM,0BAA0B,qBAA4B,CAAA"}

package/dist/sql/sql-expression-parser.js

@@ -0,0 +1,108 @@
+// src/sql/sql-expression-parser.ts
+import { ExpressionMapper } from "@bessemer/cornerstone/expression/expression-mapper";
+import { Arrays, Objects, Preconditions, Ulids } from "@bessemer/cornerstone";
+import {
+  AndExpression,
+  ContainsExpression,
+  EqualsExpression,
+  GreaterThanExpression,
+  GreaterThanOrEqualExpression,
+  LessThanExpression,
+  LessThanOrEqualExpression,
+  NotExpression,
+  OrExpression,
+  ValueExpression,
+  VariableExpression
+} from "@bessemer/cornerstone/expression/core-expression";
+import { isType, isValue } from "@bessemer/cornerstone/expression/internal";
+var SqlExpressionParser = class extends ExpressionMapper {
+};
+var DefaultSqlExpressionParser = new SqlExpressionParser();
+DefaultSqlExpressionParser.register(ValueExpression, (expression, _, context) => {
+  const value = expression.value;
+  const parameterName = `_${Ulids.generate()}`;
+  if (!Objects.isBasic(value)) {
+    throw new Error(`SqlExpressionParser - Unable to resolve complex ValueExpression as Sql: ${JSON.stringify(value)}`);
+  }
+  context.parameters[parameterName] = value;
+  return `:${parameterName}`;
+});
+DefaultSqlExpressionParser.register(VariableExpression, (expression, _, context) => {
+  const variableName = context.variables[expression.name];
+  Preconditions.isPresent(variableName, `SqlExpressionParser - Unable to resolve VariableExpression with name: ${expression.name}`);
+  return variableName;
+});
+DefaultSqlExpressionParser.register(NotExpression, (expression, map, context) => {
+  if (isType(expression.value, ContainsExpression)) {
+    const collection = expression.value.collection;
+    let value = [];
+    if (isType(collection, ValueExpression)) {
+      value = collection.value;
+    } else if (isValue(collection)) {
+      value = collection;
+    } else {
+      throw new Error(`SqlExpressionParser - Unable to resolve ContainsExpression with non-value collection: ${JSON.stringify(collection)}`);
+    }
+    value.forEach((it) => {
+      if (!Objects.isBasic(it)) {
+        throw new Error(`SqlExpressionParser - Unable to resolve complex ValueExpression as Sql: ${JSON.stringify(it)}`);
+      }
+    });
+    const parameterName = `_${Ulids.generate()}`;
+    context.parameters[parameterName] = value;
+    const containsExpression = expression.value.operands.map(map).map((sql) => `(${sql} NOT IN :${parameterName})`).join(" AND ");
+    return `(${containsExpression})`;
+  } else {
+    return `(NOT ${map(expression.value)})`;
+  }
+});
+DefaultSqlExpressionParser.register(AndExpression, (expression, map) => {
+  return `(${expression.operands.map(map).join(" AND ")})`;
+});
+DefaultSqlExpressionParser.register(OrExpression, (expression, map) => {
+  return `(${expression.operands.map(map).join(" OR ")})`;
+});
+DefaultSqlExpressionParser.register(EqualsExpression, (expression, map) => {
+  const first = Arrays.first(expression.operands);
+  const rest = Arrays.rest(expression.operands);
+  const mappedFirst = map(first);
+  const equalsExpressions = rest.map((it) => `(${mappedFirst} = ${map(it)})`).join(" AND ");
+  return `(${equalsExpressions})`;
+});
+DefaultSqlExpressionParser.register(ContainsExpression, (expression, map, context) => {
+  const collection = expression.collection;
+  let value = [];
+  if (isType(collection, ValueExpression)) {
+    value = collection.value;
+  } else if (isValue(collection)) {
+    value = collection;
+  } else {
+    throw new Error(`SqlExpressionParser - Unable to resolve ContainsExpression with non-value collection: ${JSON.stringify(collection)}`);
+  }
+  value.forEach((it) => {
+    if (!Objects.isBasic(it)) {
+      throw new Error(`SqlExpressionParser - Unable to resolve complex ValueExpression as Sql: ${JSON.stringify(it)}`);
+    }
+  });
+  const parameterName = `_${Ulids.generate()}`;
+  context.parameters[parameterName] = value;
+  const containsExpression = expression.operands.map(map).map((sql) => `(${sql} IN :${parameterName})`).join(" AND ");
+  return `(${containsExpression})`;
+});
+DefaultSqlExpressionParser.register(LessThanExpression, (expression, map) => {
+  return `(${map(expression.left)} < ${map(expression.right)})`;
+});
+DefaultSqlExpressionParser.register(LessThanOrEqualExpression, (expression, map) => {
+  return `(${map(expression.left)} <= ${map(expression.right)})`;
+});
+DefaultSqlExpressionParser.register(GreaterThanExpression, (expression, map) => {
+  return `(${map(expression.left)} > ${map(expression.right)})`;
+});
+DefaultSqlExpressionParser.register(GreaterThanOrEqualExpression, (expression, map) => {
+  return `(${map(expression.left)} >= ${map(expression.right)})`;
+});
+export {
+  DefaultSqlExpressionParser,
+  SqlExpressionParser
+};
+//# sourceMappingURL=sql-expression-parser.js.map

package/dist/sql/sql-expression-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/sql/sql-expression-parser.ts"],"sourcesContent":["import { ExpressionMapper } from '@bessemer/cornerstone/expression/expression-mapper'\nimport { Arrays, Objects, Preconditions, Ulids } from '@bessemer/cornerstone'\nimport { BasicType, Dictionary } from '@bessemer/cornerstone/types'\nimport {\n  AndExpression,\n  ContainsExpression,\n  EqualsExpression,\n  GreaterThanExpression,\n  GreaterThanOrEqualExpression,\n  LessThanExpression,\n  LessThanOrEqualExpression,\n  NotExpression,\n  OrExpression,\n  ValueExpression,\n  VariableExpression,\n} from '@bessemer/cornerstone/expression/core-expression'\nimport { isType, isValue } from '@bessemer/cornerstone/expression/internal'\nimport { SqlFragment, SqlParameterMap } from '@bessemer/cornerstone/sql'\n\nexport type SqlExpressionParserContext = {\n  variables: Dictionary<string>\n  parameters: SqlParameterMap\n}\nexport class SqlExpressionParser extends ExpressionMapper<SqlFragment, SqlExpressionParserContext> {}\n\nexport const DefaultSqlExpressionParser = new SqlExpressionParser()\nDefaultSqlExpressionParser.register(ValueExpression, (expression, _, context) => {\n  const value = expression.value\n  const parameterName = `_${Ulids.generate()}`\n  if (!Objects.isBasic(value)) {\n    throw new Error(`SqlExpressionParser - Unable to resolve complex ValueExpression as Sql: ${JSON.stringify(value)}`)\n  }\n\n  context.parameters[parameterName] = value\n  return `:${parameterName}`\n})\nDefaultSqlExpressionParser.register(VariableExpression, (expression, _, context) => {\n  const variableName = context.variables[expression.name]\n  Preconditions.isPresent(variableName, `SqlExpressionParser - Unable to resolve VariableExpression with name: ${expression.name}`)\n  return variableName\n})\nDefaultSqlExpressionParser.register(NotExpression, (expression, map, context) => {\n  if (isType(expression.value, ContainsExpression)) {\n    // JOHN tons of gross duplicated code that is duped across the contains resolver\n    const collection = expression.value.collection\n\n    // JOHN parsing expressions like this should be easier...\n    let value: Array<BasicType> = []\n    if (isType(collection, ValueExpression)) {\n      value = collection.value as Array<BasicType>\n    } else if (isValue(collection)) {\n      value = collection as Array<BasicType>\n    } else {\n      throw new Error(`SqlExpressionParser - Unable to resolve ContainsExpression with non-value collection: ${JSON.stringify(collection)}`)\n    }\n\n    value.forEach((it) => {\n      if (!Objects.isBasic(it)) {\n        throw new Error(`SqlExpressionParser - Unable to resolve complex ValueExpression as Sql: ${JSON.stringify(it)}`)\n      }\n    })\n\n    const parameterName = `_${Ulids.generate()}`\n    context.parameters[parameterName] = value\n\n    const containsExpression = expression.value.operands\n      .map(map)\n      .map((sql) => `(${sql} NOT IN :${parameterName})`)\n      .join(' AND ')\n\n    return `(${containsExpression})`\n  } else {\n    return `(NOT ${map(expression.value)})`\n  }\n})\nDefaultSqlExpressionParser.register(AndExpression, (expression, map) => {\n  return `(${expression.operands.map(map).join(' AND ')})`\n})\nDefaultSqlExpressionParser.register(OrExpression, (expression, map) => {\n  return `(${expression.operands.map(map).join(' OR ')})`\n})\nDefaultSqlExpressionParser.register(EqualsExpression, (expression, map) => {\n  const first = Arrays.first(expression.operands)!\n  const rest = Arrays.rest(expression.operands)\n\n  const mappedFirst = map(first)\n  const equalsExpressions = rest.map((it) => `(${mappedFirst} = ${map(it)})`).join(' AND ')\n  return `(${equalsExpressions})`\n})\nDefaultSqlExpressionParser.register(ContainsExpression, (expression, map, context) => {\n  const collection = expression.collection\n\n  // JOHN parsing expressions like this should be easier...\n  let value: Array<BasicType> = []\n  if (isType(collection, ValueExpression)) {\n    value = collection.value as Array<BasicType>\n  } else if (isValue(collection)) {\n    value = collection as Array<BasicType>\n  } else {\n    throw new Error(`SqlExpressionParser - Unable to resolve ContainsExpression with non-value collection: ${JSON.stringify(collection)}`)\n  }\n\n  value.forEach((it) => {\n    if (!Objects.isBasic(it)) {\n      throw new Error(`SqlExpressionParser - Unable to resolve complex ValueExpression as Sql: ${JSON.stringify(it)}`)\n    }\n  })\n\n  const parameterName = `_${Ulids.generate()}`\n  context.parameters[parameterName] = value\n\n  const containsExpression = expression.operands\n    .map(map)\n    .map((sql) => `(${sql} IN :${parameterName})`)\n    .join(' AND ')\n\n  return `(${containsExpression})`\n})\nDefaultSqlExpressionParser.register(LessThanExpression, (expression, map) => {\n  return `(${map(expression.left)} < ${map(expression.right)})`\n})\nDefaultSqlExpressionParser.register(LessThanOrEqualExpression, (expression, map) => {\n  return `(${map(expression.left)} <= ${map(expression.right)})`\n})\nDefaultSqlExpressionParser.register(GreaterThanExpression, (expression, map) => {\n  return `(${map(expression.left)} > ${map(expression.right)})`\n})\nDefaultSqlExpressionParser.register(GreaterThanOrEqualExpression, (expression, map) => {\n  return `(${map(expression.left)} >= ${map(expression.right)})`\n})\n"],"mappings":"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","names":[]}

package/dist/sql/sql.d.ts

@@ -0,0 +1,7 @@
+import { Expression } from '@bessemer/cornerstone/expression';
+import { SqlExpressionParser } from '@bessemer/cornerstone/sql/sql-expression-parser';
+import { Dictionary } from '@bessemer/cornerstone/types';
+import { SqlFragment, SqlParameterMap } from '@bessemer/cornerstone/sql';
+export declare const fragment: (fragment: string) => SqlFragment;
+export declare const parseExpression: (expression: Expression<unknown>, variableMap: Dictionary<string>, parser?: SqlExpressionParser) => [SqlFragment, SqlParameterMap];
+//# sourceMappingURL=sql.d.ts.map

package/dist/sql/sql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql.d.ts","sourceRoot":"","sources":["../../src/sql/sql.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAe,MAAM,kCAAkC,CAAA;AAC1E,OAAO,EAA8B,mBAAmB,EAA8B,MAAM,iDAAiD,CAAA;AAC7I,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AACxD,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAExE,eAAO,MAAM,QAAQ,GAAI,UAAU,MAAM,KAAG,WAE3C,CAAA;AAED,eAAO,MAAM,eAAe,GAC1B,YAAY,UAAU,CAAC,OAAO,CAAC,EAC/B,aAAa,UAAU,CAAC,MAAM,CAAC,EAC/B,SAAQ,mBAAgD,KACvD,CAAC,WAAW,EAAE,eAAe,CAO/B,CAAA"}

package/dist/sql/sql.js

@@ -0,0 +1,19 @@
+// src/sql/sql.ts
+import { Expressions } from "@bessemer/cornerstone/expression";
+import { DefaultSqlExpressionParser } from "@bessemer/cornerstone/sql/sql-expression-parser";
+var fragment = (fragment2) => {
+  return fragment2;
+};
+var parseExpression = (expression, variableMap, parser = DefaultSqlExpressionParser) => {
+  const context = {
+    variables: variableMap,
+    parameters: {}
+  };
+  const fragment2 = Expressions.map(expression, parser, context);
+  return [fragment2, context.parameters];
+};
+export {
+  fragment,
+  parseExpression
+};
+//# sourceMappingURL=sql.js.map

package/dist/sql/sql.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/sql/sql.ts"],"sourcesContent":["import { Expression, Expressions } from '@bessemer/cornerstone/expression'\nimport { DefaultSqlExpressionParser, SqlExpressionParser, SqlExpressionParserContext } from '@bessemer/cornerstone/sql/sql-expression-parser'\nimport { Dictionary } from '@bessemer/cornerstone/types'\nimport { SqlFragment, SqlParameterMap } from '@bessemer/cornerstone/sql'\n\nexport const fragment = (fragment: string): SqlFragment => {\n  return fragment\n}\n\nexport const parseExpression = (\n  expression: Expression<unknown>,\n  variableMap: Dictionary<string>,\n  parser: SqlExpressionParser = DefaultSqlExpressionParser\n): [SqlFragment, SqlParameterMap] => {\n  const context: SqlExpressionParserContext = {\n    variables: variableMap,\n    parameters: {},\n  }\n  const fragment = Expressions.map(expression, parser, context)\n  return [fragment, context.parameters]\n}\n"],"mappings":";AAAA,SAAqB,mBAAmB;AACxC,SAAS,kCAAmF;AAIrF,IAAM,WAAW,CAACA,cAAkC;AACzD,SAAOA;AACT;AAEO,IAAM,kBAAkB,CAC7B,YACA,aACA,SAA8B,+BACK;AACnC,QAAM,UAAsC;AAAA,IAC1C,WAAW;AAAA,IACX,YAAY,CAAC;AAAA,EACf;AACA,QAAMA,YAAW,YAAY,IAAI,YAAY,QAAQ,OAAO;AAC5D,SAAO,CAACA,WAAU,QAAQ,UAAU;AACtC;","names":["fragment"]}

package/dist/sql.d.ts

@@ -0,0 +1,6 @@
+import * as Sql from '@bessemer/cornerstone/sql/sql';
+import { BasicType, Dictionary, NominalType } from '@bessemer/cornerstone/types';
+export { Sql };
+export type SqlFragment = NominalType<string, 'SqlFragment'>;
+export type SqlParameterMap = Dictionary<BasicType | Array<BasicType>>;
+//# sourceMappingURL=sql.d.ts.map

package/dist/sql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql.d.ts","sourceRoot":"","sources":["../src/sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,+BAA+B,CAAA;AACpD,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAEhF,OAAO,EAAE,GAAG,EAAE,CAAA;AAEd,MAAM,MAAM,WAAW,GAAG,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;AAC5D,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,CAAA"}

package/dist/sql.js

@@ -0,0 +1,6 @@
+// src/sql.ts
+import * as Sql from "@bessemer/cornerstone/sql/sql";
+export {
+  Sql
+};
+//# sourceMappingURL=sql.js.map

package/dist/sql.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/sql.ts"],"sourcesContent":["import * as Sql from '@bessemer/cornerstone/sql/sql'\nimport { BasicType, Dictionary, NominalType } from '@bessemer/cornerstone/types'\n\nexport { Sql }\n\nexport type SqlFragment = NominalType<string, 'SqlFragment'>\nexport type SqlParameterMap = Dictionary<BasicType | Array<BasicType>>\n"],"mappings":";AAAA,YAAY,SAAS;","names":[]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bessemer/cornerstone",
   "type": "module",
-  "version": "0.5.29",
+  "version": "0.5.31",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "sideEffects": false,

package/dist/expression/basic-expression.d.ts

@@ -1,35 +0,0 @@
-import { Expression } from '@bessemer/cornerstone/expression';
-import { BasicType } from '@bessemer/cornerstone/types';
-export declare const LessThanExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<boolean, [left: Expression<BasicType>, right: Expression<BasicType>], Expression<boolean> & {
-    left: Expression<BasicType>;
-    right: Expression<BasicType>;
-}>;
-export declare const lessThan: (left: Expression<BasicType>, right: Expression<BasicType>) => Expression<boolean> & {
-    left: Expression<BasicType>;
-    right: Expression<BasicType>;
-};
-export declare const LessThanOrEqualExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<boolean, [left: Expression<BasicType>, right: Expression<BasicType>], Expression<boolean> & {
-    left: Expression<BasicType>;
-    right: Expression<BasicType>;
-}>;
-export declare const lessThanOrEqual: (left: Expression<BasicType>, right: Expression<BasicType>) => Expression<boolean> & {
-    left: Expression<BasicType>;
-    right: Expression<BasicType>;
-};
-export declare const GreaterThanExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<boolean, [left: Expression<BasicType>, right: Expression<BasicType>], Expression<boolean> & {
-    left: Expression<BasicType>;
-    right: Expression<BasicType>;
-}>;
-export declare const greaterThan: (left: Expression<BasicType>, right: Expression<BasicType>) => Expression<boolean> & {
-    left: Expression<BasicType>;
-    right: Expression<BasicType>;
-};
-export declare const GreaterThanOrEqualExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<boolean, [left: Expression<BasicType>, right: Expression<BasicType>], Expression<boolean> & {
-    left: Expression<BasicType>;
-    right: Expression<BasicType>;
-}>;
-export declare const greaterThanOrEqual: (left: Expression<BasicType>, right: Expression<BasicType>) => Expression<boolean> & {
-    left: Expression<BasicType>;
-    right: Expression<BasicType>;
-};
-//# sourceMappingURL=basic-expression.d.ts.map

package/dist/expression/basic-expression.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"basic-expression.d.ts","sourceRoot":"","sources":["../../src/expression/basic-expression.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAA;AAC7D,OAAO,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAA;AAEvD,eAAO,MAAM,kBAAkB;;;EAQ7B,CAAA;AAEF,eAAO,MAAM,QAAQ;;;CAA6B,CAAA;AAElD,eAAO,MAAM,yBAAyB;;;EAQpC,CAAA;AAEF,eAAO,MAAM,eAAe;;;CAAoC,CAAA;AAEhE,eAAO,MAAM,qBAAqB;;;EAQhC,CAAA;AAEF,eAAO,MAAM,WAAW;;;CAAgC,CAAA;AAExD,eAAO,MAAM,4BAA4B;;;EAQvC,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;CAAuC,CAAA"}

package/dist/expression/basic-expression.js

@@ -1,53 +0,0 @@
-// src/expression/basic-expression.ts
-import { defineExpression } from "@bessemer/cornerstone/expression/internal";
-var LessThanExpression = defineExpression({
-  expressionKey: "Basic.LessThan",
-  builder: (left, right) => {
-    return { left, right };
-  },
-  resolver: ({ left, right }, evaluate) => {
-    return evaluate(left) < evaluate(right);
-  }
-});
-var lessThan = LessThanExpression.builder;
-var LessThanOrEqualExpression = defineExpression({
-  expressionKey: "Basic.LessThanOrEqual",
-  builder: (left, right) => {
-    return { left, right };
-  },
-  resolver: ({ left, right }, evaluate) => {
-    return evaluate(left) <= evaluate(right);
-  }
-});
-var lessThanOrEqual = LessThanOrEqualExpression.builder;
-var GreaterThanExpression = defineExpression({
-  expressionKey: "Basic.GreaterThan",
-  builder: (left, right) => {
-    return { left, right };
-  },
-  resolver: ({ left, right }, evaluate) => {
-    return evaluate(left) > evaluate(right);
-  }
-});
-var greaterThan = GreaterThanExpression.builder;
-var GreaterThanOrEqualExpression = defineExpression({
-  expressionKey: "Basic.GreaterThanOrEqual",
-  builder: (left, right) => {
-    return { left, right };
-  },
-  resolver: ({ left, right }, evaluate) => {
-    return evaluate(left) >= evaluate(right);
-  }
-});
-var greaterThanOrEqual = GreaterThanOrEqualExpression.builder;
-export {
-  GreaterThanExpression,
-  GreaterThanOrEqualExpression,
-  LessThanExpression,
-  LessThanOrEqualExpression,
-  greaterThan,
-  greaterThanOrEqual,
-  lessThan,
-  lessThanOrEqual
-};
-//# sourceMappingURL=basic-expression.js.map

package/dist/expression/basic-expression.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/expression/basic-expression.ts"],"sourcesContent":["import { defineExpression } from '@bessemer/cornerstone/expression/internal'\nimport { Expression } from '@bessemer/cornerstone/expression'\nimport { BasicType } from '@bessemer/cornerstone/types'\n\nexport const LessThanExpression = defineExpression({\n  expressionKey: 'Basic.LessThan',\n  builder: (left: Expression<BasicType>, right: Expression<BasicType>) => {\n    return { left, right }\n  },\n  resolver: ({ left, right }, evaluate) => {\n    return evaluate(left) < evaluate(right)\n  },\n})\n\nexport const lessThan = LessThanExpression.builder\n\nexport const LessThanOrEqualExpression = defineExpression({\n  expressionKey: 'Basic.LessThanOrEqual',\n  builder: (left: Expression<BasicType>, right: Expression<BasicType>) => {\n    return { left, right }\n  },\n  resolver: ({ left, right }, evaluate) => {\n    return evaluate(left) <= evaluate(right)\n  },\n})\n\nexport const lessThanOrEqual = LessThanOrEqualExpression.builder\n\nexport const GreaterThanExpression = defineExpression({\n  expressionKey: 'Basic.GreaterThan',\n  builder: (left: Expression<BasicType>, right: Expression<BasicType>) => {\n    return { left, right }\n  },\n  resolver: ({ left, right }, evaluate) => {\n    return evaluate(left) > evaluate(right)\n  },\n})\n\nexport const greaterThan = GreaterThanExpression.builder\n\nexport const GreaterThanOrEqualExpression = defineExpression({\n  expressionKey: 'Basic.GreaterThanOrEqual',\n  builder: (left: Expression<BasicType>, right: Expression<BasicType>) => {\n    return { left, right }\n  },\n  resolver: ({ left, right }, evaluate) => {\n    return evaluate(left) >= evaluate(right)\n  },\n})\n\nexport const greaterThanOrEqual = GreaterThanOrEqualExpression.builder\n"],"mappings":";AAAA,SAAS,wBAAwB;AAI1B,IAAM,qBAAqB,iBAAiB;AAAA,EACjD,eAAe;AAAA,EACf,SAAS,CAAC,MAA6B,UAAiC;AACtE,WAAO,EAAE,MAAM,MAAM;AAAA,EACvB;AAAA,EACA,UAAU,CAAC,EAAE,MAAM,MAAM,GAAG,aAAa;AACvC,WAAO,SAAS,IAAI,IAAI,SAAS,KAAK;AAAA,EACxC;AACF,CAAC;AAEM,IAAM,WAAW,mBAAmB;AAEpC,IAAM,4BAA4B,iBAAiB;AAAA,EACxD,eAAe;AAAA,EACf,SAAS,CAAC,MAA6B,UAAiC;AACtE,WAAO,EAAE,MAAM,MAAM;AAAA,EACvB;AAAA,EACA,UAAU,CAAC,EAAE,MAAM,MAAM,GAAG,aAAa;AACvC,WAAO,SAAS,IAAI,KAAK,SAAS,KAAK;AAAA,EACzC;AACF,CAAC;AAEM,IAAM,kBAAkB,0BAA0B;AAElD,IAAM,wBAAwB,iBAAiB;AAAA,EACpD,eAAe;AAAA,EACf,SAAS,CAAC,MAA6B,UAAiC;AACtE,WAAO,EAAE,MAAM,MAAM;AAAA,EACvB;AAAA,EACA,UAAU,CAAC,EAAE,MAAM,MAAM,GAAG,aAAa;AACvC,WAAO,SAAS,IAAI,IAAI,SAAS,KAAK;AAAA,EACxC;AACF,CAAC;AAEM,IAAM,cAAc,sBAAsB;AAE1C,IAAM,+BAA+B,iBAAiB;AAAA,EAC3D,eAAe;AAAA,EACf,SAAS,CAAC,MAA6B,UAAiC;AACtE,WAAO,EAAE,MAAM,MAAM;AAAA,EACvB;AAAA,EACA,UAAU,CAAC,EAAE,MAAM,MAAM,GAAG,aAAa;AACvC,WAAO,SAAS,IAAI,KAAK,SAAS,KAAK;AAAA,EACzC;AACF,CAAC;AAEM,IAAM,qBAAqB,6BAA6B;","names":[]}

package/dist/expression/sql-expression-parser.d.ts

@@ -1,8 +0,0 @@
-import { ExpressionMapper } from '@bessemer/cornerstone/expression/expression-mapper';
-import { BasicType, Dictionary } from '@bessemer/cornerstone/types';
-export type SqlExpressionParserContext = {
-    variables: Dictionary<string>;
-    parameters: Dictionary<BasicType>;
-};
-export declare const SqlExpressionParser: ExpressionMapper<string, SqlExpressionParserContext>;
-//# sourceMappingURL=sql-expression-parser.d.ts.map

package/dist/expression/sql-expression-parser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sql-expression-parser.d.ts","sourceRoot":"","sources":["../../src/expression/sql-expression-parser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oDAAoD,CAAA;AAErF,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAInE,MAAM,MAAM,0BAA0B,GAAG;IACvC,SAAS,EAAE,UAAU,CAAC,MAAM,CAAC,CAAA;IAC7B,UAAU,EAAE,UAAU,CAAC,SAAS,CAAC,CAAA;CAClC,CAAA;AACD,eAAO,MAAM,mBAAmB,sDAAkE,CAAA"}

package/dist/expression/sql-expression-parser.js

@@ -1,51 +0,0 @@
-// src/expression/sql-expression-parser.ts
-import { BasicExpressions, Expressions } from "@bessemer/cornerstone/expression";
-import { ExpressionMapper } from "@bessemer/cornerstone/expression/expression-mapper";
-import { Arrays, Objects, Preconditions, Ulids } from "@bessemer/cornerstone";
-var SqlExpressionParser = new ExpressionMapper();
-SqlExpressionParser.register(Expressions.ValueExpression, (expression, _, context) => {
-  const value = expression.value;
-  const parameterName = `_${Ulids.generate()}`;
-  if (!Objects.isBasic(value)) {
-    throw new Error(`Unable to resolve complex ValueExpression as Sql: ${JSON.stringify(value)}`);
-  }
-  context.parameters[parameterName] = value;
-  return `:${parameterName}`;
-});
-SqlExpressionParser.register(Expressions.VariableExpression, (expression, _, context) => {
-  const variableName = context.variables[expression.name];
-  Preconditions.isPresent(variableName, `Unable to resolve VariableExpression with name: ${expression.name}`);
-  return variableName;
-});
-SqlExpressionParser.register(Expressions.NotExpression, (expression, map) => {
-  return `(NOT ${map(expression.value)})`;
-});
-SqlExpressionParser.register(Expressions.AndExpression, (expression, map) => {
-  return `(${expression.operands.map(map).join(" AND ")})`;
-});
-SqlExpressionParser.register(Expressions.OrExpression, (expression, map) => {
-  return `(${expression.operands.map(map).join(" OR ")})`;
-});
-SqlExpressionParser.register(Expressions.EqualsExpression, (expression, map) => {
-  const first = Arrays.first(expression.operands);
-  const rest = Arrays.rest(expression.operands);
-  const mappedFirst = map(first);
-  const equalsExpressions = rest.map((it) => `(${mappedFirst} = ${map(it)})`).join(" AND ");
-  return `(${equalsExpressions})`;
-});
-SqlExpressionParser.register(BasicExpressions.LessThanExpression, (expression, map) => {
-  return `(${map(expression.left)} < ${map(expression.right)})`;
-});
-SqlExpressionParser.register(BasicExpressions.LessThanOrEqualExpression, (expression, map) => {
-  return `(${map(expression.left)} <= ${map(expression.right)})`;
-});
-SqlExpressionParser.register(BasicExpressions.GreaterThanExpression, (expression, map) => {
-  return `(${map(expression.left)} > ${map(expression.right)})`;
-});
-SqlExpressionParser.register(BasicExpressions.GreaterThanOrEqualExpression, (expression, map) => {
-  return `(${map(expression.left)} >= ${map(expression.right)})`;
-});
-export {
-  SqlExpressionParser
-};
-//# sourceMappingURL=sql-expression-parser.js.map

package/dist/expression/sql-expression-parser.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/expression/sql-expression-parser.ts"],"sourcesContent":["import { BasicExpressions, Expressions } from '@bessemer/cornerstone/expression'\nimport { ExpressionMapper } from '@bessemer/cornerstone/expression/expression-mapper'\nimport { Arrays, Objects, Preconditions, Ulids } from '@bessemer/cornerstone'\nimport { BasicType, Dictionary } from '@bessemer/cornerstone/types'\n\n// JOHN need to add tests...\ntype SqlFragment = string\nexport type SqlExpressionParserContext = {\n  variables: Dictionary<string>\n  parameters: Dictionary<BasicType>\n}\nexport const SqlExpressionParser = new ExpressionMapper<SqlFragment, SqlExpressionParserContext>()\n\nSqlExpressionParser.register(Expressions.ValueExpression, (expression, _, context) => {\n  const value = expression.value\n  const parameterName = `_${Ulids.generate()}`\n  if (!Objects.isBasic(value)) {\n    throw new Error(`Unable to resolve complex ValueExpression as Sql: ${JSON.stringify(value)}`)\n  }\n\n  context.parameters[parameterName] = value\n  return `:${parameterName}`\n})\nSqlExpressionParser.register(Expressions.VariableExpression, (expression, _, context) => {\n  const variableName = context.variables[expression.name]\n  Preconditions.isPresent(variableName, `Unable to resolve VariableExpression with name: ${expression.name}`)\n  return variableName\n})\nSqlExpressionParser.register(Expressions.NotExpression, (expression, map) => {\n  return `(NOT ${map(expression.value)})`\n})\nSqlExpressionParser.register(Expressions.AndExpression, (expression, map) => {\n  return `(${expression.operands.map(map).join(' AND ')})`\n})\nSqlExpressionParser.register(Expressions.OrExpression, (expression, map) => {\n  return `(${expression.operands.map(map).join(' OR ')})`\n})\nSqlExpressionParser.register(Expressions.EqualsExpression, (expression, map) => {\n  const first = Arrays.first(expression.operands)!\n  const rest = Arrays.rest(expression.operands)\n\n  const mappedFirst = map(first)\n  const equalsExpressions = rest.map((it) => `(${mappedFirst} = ${map(it)})`).join(' AND ')\n  return `(${equalsExpressions})`\n})\n// SqlExpressionMapper.register(Expressions.ContainsExpression, (expression, map, context) => {\n//   // JOHN incomplete\n//   expression.collection\n//   return `(someVariable IN (${expression.collection}))`\n// })\nSqlExpressionParser.register(BasicExpressions.LessThanExpression, (expression, map) => {\n  return `(${map(expression.left)} < ${map(expression.right)})`\n})\nSqlExpressionParser.register(BasicExpressions.LessThanOrEqualExpression, (expression, map) => {\n  return `(${map(expression.left)} <= ${map(expression.right)})`\n})\nSqlExpressionParser.register(BasicExpressions.GreaterThanExpression, (expression, map) => {\n  return `(${map(expression.left)} > ${map(expression.right)})`\n})\nSqlExpressionParser.register(BasicExpressions.GreaterThanOrEqualExpression, (expression, map) => {\n  return `(${map(expression.left)} >= ${map(expression.right)})`\n})\n"],"mappings":";AAAA,SAAS,kBAAkB,mBAAmB;AAC9C,SAAS,wBAAwB;AACjC,SAAS,QAAQ,SAAS,eAAe,aAAa;AAS/C,IAAM,sBAAsB,IAAI,iBAA0D;AAEjG,oBAAoB,SAAS,YAAY,iBAAiB,CAAC,YAAY,GAAG,YAAY;AACpF,QAAM,QAAQ,WAAW;AACzB,QAAM,gBAAgB,IAAI,MAAM,SAAS,CAAC;AAC1C,MAAI,CAAC,QAAQ,QAAQ,KAAK,GAAG;AAC3B,UAAM,IAAI,MAAM,qDAAqD,KAAK,UAAU,KAAK,CAAC,EAAE;AAAA,EAC9F;AAEA,UAAQ,WAAW,aAAa,IAAI;AACpC,SAAO,IAAI,aAAa;AAC1B,CAAC;AACD,oBAAoB,SAAS,YAAY,oBAAoB,CAAC,YAAY,GAAG,YAAY;AACvF,QAAM,eAAe,QAAQ,UAAU,WAAW,IAAI;AACtD,gBAAc,UAAU,cAAc,mDAAmD,WAAW,IAAI,EAAE;AAC1G,SAAO;AACT,CAAC;AACD,oBAAoB,SAAS,YAAY,eAAe,CAAC,YAAY,QAAQ;AAC3E,SAAO,QAAQ,IAAI,WAAW,KAAK,CAAC;AACtC,CAAC;AACD,oBAAoB,SAAS,YAAY,eAAe,CAAC,YAAY,QAAQ;AAC3E,SAAO,IAAI,WAAW,SAAS,IAAI,GAAG,EAAE,KAAK,OAAO,CAAC;AACvD,CAAC;AACD,oBAAoB,SAAS,YAAY,cAAc,CAAC,YAAY,QAAQ;AAC1E,SAAO,IAAI,WAAW,SAAS,IAAI,GAAG,EAAE,KAAK,MAAM,CAAC;AACtD,CAAC;AACD,oBAAoB,SAAS,YAAY,kBAAkB,CAAC,YAAY,QAAQ;AAC9E,QAAM,QAAQ,OAAO,MAAM,WAAW,QAAQ;AAC9C,QAAM,OAAO,OAAO,KAAK,WAAW,QAAQ;AAE5C,QAAM,cAAc,IAAI,KAAK;AAC7B,QAAM,oBAAoB,KAAK,IAAI,CAAC,OAAO,IAAI,WAAW,MAAM,IAAI,EAAE,CAAC,GAAG,EAAE,KAAK,OAAO;AACxF,SAAO,IAAI,iBAAiB;AAC9B,CAAC;AAMD,oBAAoB,SAAS,iBAAiB,oBAAoB,CAAC,YAAY,QAAQ;AACrF,SAAO,IAAI,IAAI,WAAW,IAAI,CAAC,MAAM,IAAI,WAAW,KAAK,CAAC;AAC5D,CAAC;AACD,oBAAoB,SAAS,iBAAiB,2BAA2B,CAAC,YAAY,QAAQ;AAC5F,SAAO,IAAI,IAAI,WAAW,IAAI,CAAC,OAAO,IAAI,WAAW,KAAK,CAAC;AAC7D,CAAC;AACD,oBAAoB,SAAS,iBAAiB,uBAAuB,CAAC,YAAY,QAAQ;AACxF,SAAO,IAAI,IAAI,WAAW,IAAI,CAAC,MAAM,IAAI,WAAW,KAAK,CAAC;AAC5D,CAAC;AACD,oBAAoB,SAAS,iBAAiB,8BAA8B,CAAC,YAAY,QAAQ;AAC/F,SAAO,IAAI,IAAI,WAAW,IAAI,CAAC,OAAO,IAAI,WAAW,KAAK,CAAC;AAC7D,CAAC;","names":[]}