@bessemer/cornerstone 0.5.60 → 0.5.62

package/dist/async-value.d.ts

@@ -1,23 +1,4 @@
-import Zod, { ZodType } from 'zod';
-export declare const schema: <T>(type: ZodType<T>) => Zod.ZodObject<{
-    isSuccess: Zod.ZodBoolean;
-    isError: Zod.ZodBoolean;
-    isLoading: Zod.ZodBoolean;
-    isFetching: Zod.ZodBoolean;
-    data: Zod.ZodUnion<[Zod.ZodType<T, Zod.ZodTypeDef, T>, Zod.ZodUnknown]>;
-}, "strip", Zod.ZodTypeAny, {
-    isSuccess: boolean;
-    isError: boolean;
-    isLoading: boolean;
-    isFetching: boolean;
-    data?: unknown;
-}, {
-    isSuccess: boolean;
-    isError: boolean;
-    isLoading: boolean;
-    isFetching: boolean;
-    data?: unknown;
-}>;
+import { ZodType } from 'zod';
 export type PendingValue = {
     isSuccess: false;
     isError: false;
@@ -61,6 +42,7 @@ export type SettledValue<T> = {
     data: T;
 };
 export type AsyncValue<T> = PendingValue | LoadingValue | ErrorValue | FetchingValueSuccess<T> | FetchingValueError | SettledValue<T>;
+export declare const schema: <T>(_: ZodType<T>) => ZodType<AsyncValue<T>>;
 export declare const isSettled: <T>(value: AsyncValue<T>) => value is SettledValue<T>;
 export declare const loading: () => LoadingValue;
 export declare const fetching: <T>(data: T) => FetchingValueSuccess<T>;

package/dist/async-value.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"async-value.d.ts","sourceRoot":"","sources":["../src/async-value.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"async-value.d.ts","sourceRoot":"","sources":["../src/async-value.ts"],"names":[],"mappings":"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"}

package/dist/async-value.js

@@ -1,13 +1,13 @@
 // src/async-value.ts
 import Zod from "zod";
 import { Objects } from "@bessemer/cornerstone/index";
-var schema = (type) => {
+var schema = (_) => {
   return Zod.object({
     isSuccess: Zod.boolean(),
     isError: Zod.boolean(),
     isLoading: Zod.boolean(),
     isFetching: Zod.boolean(),
-    data: Zod.union([type, Zod.unknown()])
+    data: Zod.unknown()
   });
 };
 var isSettled = (value) => {

package/dist/async-value.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/async-value.ts"],"sourcesContent":["import Zod, { ZodType } from 'zod'\nimport { Objects } from '@bessemer/cornerstone/index'\n\nexport const schema = <T>(type: ZodType<T>) => {\n  return Zod.object({\n    isSuccess: Zod.boolean(),\n    isError: Zod.boolean(),\n    isLoading: Zod.boolean(),\n    isFetching: Zod.boolean(),\n    data: Zod.union([type, Zod.unknown()]),\n  })\n}\n\nexport type PendingValue = {\n  isSuccess: false\n  isError: false\n  isLoading: false\n  isFetching: boolean\n  data: undefined\n}\n\nexport type LoadingValue = {\n  isSuccess: false\n  isError: false\n  isLoading: true\n  isFetching: boolean\n  data: undefined\n}\n\nexport type ErrorValue = {\n  isSuccess: false\n  isError: true\n  isLoading: false\n  isFetching: boolean\n  data: unknown\n}\n\nexport type FetchingValueSuccess<T> = {\n  isSuccess: true\n  isError: false\n  isLoading: false\n  isFetching: true\n  data: T\n}\n\nexport type FetchingValueError = {\n  isSuccess: false\n  isError: true\n  isLoading: false\n  isFetching: true\n  data: unknown\n}\n\nexport type SettledValue<T> = {\n  isSuccess: true\n  isError: false\n  isLoading: false\n  isFetching: false\n  data: T\n}\n\nexport type AsyncValue<T> = PendingValue | LoadingValue | ErrorValue | FetchingValueSuccess<T> | FetchingValueError | SettledValue<T>\n\nexport const isSettled = <T>(value: AsyncValue<T>): value is SettledValue<T> => {\n  return value.isSuccess && !value.isError && !value.isLoading && !value.isFetching\n}\n\nexport const loading = (): LoadingValue => ({ isSuccess: false, isError: false, isLoading: true, isFetching: true, data: undefined })\n\nexport const fetching = <T>(data: T): FetchingValueSuccess<T> => ({\n  isSuccess: true,\n  isError: false,\n  isLoading: false,\n  isFetching: true,\n  data,\n})\n\nexport const settled = <T>(data: T): SettledValue<T> => ({ isSuccess: true, isError: false, isLoading: false, isFetching: false, data })\n\nexport const error = (error: unknown): ErrorValue => ({ isSuccess: false, isError: true, isLoading: false, isFetching: false, data: error })\n\nexport const handle = <T, N>(\n  value: AsyncValue<T | null>,\n  handlers: { loading: () => N; error: (error: unknown) => N; absent: () => N; success: (data: T) => N }\n): N => {\n  if (value.isLoading || (value.isError && value.isFetching)) {\n    return handlers.loading()\n  }\n  if (value.isError) {\n    return handlers.error(value.data)\n  }\n  if (Objects.isNil(value.data)) {\n    return handlers.absent()\n  }\n\n  return handlers.success(value.data)\n}\n\nexport const map = <T, N>(value: AsyncValue<T>, mapper: (value: T) => N): AsyncValue<N> => {\n  if (!value.isSuccess) {\n    return value\n  }\n\n  return { ...value, data: mapper(value.data) }\n}\n"],"mappings":";AAAA,OAAO,SAAsB;AAC7B,SAAS,eAAe;AAEjB,IAAM,SAAS,CAAI,SAAqB;AAC7C,SAAO,IAAI,OAAO;AAAA,IAChB,WAAW,IAAI,QAAQ;AAAA,IACvB,SAAS,IAAI,QAAQ;AAAA,IACrB,WAAW,IAAI,QAAQ;AAAA,IACvB,YAAY,IAAI,QAAQ;AAAA,IACxB,MAAM,IAAI,MAAM,CAAC,MAAM,IAAI,QAAQ,CAAC,CAAC;AAAA,EACvC,CAAC;AACH;AAoDO,IAAM,YAAY,CAAI,UAAmD;AAC9E,SAAO,MAAM,aAAa,CAAC,MAAM,WAAW,CAAC,MAAM,aAAa,CAAC,MAAM;AACzE;AAEO,IAAM,UAAU,OAAqB,EAAE,WAAW,OAAO,SAAS,OAAO,WAAW,MAAM,YAAY,MAAM,MAAM,OAAU;AAE5H,IAAM,WAAW,CAAI,UAAsC;AAAA,EAChE,WAAW;AAAA,EACX,SAAS;AAAA,EACT,WAAW;AAAA,EACX,YAAY;AAAA,EACZ;AACF;AAEO,IAAM,UAAU,CAAI,UAA8B,EAAE,WAAW,MAAM,SAAS,OAAO,WAAW,OAAO,YAAY,OAAO,KAAK;AAE/H,IAAM,QAAQ,CAACA,YAAgC,EAAE,WAAW,OAAO,SAAS,MAAM,WAAW,OAAO,YAAY,OAAO,MAAMA,OAAM;AAEnI,IAAM,SAAS,CACpB,OACA,aACM;AACN,MAAI,MAAM,aAAc,MAAM,WAAW,MAAM,YAAa;AAC1D,WAAO,SAAS,QAAQ;AAAA,EAC1B;AACA,MAAI,MAAM,SAAS;AACjB,WAAO,SAAS,MAAM,MAAM,IAAI;AAAA,EAClC;AACA,MAAI,QAAQ,MAAM,MAAM,IAAI,GAAG;AAC7B,WAAO,SAAS,OAAO;AAAA,EACzB;AAEA,SAAO,SAAS,QAAQ,MAAM,IAAI;AACpC;AAEO,IAAM,MAAM,CAAO,OAAsB,WAA2C;AACzF,MAAI,CAAC,MAAM,WAAW;AACpB,WAAO;AAAA,EACT;AAEA,SAAO,EAAE,GAAG,OAAO,MAAM,OAAO,MAAM,IAAI,EAAE;AAC9C;","names":["error"]}
+{"version":3,"sources":["../src/async-value.ts"],"sourcesContent":["import Zod, { ZodType } from 'zod'\nimport { Objects } from '@bessemer/cornerstone/index'\n\nexport type PendingValue = {\n  isSuccess: false\n  isError: false\n  isLoading: false\n  isFetching: boolean\n  data: undefined\n}\n\nexport type LoadingValue = {\n  isSuccess: false\n  isError: false\n  isLoading: true\n  isFetching: boolean\n  data: undefined\n}\n\nexport type ErrorValue = {\n  isSuccess: false\n  isError: true\n  isLoading: false\n  isFetching: boolean\n  data: unknown\n}\n\nexport type FetchingValueSuccess<T> = {\n  isSuccess: true\n  isError: false\n  isLoading: false\n  isFetching: true\n  data: T\n}\n\nexport type FetchingValueError = {\n  isSuccess: false\n  isError: true\n  isLoading: false\n  isFetching: true\n  data: unknown\n}\n\nexport type SettledValue<T> = {\n  isSuccess: true\n  isError: false\n  isLoading: false\n  isFetching: false\n  data: T\n}\n\nexport type AsyncValue<T> = PendingValue | LoadingValue | ErrorValue | FetchingValueSuccess<T> | FetchingValueError | SettledValue<T>\n\nexport const schema = <T>(_: ZodType<T>): ZodType<AsyncValue<T>> => {\n  return Zod.object({\n    isSuccess: Zod.boolean(),\n    isError: Zod.boolean(),\n    isLoading: Zod.boolean(),\n    isFetching: Zod.boolean(),\n    data: Zod.unknown(),\n  }) as any\n}\n\nexport const isSettled = <T>(value: AsyncValue<T>): value is SettledValue<T> => {\n  return value.isSuccess && !value.isError && !value.isLoading && !value.isFetching\n}\n\nexport const loading = (): LoadingValue => ({ isSuccess: false, isError: false, isLoading: true, isFetching: true, data: undefined })\n\nexport const fetching = <T>(data: T): FetchingValueSuccess<T> => ({\n  isSuccess: true,\n  isError: false,\n  isLoading: false,\n  isFetching: true,\n  data,\n})\n\nexport const settled = <T>(data: T): SettledValue<T> => ({ isSuccess: true, isError: false, isLoading: false, isFetching: false, data })\n\nexport const error = (error: unknown): ErrorValue => ({ isSuccess: false, isError: true, isLoading: false, isFetching: false, data: error })\n\nexport const handle = <T, N>(\n  value: AsyncValue<T | null>,\n  handlers: { loading: () => N; error: (error: unknown) => N; absent: () => N; success: (data: T) => N }\n): N => {\n  if (value.isLoading || (value.isError && value.isFetching)) {\n    return handlers.loading()\n  }\n  if (value.isError) {\n    return handlers.error(value.data)\n  }\n  if (Objects.isNil(value.data)) {\n    return handlers.absent()\n  }\n\n  return handlers.success(value.data)\n}\n\nexport const map = <T, N>(value: AsyncValue<T>, mapper: (value: T) => N): AsyncValue<N> => {\n  if (!value.isSuccess) {\n    return value\n  }\n\n  return { ...value, data: mapper(value.data) }\n}\n"],"mappings":";AAAA,OAAO,SAAsB;AAC7B,SAAS,eAAe;AAoDjB,IAAM,SAAS,CAAI,MAA0C;AAClE,SAAO,IAAI,OAAO;AAAA,IAChB,WAAW,IAAI,QAAQ;AAAA,IACvB,SAAS,IAAI,QAAQ;AAAA,IACrB,WAAW,IAAI,QAAQ;AAAA,IACvB,YAAY,IAAI,QAAQ;AAAA,IACxB,MAAM,IAAI,QAAQ;AAAA,EACpB,CAAC;AACH;AAEO,IAAM,YAAY,CAAI,UAAmD;AAC9E,SAAO,MAAM,aAAa,CAAC,MAAM,WAAW,CAAC,MAAM,aAAa,CAAC,MAAM;AACzE;AAEO,IAAM,UAAU,OAAqB,EAAE,WAAW,OAAO,SAAS,OAAO,WAAW,MAAM,YAAY,MAAM,MAAM,OAAU;AAE5H,IAAM,WAAW,CAAI,UAAsC;AAAA,EAChE,WAAW;AAAA,EACX,SAAS;AAAA,EACT,WAAW;AAAA,EACX,YAAY;AAAA,EACZ;AACF;AAEO,IAAM,UAAU,CAAI,UAA8B,EAAE,WAAW,MAAM,SAAS,OAAO,WAAW,OAAO,YAAY,OAAO,KAAK;AAE/H,IAAM,QAAQ,CAACA,YAAgC,EAAE,WAAW,OAAO,SAAS,MAAM,WAAW,OAAO,YAAY,OAAO,MAAMA,OAAM;AAEnI,IAAM,SAAS,CACpB,OACA,aACM;AACN,MAAI,MAAM,aAAc,MAAM,WAAW,MAAM,YAAa;AAC1D,WAAO,SAAS,QAAQ;AAAA,EAC1B;AACA,MAAI,MAAM,SAAS;AACjB,WAAO,SAAS,MAAM,MAAM,IAAI;AAAA,EAClC;AACA,MAAI,QAAQ,MAAM,MAAM,IAAI,GAAG;AAC7B,WAAO,SAAS,OAAO;AAAA,EACzB;AAEA,SAAO,SAAS,QAAQ,MAAM,IAAI;AACpC;AAEO,IAAM,MAAM,CAAO,OAAsB,WAA2C;AACzF,MAAI,CAAC,MAAM,WAAW;AACpB,WAAO;AAAA,EACT;AAEA,SAAO,EAAE,GAAG,OAAO,MAAM,OAAO,MAAM,IAAI,EAAE;AAC9C;","names":["error"]}

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

@@ -1,9 +1,12 @@
 import { Expression } from '@bessemer/cornerstone/expression';
 import { BasicType } from '@bessemer/cornerstone/types';
 import { Signatures } from '@bessemer/cornerstone';
+import { Result } from '@bessemer/cornerstone/result';
 export declare const ValueExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<unknown, [value: unknown], {
     value: unknown;
 }>;
+export declare const isValue: <T>(expression: Expression<T>) => boolean;
+export declare const getValue: <T>(expression: Expression<T>) => Result<T>;
 export declare const VariableExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<{}, [name: string], Expression<{}> & {
     name: string;
 }>;

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

@@ -1 +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,EAA+B,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAG/E,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"}
+{"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,EAA+B,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAE/E,OAAO,EAAW,MAAM,EAAW,MAAM,8BAA8B,CAAA;AAEvE,eAAO,MAAM,eAAe;;EAQ1B,CAAA;AAEF,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,YAAY,UAAU,CAAC,CAAC,CAAC,KAAG,OAEtD,CAAA;AAED,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,YAAY,UAAU,CAAC,CAAC,CAAC,KAAG,MAAM,CAAC,CAAC,CAQ/D,CAAA;AAED,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

@@ -1,6 +1,7 @@
 // src/expression/core-expression.ts
-import { defineExpression } from "@bessemer/cornerstone/expression/internal";
+import { defineExpression, isRawValue, isType } from "@bessemer/cornerstone/expression/internal";
 import { Arrays, Assertions, Objects, Signatures } from "@bessemer/cornerstone";
+import { failure, success } from "@bessemer/cornerstone/result";
 var ValueExpression = defineExpression({
   expressionKey: "Value",
   builder: (value) => {
@@ -10,6 +11,18 @@ var ValueExpression = defineExpression({
     return value;
   }
 });
+var isValue = (expression) => {
+  return isRawValue(expression) || isType(expression, ValueExpression);
+};
+var getValue = (expression) => {
+  if (isType(expression, ValueExpression)) {
+    return success(expression.value);
+  } else if (isRawValue(expression)) {
+    return success(expression);
+  } else {
+    return failure();
+  }
+};
 var VariableExpression = defineExpression({
   expressionKey: "Variable",
   builder: (name) => {
@@ -124,6 +137,8 @@ export {
   NotExpression,
   OrExpression,
   ValueExpression,
-  VariableExpression
+  VariableExpression,
+  getValue,
+  isValue
 };
 //# sourceMappingURL=core-expression.js.map

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

@@ -1 +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, Assertions, Objects, 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    Assertions.assertPresent(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":[]}
+{"version":3,"sources":["../../src/expression/core-expression.ts"],"sourcesContent":["import { defineExpression, isRawValue, isType } from '@bessemer/cornerstone/expression/internal'\nimport { Expression } from '@bessemer/cornerstone/expression'\nimport { BasicType } from '@bessemer/cornerstone/types'\nimport { Arrays, Assertions, Objects, Signatures } from '@bessemer/cornerstone'\nimport { Signable } from '@bessemer/cornerstone/signature'\nimport { failure, Result, success } from '@bessemer/cornerstone/result'\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 isValue = <T>(expression: Expression<T>): boolean => {\n  return isRawValue(expression) || isType(expression, ValueExpression)\n}\n\nexport const getValue = <T>(expression: Expression<T>): Result<T> => {\n  if (isType(expression, ValueExpression)) {\n    return success(expression.value as T)\n  } else if (isRawValue(expression)) {\n    return success(expression)\n  } else {\n    return failure()\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    Assertions.assertPresent(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-evaluator.js

@@ -1,12 +1,12 @@
 // src/expression/expression-evaluator.ts
 import { Assertions } from "@bessemer/cornerstone";
-import { isValue } from "@bessemer/cornerstone/expression/internal";
+import { isRawValue } from "@bessemer/cornerstone/expression/internal";
 var ExpressionEvaluator = class {
   constructor(expressionDefinitions) {
     this.expressionDefinitions = expressionDefinitions;
   }
   evaluate(expression, context) {
-    if (isValue(expression)) {
+    if (isRawValue(expression)) {
       return expression;
     }
     const matchingExpressionDefinition = this.expressionDefinitions.find((it) => it.expressionKey === expression.expressionKey);

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

@@ -1 +1 @@
-{"version":3,"sources":["../../src/expression/expression-evaluator.ts"],"sourcesContent":["import { Expression, ExpressionContext, ExpressionDefinition, ExpressionReference } from '@bessemer/cornerstone/expression'\nimport { Assertions } from '@bessemer/cornerstone'\nimport { isValue } from '@bessemer/cornerstone/expression/internal'\n\n// JOHN need to add tests...\nexport class ExpressionEvaluator {\n  constructor(private readonly expressionDefinitions: Array<ExpressionDefinition<unknown, Array<any>, Expression<any>>>) {}\n\n  evaluate<T>(expression: Expression<T>, context: ExpressionContext): T {\n    if (isValue(expression)) {\n      return expression\n    }\n\n    const matchingExpressionDefinition = this.expressionDefinitions.find((it) => it.expressionKey === expression.expressionKey)\n    Assertions.assertPresent(matchingExpressionDefinition)\n    return matchingExpressionDefinition.resolver(expression, (expression) => this.evaluate(expression, context), context) as T\n  }\n\n  dereference<ReturnType, ArgumentType extends Array<unknown>>(\n    reference: ExpressionReference<ReturnType, ArgumentType>,\n    ...args: ArgumentType\n  ): Expression<ReturnType> {\n    const matchingExpressionDefinition = this.expressionDefinitions.find((it) => it.expressionKey === reference.expressionKey)\n    Assertions.assertPresent(matchingExpressionDefinition, () => `Unable to find Expression Definition for type: ${reference.expressionKey}`)\n    return matchingExpressionDefinition.builder(...args)\n  }\n}\n"],"mappings":";AACA,SAAS,kBAAkB;AAC3B,SAAS,eAAe;AAGjB,IAAM,sBAAN,MAA0B;AAAA,EAC/B,YAA6B,uBAA0F;AAA1F;AAAA,EAA2F;AAAA,EAExH,SAAY,YAA2B,SAA+B;AACpE,QAAI,QAAQ,UAAU,GAAG;AACvB,aAAO;AAAA,IACT;AAEA,UAAM,+BAA+B,KAAK,sBAAsB,KAAK,CAAC,OAAO,GAAG,kBAAkB,WAAW,aAAa;AAC1H,eAAW,cAAc,4BAA4B;AACrD,WAAO,6BAA6B,SAAS,YAAY,CAACA,gBAAe,KAAK,SAASA,aAAY,OAAO,GAAG,OAAO;AAAA,EACtH;AAAA,EAEA,YACE,cACG,MACqB;AACxB,UAAM,+BAA+B,KAAK,sBAAsB,KAAK,CAAC,OAAO,GAAG,kBAAkB,UAAU,aAAa;AACzH,eAAW,cAAc,8BAA8B,MAAM,kDAAkD,UAAU,aAAa,EAAE;AACxI,WAAO,6BAA6B,QAAQ,GAAG,IAAI;AAAA,EACrD;AACF;","names":["expression"]}
+{"version":3,"sources":["../../src/expression/expression-evaluator.ts"],"sourcesContent":["import { Expression, ExpressionContext, ExpressionDefinition, ExpressionReference } from '@bessemer/cornerstone/expression'\nimport { Assertions } from '@bessemer/cornerstone'\nimport { isRawValue } from '@bessemer/cornerstone/expression/internal'\n\n// JOHN need to add tests...\nexport class ExpressionEvaluator {\n  constructor(private readonly expressionDefinitions: Array<ExpressionDefinition<unknown, Array<any>, Expression<any>>>) {}\n\n  evaluate<T>(expression: Expression<T>, context: ExpressionContext): T {\n    if (isRawValue(expression)) {\n      return expression\n    }\n\n    const matchingExpressionDefinition = this.expressionDefinitions.find((it) => it.expressionKey === expression.expressionKey)\n    Assertions.assertPresent(matchingExpressionDefinition)\n    return matchingExpressionDefinition.resolver(expression, (expression) => this.evaluate(expression, context), context) as T\n  }\n\n  dereference<ReturnType, ArgumentType extends Array<unknown>>(\n    reference: ExpressionReference<ReturnType, ArgumentType>,\n    ...args: ArgumentType\n  ): Expression<ReturnType> {\n    const matchingExpressionDefinition = this.expressionDefinitions.find((it) => it.expressionKey === reference.expressionKey)\n    Assertions.assertPresent(matchingExpressionDefinition, () => `Unable to find Expression Definition for type: ${reference.expressionKey}`)\n    return matchingExpressionDefinition.builder(...args)\n  }\n}\n"],"mappings":";AACA,SAAS,kBAAkB;AAC3B,SAAS,kBAAkB;AAGpB,IAAM,sBAAN,MAA0B;AAAA,EAC/B,YAA6B,uBAA0F;AAA1F;AAAA,EAA2F;AAAA,EAExH,SAAY,YAA2B,SAA+B;AACpE,QAAI,WAAW,UAAU,GAAG;AAC1B,aAAO;AAAA,IACT;AAEA,UAAM,+BAA+B,KAAK,sBAAsB,KAAK,CAAC,OAAO,GAAG,kBAAkB,WAAW,aAAa;AAC1H,eAAW,cAAc,4BAA4B;AACrD,WAAO,6BAA6B,SAAS,YAAY,CAACA,gBAAe,KAAK,SAASA,aAAY,OAAO,GAAG,OAAO;AAAA,EACtH;AAAA,EAEA,YACE,cACG,MACqB;AACxB,UAAM,+BAA+B,KAAK,sBAAsB,KAAK,CAAC,OAAO,GAAG,kBAAkB,UAAU,aAAa;AACzH,eAAW,cAAc,8BAA8B,MAAM,kDAAkD,UAAU,aAAa,EAAE;AACxI,WAAO,6BAA6B,QAAQ,GAAG,IAAI;AAAA,EACrD;AACF;","names":["expression"]}

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

@@ -1,9 +1,8 @@
 import { Expression, ExpressionDefinition } from '@bessemer/cornerstone/expression';
-type ExpressionResolver<ExpressionType, MappingType, ContextType> = (expression: ExpressionType, map: (expression: Expression<unknown>) => MappingType, context: ContextType) => MappingType;
+export type ExpressionResolver<ExpressionType, MappingType, ContextType> = (expression: ExpressionType, map: (expression: Expression<unknown>) => MappingType, context: ContextType) => MappingType;
 export declare class ExpressionMapper<MappingType, ContextType> {
     private readonly resolverMap;
     map(expression: Expression<unknown>, context: ContextType): MappingType;
     register<ExpressionType>(definition: ExpressionDefinition<any, any, ExpressionType>, resolver: ExpressionResolver<ExpressionType, MappingType, ContextType>): void;
 }
-export {};
 //# sourceMappingURL=expression-mapper.d.ts.map

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;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;IAuBvE,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,MAAM,MAAM,kBAAkB,CAAC,cAAc,EAAE,WAAW,EAAE,WAAW,IAAI,CACzE,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;IAuBvE,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.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 { Assertions } 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      Assertions.assertPresent(\n        resolver,\n        () =>\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      Assertions.assertPresent(\n        resolver,\n        () =>\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,kBAAkB;AAC3B,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,iBAAW;AAAA,QACT;AAAA,QACA,MACE,2DAA2D,WAAW,aAAa;AAAA,MACvF;AAEA,aAAO,SAAS,YAAY,CAACA,gBAAe,KAAK,IAAIA,aAAY,OAAO,GAAG,OAAO;AAAA,IACpF,OAAO;AACL,YAAM,WAAW,KAAK,YAAY,gBAAgB,aAAa;AAC/D,iBAAW;AAAA,QACT;AAAA,QACA,MACE,2DAA2D,gBAAgB,aAAa;AAAA,MAC5F;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 { Assertions } from '@bessemer/cornerstone'\nimport { value } from '@bessemer/cornerstone/expression/expression'\nimport { ValueExpression } from '@bessemer/cornerstone/expression/core-expression'\n\nexport type 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      Assertions.assertPresent(\n        resolver,\n        () =>\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      Assertions.assertPresent(\n        resolver,\n        () =>\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,kBAAkB;AAC3B,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,iBAAW;AAAA,QACT;AAAA,QACA,MACE,2DAA2D,WAAW,aAAa;AAAA,MACvF;AAEA,aAAO,SAAS,YAAY,CAACA,gBAAe,KAAK,IAAIA,aAAY,OAAO,GAAG,OAAO;AAAA,IACpF,OAAO;AACL,YAAM,WAAW,KAAK,YAAY,gBAAgB,aAAa;AAC/D,iBAAW;AAAA,QACT;AAAA,QACA,MACE,2DAA2D,gBAAgB,aAAa;AAAA,MAC5F;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/internal.d.ts

@@ -7,5 +7,5 @@ export declare const defineExpression: <ReturnType, ArgumentType extends Array<u
 }) => ExpressionDefinition<ReturnType, ArgumentType, Expression<ReturnType> & PayloadType>;
 export declare const isType: <ReturnValue, ArgumentType extends Array<any>, ExpressionType extends Expression<ReturnValue>>(expression: Expression<ReturnValue>, expressionDefinition: ExpressionDefinition<ReturnValue, ArgumentType, ExpressionType>) => expression is ReturnType<(typeof expressionDefinition)["builder"]>;
 export declare const isExpression: <T>(expression: Expression<any>) => expression is IExpression<T>;
-export declare const isValue: <T>(expression: Expression<T>) => expression is T;
+export declare const isRawValue: <T>(expression: Expression<T>) => expression is T;
 //# sourceMappingURL=internal.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../src/expression/internal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,UAAU,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAA;AAEtJ,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAEzC,eAAO,MAAM,gBAAgB,GAAI,UAAU,EAAE,YAAY,SAAS,KAAK,CAAC,OAAO,CAAC,EAAE,WAAW,SAAS,aAAa,EAAE,SAAS;IAC5H,aAAa,EAAE,aAAa,CAAC,UAAU,EAAE,YAAY,CAAC,CAAA;IACtD,OAAO,EAAE,CAAC,GAAG,UAAU,EAAE,YAAY,KAAK,WAAW,CAAA;IACrD,QAAQ,EAAE,CAAC,UAAU,EAAE,WAAW,EAAE,QAAQ,EAAE,kBAAkB,EAAE,OAAO,EAAE,iBAAiB,KAAK,UAAU,CAAA;CAC5G,KAAG,oBAAoB,CAAC,UAAU,EAAE,YAAY,EAAE,UAAU,CAAC,UAAU,CAAC,GAAG,WAAW,CAUtF,CAAA;AAED,eAAO,MAAM,MAAM,GAAI,WAAW,EAAE,YAAY,SAAS,KAAK,CAAC,GAAG,CAAC,EAAE,cAAc,SAAS,UAAU,CAAC,WAAW,CAAC,EACjH,YAAY,UAAU,CAAC,WAAW,CAAC,EACnC,sBAAsB,oBAAoB,CAAC,WAAW,EAAE,YAAY,EAAE,cAAc,CAAC,KACpF,UAAU,IAAI,UAAU,CAAC,CAAA,OAAO,oBAAoB,EAAC,SAAS,CAAC,CAMjE,CAAA;AAED,eAAO,MAAM,YAAY,GAAI,CAAC,EAAE,YAAY,UAAU,CAAC,GAAG,CAAC,KAAG,UAAU,IAAI,WAAW,CAAC,CAAC,CAExF,CAAA;AAED,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,YAAY,UAAU,CAAC,CAAC,CAAC,KAAG,UAAU,IAAI,CAOpE,CAAA"}
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../src/expression/internal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,UAAU,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAA;AACtJ,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAGzC,eAAO,MAAM,gBAAgB,GAAI,UAAU,EAAE,YAAY,SAAS,KAAK,CAAC,OAAO,CAAC,EAAE,WAAW,SAAS,aAAa,EAAE,SAAS;IAC5H,aAAa,EAAE,aAAa,CAAC,UAAU,EAAE,YAAY,CAAC,CAAA;IACtD,OAAO,EAAE,CAAC,GAAG,UAAU,EAAE,YAAY,KAAK,WAAW,CAAA;IACrD,QAAQ,EAAE,CAAC,UAAU,EAAE,WAAW,EAAE,QAAQ,EAAE,kBAAkB,EAAE,OAAO,EAAE,iBAAiB,KAAK,UAAU,CAAA;CAC5G,KAAG,oBAAoB,CAAC,UAAU,EAAE,YAAY,EAAE,UAAU,CAAC,UAAU,CAAC,GAAG,WAAW,CAUtF,CAAA;AAED,eAAO,MAAM,MAAM,GAAI,WAAW,EAAE,YAAY,SAAS,KAAK,CAAC,GAAG,CAAC,EAAE,cAAc,SAAS,UAAU,CAAC,WAAW,CAAC,EACjH,YAAY,UAAU,CAAC,WAAW,CAAC,EACnC,sBAAsB,oBAAoB,CAAC,WAAW,EAAE,YAAY,EAAE,cAAc,CAAC,KACpF,UAAU,IAAI,UAAU,CAAC,CAAA,OAAO,oBAAoB,EAAC,SAAS,CAAC,CAMjE,CAAA;AAED,eAAO,MAAM,YAAY,GAAI,CAAC,EAAE,YAAY,UAAU,CAAC,GAAG,CAAC,KAAG,UAAU,IAAI,WAAW,CAAC,CAAC,CAExF,CAAA;AAED,eAAO,MAAM,UAAU,GAAI,CAAC,EAAE,YAAY,UAAU,CAAC,CAAC,CAAC,KAAG,UAAU,IAAI,CAOvE,CAAA"}

package/dist/expression/internal.js

@@ -1,5 +1,5 @@
 // src/expression/internal.ts
-import { Objects } from "@bessemer/cornerstone";
+import { isObject } from "@bessemer/cornerstone/object";
 var defineExpression = (options) => {
   return {
     expressionKey: options.expressionKey,
@@ -18,10 +18,10 @@ var isType = (expression, expressionDefinition) => {
   return expression.expressionKey === expressionDefinition.expressionKey;
 };
 var isExpression = (expression) => {
-  return Objects.isObject(expression) && "expressionKey" in expression;
+  return isObject(expression) && "expressionKey" in expression;
 };
-var isValue = (expression) => {
-  if (!Objects.isObject(expression)) {
+var isRawValue = (expression) => {
+  if (!isObject(expression)) {
     return true;
   }
   const result = expression.expressionKey === void 0;
@@ -30,7 +30,7 @@ var isValue = (expression) => {
 export {
   defineExpression,
   isExpression,
-  isType,
-  isValue
+  isRawValue,
+  isType
 };
 //# sourceMappingURL=internal.js.map

package/dist/expression/internal.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/expression/internal.ts"],"sourcesContent":["import { EvaluateExpression, Expression, ExpressionContext, ExpressionDefinition, ExpressionKey, IExpression } from '@bessemer/cornerstone/expression'\nimport { Objects } from '@bessemer/cornerstone'\nimport { UnknownRecord } from 'type-fest'\n\nexport const defineExpression = <ReturnType, ArgumentType extends Array<unknown>, PayloadType extends UnknownRecord>(options: {\n  expressionKey: ExpressionKey<ReturnType, ArgumentType>\n  builder: (...parameters: ArgumentType) => PayloadType\n  resolver: (expression: PayloadType, evaluate: EvaluateExpression, context: ExpressionContext) => ReturnType\n}): ExpressionDefinition<ReturnType, ArgumentType, Expression<ReturnType> & PayloadType> => {\n  return {\n    expressionKey: options.expressionKey,\n    builder: (...parameters) => {\n      return { expressionKey: options.expressionKey, ...options.builder(...parameters) }\n    },\n    resolver: (expression, evaluate, context) => {\n      return options.resolver(expression as any, evaluate, context)\n    },\n  }\n}\n\nexport const isType = <ReturnValue, ArgumentType extends Array<any>, ExpressionType extends Expression<ReturnValue>>(\n  expression: Expression<ReturnValue>,\n  expressionDefinition: ExpressionDefinition<ReturnValue, ArgumentType, ExpressionType>\n): expression is ReturnType<typeof expressionDefinition['builder']> => {\n  if (!isExpression(expression)) {\n    return false\n  }\n\n  return expression.expressionKey === expressionDefinition.expressionKey\n}\n\nexport const isExpression = <T>(expression: Expression<any>): expression is IExpression<T> => {\n  return Objects.isObject(expression) && 'expressionKey' in expression\n}\n\nexport const isValue = <T>(expression: Expression<T>): expression is T => {\n  if (!Objects.isObject(expression)) {\n    return true\n  }\n\n  const result = (expression as unknown as IExpression<T>).expressionKey === undefined\n  return result\n}\n"],"mappings":";AACA,SAAS,eAAe;AAGjB,IAAM,mBAAmB,CAAqF,YAIzB;AAC1F,SAAO;AAAA,IACL,eAAe,QAAQ;AAAA,IACvB,SAAS,IAAI,eAAe;AAC1B,aAAO,EAAE,eAAe,QAAQ,eAAe,GAAG,QAAQ,QAAQ,GAAG,UAAU,EAAE;AAAA,IACnF;AAAA,IACA,UAAU,CAAC,YAAY,UAAU,YAAY;AAC3C,aAAO,QAAQ,SAAS,YAAmB,UAAU,OAAO;AAAA,IAC9D;AAAA,EACF;AACF;AAEO,IAAM,SAAS,CACpB,YACA,yBACqE;AACrE,MAAI,CAAC,aAAa,UAAU,GAAG;AAC7B,WAAO;AAAA,EACT;AAEA,SAAO,WAAW,kBAAkB,qBAAqB;AAC3D;AAEO,IAAM,eAAe,CAAI,eAA8D;AAC5F,SAAO,QAAQ,SAAS,UAAU,KAAK,mBAAmB;AAC5D;AAEO,IAAM,UAAU,CAAI,eAA+C;AACxE,MAAI,CAAC,QAAQ,SAAS,UAAU,GAAG;AACjC,WAAO;AAAA,EACT;AAEA,QAAM,SAAU,WAAyC,kBAAkB;AAC3E,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../../src/expression/internal.ts"],"sourcesContent":["import { EvaluateExpression, Expression, ExpressionContext, ExpressionDefinition, ExpressionKey, IExpression } from '@bessemer/cornerstone/expression'\nimport { UnknownRecord } from 'type-fest'\nimport { isObject } from '@bessemer/cornerstone/object'\n\nexport const defineExpression = <ReturnType, ArgumentType extends Array<unknown>, PayloadType extends UnknownRecord>(options: {\n  expressionKey: ExpressionKey<ReturnType, ArgumentType>\n  builder: (...parameters: ArgumentType) => PayloadType\n  resolver: (expression: PayloadType, evaluate: EvaluateExpression, context: ExpressionContext) => ReturnType\n}): ExpressionDefinition<ReturnType, ArgumentType, Expression<ReturnType> & PayloadType> => {\n  return {\n    expressionKey: options.expressionKey,\n    builder: (...parameters) => {\n      return { expressionKey: options.expressionKey, ...options.builder(...parameters) }\n    },\n    resolver: (expression, evaluate, context) => {\n      return options.resolver(expression as any, evaluate, context)\n    },\n  }\n}\n\nexport const isType = <ReturnValue, ArgumentType extends Array<any>, ExpressionType extends Expression<ReturnValue>>(\n  expression: Expression<ReturnValue>,\n  expressionDefinition: ExpressionDefinition<ReturnValue, ArgumentType, ExpressionType>\n): expression is ReturnType<typeof expressionDefinition['builder']> => {\n  if (!isExpression(expression)) {\n    return false\n  }\n\n  return expression.expressionKey === expressionDefinition.expressionKey\n}\n\nexport const isExpression = <T>(expression: Expression<any>): expression is IExpression<T> => {\n  return isObject(expression) && 'expressionKey' in expression\n}\n\nexport const isRawValue = <T>(expression: Expression<T>): expression is T => {\n  if (!isObject(expression)) {\n    return true\n  }\n\n  const result = (expression as unknown as IExpression<T>).expressionKey === undefined\n  return result\n}\n"],"mappings":";AAEA,SAAS,gBAAgB;AAElB,IAAM,mBAAmB,CAAqF,YAIzB;AAC1F,SAAO;AAAA,IACL,eAAe,QAAQ;AAAA,IACvB,SAAS,IAAI,eAAe;AAC1B,aAAO,EAAE,eAAe,QAAQ,eAAe,GAAG,QAAQ,QAAQ,GAAG,UAAU,EAAE;AAAA,IACnF;AAAA,IACA,UAAU,CAAC,YAAY,UAAU,YAAY;AAC3C,aAAO,QAAQ,SAAS,YAAmB,UAAU,OAAO;AAAA,IAC9D;AAAA,EACF;AACF;AAEO,IAAM,SAAS,CACpB,YACA,yBACqE;AACrE,MAAI,CAAC,aAAa,UAAU,GAAG;AAC7B,WAAO;AAAA,EACT;AAEA,SAAO,WAAW,kBAAkB,qBAAqB;AAC3D;AAEO,IAAM,eAAe,CAAI,eAA8D;AAC5F,SAAO,SAAS,UAAU,KAAK,mBAAmB;AACpD;AAEO,IAAM,aAAa,CAAI,eAA+C;AAC3E,MAAI,CAAC,SAAS,UAAU,GAAG;AACzB,WAAO;AAAA,EACT;AAEA,QAAM,SAAU,WAAyC,kBAAkB;AAC3E,SAAO;AACT;","names":[]}

package/dist/signature.d.ts

@@ -1,10 +1,10 @@
 import { Reference } from '@bessemer/cornerstone/reference';
 import { BasicType } from '@bessemer/cornerstone/types';
-export type Signable = BasicType | {
+export type Signable = BasicType | null | {
     id: string;
 } | {
     reference: Reference<string>;
 };
-export declare const sign: (value: Signable) => string | number;
-export declare const signAll: (values: Array<Signable>) => Array<string | number>;
+export declare const sign: (value: Signable) => string | number | null;
+export declare const signAll: (values: Array<Signable>) => Array<string | number | null>;
 //# sourceMappingURL=signature.d.ts.map

package/dist/signature.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signature.d.ts","sourceRoot":"","sources":["../src/signature.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAA;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAA;AAKvD,MAAM,MAAM,QAAQ,GAAG,SAAS,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,SAAS,EAAE,SAAS,CAAC,MAAM,CAAC,CAAA;CAAE,CAAA;AAEpF,eAAO,MAAM,IAAI,GAAI,OAAO,QAAQ,KAAG,MAAM,GAAG,MAqB/C,CAAA;AAED,eAAO,MAAM,OAAO,GAAI,QAAQ,KAAK,CAAC,QAAQ,CAAC,KAAG,KAAK,CAAC,MAAM,GAAG,MAAM,CAEtE,CAAA"}
+{"version":3,"file":"signature.d.ts","sourceRoot":"","sources":["../src/signature.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAA;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAA;AAKvD,MAAM,MAAM,QAAQ,GAAG,SAAS,GAAG,IAAI,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,SAAS,EAAE,SAAS,CAAC,MAAM,CAAC,CAAA;CAAE,CAAA;AAE3F,eAAO,MAAM,IAAI,GAAI,OAAO,QAAQ,KAAG,MAAM,GAAG,MAAM,GAAG,IAyBxD,CAAA;AAED,eAAO,MAAM,OAAO,GAAI,QAAQ,KAAK,CAAC,QAAQ,CAAC,KAAG,KAAK,CAAC,MAAM,GAAG,MAAM,GAAG,IAAI,CAE7E,CAAA"}

package/dist/signature.js

@@ -1,6 +1,9 @@
 // src/signature.ts
 import { Dates, Objects, References } from "@bessemer/cornerstone";
 var sign = (value) => {
+  if (value === null) {
+    return null;
+  }
   if (Objects.isObject(value)) {
     if (References.isReferencable(value)) {
       return value.reference.id;

package/dist/signature.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/signature.ts"],"sourcesContent":["import { Dates, Objects, References } from '@bessemer/cornerstone'\nimport { Reference } from '@bessemer/cornerstone/reference'\nimport { BasicType } from '@bessemer/cornerstone/types'\n\n// JOHN it is probably worth revisiting this in the context of using this library code more frequently... in particular\n// all of these things have similar properties (\"primitives\", sortable, value equality, etc.) but this method of implementation\n// forces them all to be converted to strings or numbers first which is an expensive operation.\nexport type Signable = BasicType | { id: string } | { reference: Reference<string> }\n\nexport const sign = (value: Signable): string | number => {\n  if (Objects.isObject(value)) {\n    if (References.isReferencable(value)) {\n      return value.reference.id\n    } else {\n      return value.id\n    }\n  }\n\n  if (Dates.isDate(value)) {\n    return value.getTime()\n  }\n\n  if (value === true) {\n    return 1\n  }\n  if (value === false) {\n    return 0\n  }\n\n  return value\n}\n\nexport const signAll = (values: Array<Signable>): Array<string | number> => {\n  return values.map(sign)\n}\n"],"mappings":";AAAA,SAAS,OAAO,SAAS,kBAAkB;AASpC,IAAM,OAAO,CAAC,UAAqC;AACxD,MAAI,QAAQ,SAAS,KAAK,GAAG;AAC3B,QAAI,WAAW,eAAe,KAAK,GAAG;AACpC,aAAO,MAAM,UAAU;AAAA,IACzB,OAAO;AACL,aAAO,MAAM;AAAA,IACf;AAAA,EACF;AAEA,MAAI,MAAM,OAAO,KAAK,GAAG;AACvB,WAAO,MAAM,QAAQ;AAAA,EACvB;AAEA,MAAI,UAAU,MAAM;AAClB,WAAO;AAAA,EACT;AACA,MAAI,UAAU,OAAO;AACnB,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAEO,IAAM,UAAU,CAAC,WAAoD;AAC1E,SAAO,OAAO,IAAI,IAAI;AACxB;","names":[]}
+{"version":3,"sources":["../src/signature.ts"],"sourcesContent":["import { Dates, Objects, References } from '@bessemer/cornerstone'\nimport { Reference } from '@bessemer/cornerstone/reference'\nimport { BasicType } from '@bessemer/cornerstone/types'\n\n// JOHN it is probably worth revisiting this in the context of using this library code more frequently... in particular\n// all of these things have similar properties (\"primitives\", sortable, value equality, etc.) but this method of implementation\n// forces them all to be converted to strings or numbers first which is an expensive operation.\nexport type Signable = BasicType | null | { id: string } | { reference: Reference<string> }\n\nexport const sign = (value: Signable): string | number | null => {\n  if (value === null) {\n    return null\n  }\n\n  if (Objects.isObject(value)) {\n    if (References.isReferencable(value)) {\n      return value.reference.id\n    } else {\n      return value.id\n    }\n  }\n\n  if (Dates.isDate(value)) {\n    return value.getTime()\n  }\n\n  if (value === true) {\n    return 1\n  }\n  if (value === false) {\n    return 0\n  }\n\n  return value\n}\n\nexport const signAll = (values: Array<Signable>): Array<string | number | null> => {\n  return values.map(sign)\n}\n"],"mappings":";AAAA,SAAS,OAAO,SAAS,kBAAkB;AASpC,IAAM,OAAO,CAAC,UAA4C;AAC/D,MAAI,UAAU,MAAM;AAClB,WAAO;AAAA,EACT;AAEA,MAAI,QAAQ,SAAS,KAAK,GAAG;AAC3B,QAAI,WAAW,eAAe,KAAK,GAAG;AACpC,aAAO,MAAM,UAAU;AAAA,IACzB,OAAO;AACL,aAAO,MAAM;AAAA,IACf;AAAA,EACF;AAEA,MAAI,MAAM,OAAO,KAAK,GAAG;AACvB,WAAO,MAAM,QAAQ;AAAA,EACvB;AAEA,MAAI,UAAU,MAAM;AAClB,WAAO;AAAA,EACT;AACA,MAAI,UAAU,OAAO;AACnB,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAEO,IAAM,UAAU,CAAC,WAA2D;AACjF,SAAO,OAAO,IAAI,IAAI;AACxB;","names":[]}

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

@@ -1 +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"}
+{"version":3,"file":"sql-expression-parser.d.ts","sourceRoot":"","sources":["../../src/sql/sql-expression-parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAsB,MAAM,oDAAoD,CAAA;AAEzG,OAAO,EAAa,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAgBnE,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;AAwCrG,eAAO,MAAM,0BAA0B,qBAA4B,CAAA"}

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

@@ -5,6 +5,7 @@ import {
   AndExpression,
   ContainsExpression,
   EqualsExpression,
+  getValue,
   GreaterThanExpression,
   GreaterThanOrEqualExpression,
   LessThanExpression,
@@ -14,9 +15,30 @@ import {
   ValueExpression,
   VariableExpression
 } from "@bessemer/cornerstone/expression/core-expression";
-import { isType, isValue } from "@bessemer/cornerstone/expression/internal";
+import { isType } from "@bessemer/cornerstone/expression/internal";
 var SqlExpressionParser = class extends ExpressionMapper {
 };
+var resolveContainsExpression = (expression, map, context) => {
+  const collection = expression.collection;
+  const parsedValue = getValue(collection);
+  if (!parsedValue.isSuccess) {
+    throw new Error(`SqlExpressionParser - Unable to resolve ContainsExpression with non-value collection: ${JSON.stringify(collection)}`);
+  }
+  const value = parsedValue.value;
+  value.forEach((it) => {
+    if (!Objects.isBasic(it)) {
+      throw new Error(`SqlExpressionParser - Unable to resolve complex ValueExpression as Sql: ${JSON.stringify(it)}`);
+    }
+  });
+  const parameters = value.map((it) => Entries.of(`_${Ulids.generate()}`, it));
+  parameters.forEach(([key, value2]) => {
+    context.parameters[key] = value2;
+  });
+  const containsExpression = expression.operands.map(map).map(
+    (sql) => `(${sql} IN (${Entries.keys(parameters).map((it) => `:${it}`).join(",")}))`
+  ).join(" AND ");
+  return `(${containsExpression})`;
+};
 var DefaultSqlExpressionParser = new SqlExpressionParser();
 DefaultSqlExpressionParser.register(ValueExpression, (expression, _, context) => {
   const value = expression.value;
@@ -33,28 +55,7 @@ DefaultSqlExpressionParser.register(VariableExpression, (expression, _, context)
 });
 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 parameters = value.map((it) => Entries.of(`_${Ulids.generate()}`, it));
-    parameters.forEach(([key, value2]) => {
-      context.parameters[key] = value2;
-    });
-    const containsExpression = expression.value.operands.map(map).map(
-      (sql) => `(${sql} NOT IN (${Entries.keys(parameters).map((it) => `:${it}`).join(",")}))`
-    ).join(" AND ");
-    return `(${containsExpression})`;
+    return resolveContainsExpression(expression.value, map, context);
   } else {
     return `(NOT ${map(expression.value)})`;
   }
@@ -69,33 +70,21 @@ 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 equalsExpressions = rest.map((it) => {
+    const parsedValue = getValue(it);
+    if (parsedValue.isSuccess) {
+      if (parsedValue.value === null) {
+        return `(${mappedFirst} IS NULL)`;
+      } else {
+        return `(${mappedFirst} = ${map(it)})`;
+      }
+    } else {
+      return `(${mappedFirst} = ${map(it)})`;
     }
-  });
-  const parameters = value.map((it) => Entries.of(`_${Ulids.generate()}`, it));
-  parameters.forEach(([key, value2]) => {
-    context.parameters[key] = value2;
-  });
-  const containsExpression = expression.operands.map(map).map(
-    (sql) => `(${sql} IN (${Entries.keys(parameters).map((it) => `:${it}`).join(",")}))`
-  ).join(" AND ");
-  return `(${containsExpression})`;
+  }).join(" AND ");
+  return `(${equalsExpressions})`;
 });
+DefaultSqlExpressionParser.register(ContainsExpression, resolveContainsExpression);
 DefaultSqlExpressionParser.register(LessThanExpression, (expression, map) => {
   return `(${map(expression.left)} < ${map(expression.right)})`;
 });

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

@@ -1 +1 @@
-{"version":3,"sources":["../../src/sql/sql-expression-parser.ts"],"sourcesContent":["import { ExpressionMapper } from '@bessemer/cornerstone/expression/expression-mapper'\nimport { Arrays, Entries, Objects, 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  return variableName ?? expression.name\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 parameters = value.map((it) => Entries.of(`_${Ulids.generate()}`, it))\n    parameters.forEach(([key, value]) => {\n      context.parameters[key] = value\n    })\n\n    const containsExpression = expression.value.operands\n      .map(map)\n      .map(\n        (sql) =>\n          `(${sql} NOT IN (${Entries.keys(parameters)\n            .map((it) => `:${it}`)\n            .join(',')}))`\n      )\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 parameters = value.map((it) => Entries.of(`_${Ulids.generate()}`, it))\n  parameters.forEach(([key, value]) => {\n    context.parameters[key] = value\n  })\n\n  const containsExpression = expression.operands\n    .map(map)\n    .map(\n      (sql) =>\n        `(${sql} IN (${Entries.keys(parameters)\n          .map((it) => `:${it}`)\n          .join(',')}))`\n    )\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":["value"]}
+{"version":3,"sources":["../../src/sql/sql-expression-parser.ts"],"sourcesContent":["import { ExpressionMapper, ExpressionResolver } from '@bessemer/cornerstone/expression/expression-mapper'\nimport { Arrays, Entries, Objects, Ulids } from '@bessemer/cornerstone'\nimport { BasicType, Dictionary } from '@bessemer/cornerstone/types'\nimport {\n  AndExpression,\n  ContainsExpression,\n  EqualsExpression,\n  getValue,\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 } 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\n// JOHN should be easier to define this type\nconst resolveContainsExpression: ExpressionResolver<ReturnType<typeof ContainsExpression.builder>, SqlFragment, SqlExpressionParserContext> = (\n  expression,\n  map,\n  context\n) => {\n  const collection = expression.collection\n\n  const parsedValue = getValue(collection)\n  if (!parsedValue.isSuccess) {\n    throw new Error(`SqlExpressionParser - Unable to resolve ContainsExpression with non-value collection: ${JSON.stringify(collection)}`)\n  }\n  const value = parsedValue.value as Array<BasicType>\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 parameters = value.map((it) => Entries.of(`_${Ulids.generate()}`, it))\n  parameters.forEach(([key, value]) => {\n    context.parameters[key] = value\n  })\n\n  const containsExpression = expression.operands\n    .map(map)\n    .map(\n      (sql) =>\n        `(${sql} IN (${Entries.keys(parameters)\n          .map((it) => `:${it}`)\n          .join(',')}))`\n    )\n    .join(' AND ')\n\n  return `(${containsExpression})`\n}\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  return variableName ?? expression.name\n})\nDefaultSqlExpressionParser.register(NotExpression, (expression, map, context) => {\n  if (isType(expression.value, ContainsExpression)) {\n    return resolveContainsExpression(expression.value, map, context)\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\n    .map((it) => {\n      const parsedValue = getValue(it)\n      if (parsedValue.isSuccess) {\n        if (parsedValue.value === null) {\n          return `(${mappedFirst} IS NULL)`\n        } else {\n          return `(${mappedFirst} = ${map(it)})`\n        }\n      } else {\n        return `(${mappedFirst} = ${map(it)})`\n      }\n    })\n    .join(' AND ')\n  return `(${equalsExpressions})`\n})\nDefaultSqlExpressionParser.register(ContainsExpression, resolveContainsExpression)\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":["value"]}

package/package.json

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