effect-qb 0.12.3

package/src/internal/grouping-key.ts

@@ -0,0 +1,82 @@
+import * as Expression from "./expression.js"
+import * as ExpressionAst from "./expression-ast.js"
+
+const literalGroupingKey = (value: unknown): string => {
+  if (value instanceof Date) {
+    return `date:${value.toISOString()}`
+  }
+  if (value === null) {
+    return "null"
+  }
+  switch (typeof value) {
+    case "string":
+      return `string:${JSON.stringify(value)}`
+    case "number":
+      return `number:${value}`
+    case "boolean":
+      return `boolean:${value}`
+    default:
+      return `literal:${JSON.stringify(value)}`
+  }
+}
+
+export const groupingKeyOfExpression = (expression: Expression.Any): string => {
+  const ast = (expression as Expression.Any & {
+    readonly [ExpressionAst.TypeId]: ExpressionAst.Any
+  })[ExpressionAst.TypeId]
+  switch (ast.kind) {
+    case "column":
+      return `column:${ast.tableName}.${ast.columnName}`
+    case "literal":
+      return `literal:${literalGroupingKey(ast.value)}`
+    case "cast":
+      return `cast(${groupingKeyOfExpression(ast.value)} as ${ast.target.dialect}:${ast.target.kind})`
+    case "isNull":
+    case "isNotNull":
+    case "not":
+    case "upper":
+    case "lower":
+    case "count":
+    case "max":
+    case "min":
+      return `${ast.kind}(${groupingKeyOfExpression(ast.value)})`
+    case "eq":
+    case "neq":
+    case "lt":
+    case "lte":
+    case "gt":
+    case "gte":
+    case "like":
+    case "ilike":
+    case "isDistinctFrom":
+    case "isNotDistinctFrom":
+      return `${ast.kind}(${groupingKeyOfExpression(ast.left)},${groupingKeyOfExpression(ast.right)})`
+    case "and":
+    case "or":
+    case "coalesce":
+    case "concat":
+    case "in":
+    case "notIn":
+    case "between":
+      return `${ast.kind}(${ast.values.map(groupingKeyOfExpression).join(",")})`
+    case "case":
+      return `case(${ast.branches.map((branch: ExpressionAst.CaseBranchNode) =>
+        `when:${groupingKeyOfExpression(branch.when)}=>${groupingKeyOfExpression(branch.then)}`).join("|")};else:${groupingKeyOfExpression(ast.else)})`
+    default:
+      throw new Error("Unsupported expression for grouping key generation")
+  }
+}
+
+export const dedupeGroupedExpressions = <Values extends readonly Expression.Any[]>(
+  values: Values
+): Values => {
+  const seen = new Set<string>()
+  return values.filter((value) => {
+    const key = groupingKeyOfExpression(value)
+    if (seen.has(key)) {
+      return false
+    }
+    seen.add(key)
+    return true
+  }) as unknown as Values
+}

package/src/internal/json/ast.ts

@@ -0,0 +1,63 @@
+import type * as Expression from ".././expression.js"
+import type * as JsonPath from "./path.js"
+
+export type JsonKind =
+  | "jsonGet"
+  | "jsonPath"
+  | "jsonAccess"
+  | "jsonTraverse"
+  | "jsonGetText"
+  | "jsonPathText"
+  | "jsonAccessText"
+  | "jsonTraverseText"
+  | "jsonHasKey"
+  | "jsonKeyExists"
+  | "jsonHasAnyKeys"
+  | "jsonHasAllKeys"
+  | "jsonConcat"
+  | "jsonMerge"
+  | "jsonDelete"
+  | "jsonDeletePath"
+  | "jsonRemove"
+  | "jsonSet"
+  | "jsonInsert"
+  | "jsonPathExists"
+  | "jsonPathMatch"
+  | "jsonBuildObject"
+  | "jsonBuildArray"
+  | "jsonToJson"
+  | "jsonToJsonb"
+  | "jsonTypeOf"
+  | "jsonLength"
+  | "jsonKeys"
+  | "jsonStripNulls"
+
+/**
+ * Broad JSON AST node accepted by the renderer.
+ *
+ * The JSON subsystem is intentionally shaped as a small grammar rather than a
+ * collection of bespoke node interfaces. The renderer uses the `kind` plus the
+ * common field names below to lower the nodes into dialect SQL.
+ */
+export interface JsonNode<
+  Kind extends JsonKind = JsonKind
+> {
+  readonly kind: Kind
+  readonly value?: Expression.Any
+  readonly base?: Expression.Any
+  readonly left?: Expression.Any
+  readonly right?: Expression.Any
+  readonly path?: JsonPath.Path<any> | readonly any[]
+  readonly segments?: readonly any[]
+  readonly keys?: readonly string[]
+  readonly query?: string | Expression.Any
+  readonly newValue?: Expression.Any
+  readonly insert?: Expression.Any
+  readonly createMissing?: boolean
+  readonly insertAfter?: boolean
+  readonly entries?: readonly {
+    readonly key: string
+    readonly value: Expression.Any
+  }[]
+  readonly values?: readonly Expression.Any[]
+}

package/src/internal/json/errors.ts

@@ -0,0 +1,13 @@
+export type JsonPathUsageError<
+  Operation extends string,
+  Root,
+  Path,
+  Reason extends string
+> = {
+  readonly __effect_qb_error__: "effect-qb: invalid json path usage"
+  readonly __effect_qb_json_operation__: Operation
+  readonly __effect_qb_json_reason__: Reason
+  readonly __effect_qb_json_root__: Root
+  readonly __effect_qb_json_path__: Path
+  readonly __effect_qb_hint__: "Use key(...) on objects, index(...) on arrays, and prefer exact key/index paths when you want precise output typing"
+}

package/src/internal/json/path.ts

@@ -0,0 +1,227 @@
+import type * as Expression from ".././expression.js"
+import type { JsonPathUsageError } from "./errors.js"
+import type {
+  JsonBuildArray as JsonBuildArrayResult,
+  JsonBuildObject as JsonBuildObjectResult,
+  JsonConcatResult,
+  JsonDeleteAtPath,
+  JsonInsertAtPath,
+  JsonLiteralInput,
+  JsonStripNullsResult as JsonStripNullsResultValue,
+  JsonValueAtPath,
+  JsonSetAtPath
+} from "./types.js"
+import type { JsonKeysResult as JsonKeysResultValue, JsonLengthResult as JsonLengthResultValue, JsonTextResult as JsonTextResultValue, JsonTypeName as JsonTypeNameValue } from "./types.js"
+
+export const SegmentTypeId: unique symbol = Symbol.for("effect-qb/JsonPathSegment")
+
+export type SegmentTypeId = typeof SegmentTypeId
+
+export const TypeId: unique symbol = Symbol.for("effect-qb/JsonPath")
+
+export type TypeId = typeof TypeId
+
+type SegmentState<Kind extends string> = {
+  readonly kind: Kind
+}
+
+export interface KeySegment<Key extends string = string> {
+  readonly [SegmentTypeId]: SegmentState<"key">
+  readonly kind: "key"
+  readonly key: Key
+}
+
+export interface IndexSegment<Index extends number = number> {
+  readonly [SegmentTypeId]: SegmentState<"index">
+  readonly kind: "index"
+  readonly index: Index
+}
+
+export interface WildcardSegment {
+  readonly [SegmentTypeId]: SegmentState<"wildcard">
+  readonly kind: "wildcard"
+}
+
+export interface SliceSegment<
+  Start extends number | undefined = number | undefined,
+  End extends number | undefined = number | undefined
+> {
+  readonly [SegmentTypeId]: SegmentState<"slice">
+  readonly kind: "slice"
+  readonly start: Start
+  readonly end: End
+}
+
+export interface DescendSegment {
+  readonly [SegmentTypeId]: SegmentState<"descend">
+  readonly kind: "descend"
+}
+
+export type CanonicalSegment =
+  | KeySegment
+  | IndexSegment
+  | WildcardSegment
+  | SliceSegment
+  | DescendSegment
+
+export type AnySegment = any
+
+export type ExactSegment = KeySegment | IndexSegment
+
+type PathState<Segments extends readonly CanonicalSegment[]> = {
+  readonly segments: Segments
+}
+
+export interface Path<Segments extends readonly CanonicalSegment[] = readonly CanonicalSegment[]> {
+  readonly [TypeId]: PathState<Segments>
+  readonly segments: Segments
+}
+
+export type JsonPath<Segments extends readonly CanonicalSegment[] = readonly CanonicalSegment[]> = Path<Segments>
+
+export type JsonPathSegments = readonly CanonicalSegment[]
+
+export type JsonPrimitive = JsonLiteralInput
+
+export type JsonLiteral = JsonLiteralInput
+
+export type JsonInput = Expression.Any | JsonLiteral
+
+const makeSegment = <Segment extends CanonicalSegment>(segment: Segment): Segment => segment
+
+export const key = <Key extends string>(value: Key): KeySegment<Key> =>
+  makeSegment({
+    [SegmentTypeId]: {
+      kind: "key"
+    },
+    kind: "key",
+    key: value
+  } as KeySegment<Key>)
+
+export const index = <Index extends number>(value: Index): IndexSegment<Index> =>
+  makeSegment({
+    [SegmentTypeId]: {
+      kind: "index"
+    },
+    kind: "index",
+    index: value
+  } as IndexSegment<Index>)
+
+export const wildcard = (): WildcardSegment =>
+  makeSegment({
+    [SegmentTypeId]: {
+      kind: "wildcard"
+    },
+    kind: "wildcard"
+  })
+
+export const slice = <
+  Start extends number | undefined = undefined,
+  End extends number | undefined = undefined
+>(
+  start?: Start,
+  end?: End
+): SliceSegment<Start, End> =>
+  makeSegment({
+    [SegmentTypeId]: {
+      kind: "slice"
+    },
+    kind: "slice",
+    start: start as Start,
+    end: end as End
+  } as SliceSegment<Start, End>)
+
+export const descend = (): DescendSegment =>
+  makeSegment({
+    [SegmentTypeId]: {
+      kind: "descend"
+    },
+    kind: "descend"
+  })
+
+export const path = <Segments extends readonly CanonicalSegment[]>(
+  ...segments: Segments
+): Path<Segments> => ({
+  [TypeId]: {
+    segments
+  },
+  segments
+})
+
+export const makeJsonPath = path
+
+export type SegmentsOf<Value extends Path<any>> = Value[typeof TypeId]["segments"]
+
+export type IsExactSegment<Segment extends CanonicalSegment> = Segment extends ExactSegment ? true : false
+
+export type IsExactPath<PathValue extends Path<any>> =
+  SegmentsOf<PathValue> extends readonly [infer Head extends CanonicalSegment, ...infer Tail extends readonly CanonicalSegment[]]
+    ? IsExactSegment<Head> extends true
+      ? Tail extends readonly []
+        ? true
+        : IsExactPath<Path<Tail>>
+      : false
+    : true
+
+export type JsonPathValue<
+  Root,
+  PathValue extends Path<any>,
+  Operation extends string = "json.get"
+> = JsonValueAtPath<Root, PathValue, Operation>
+
+export type JsonPathOutput<
+  Root,
+  PathValue extends Path<any>,
+  Operation extends string = "json.get"
+> = JsonValueAtPath<Root, PathValue, Operation>
+
+export type JsonPathCompatible<
+  Root,
+  PathValue extends Path<any>,
+  Operation extends string = "json.get"
+> = JsonValueAtPath<Root, PathValue, Operation> extends JsonPathUsageError<any, any, any, any>
+  ? JsonValueAtPath<Root, PathValue, Operation>
+  : PathValue
+
+export type JsonPathUpdate<
+  Root,
+  PathValue extends Path<any>,
+  Next,
+  Operation extends string = "json.set"
+> = JsonSetAtPath<Root, PathValue, Next, Operation>
+
+export type JsonPathDelete<
+  Root,
+  PathValue extends Path<any>,
+  Operation extends string = "json.delete"
+> = JsonDeleteAtPath<Root, PathValue, Operation>
+
+export type JsonConcat<
+  Left,
+  Right
+> = JsonConcatResult<Left, Right>
+
+export type JsonBuildObject<
+  Shape extends Record<string, JsonInput>
+> = JsonBuildObjectResult<Shape>
+
+export type JsonBuildArray<
+  Values extends readonly JsonInput[]
+> = JsonBuildArrayResult<Values>
+
+export type JsonTextResult<Value> = JsonTextResultValue<Value>
+
+export type JsonTypeName<Value> = JsonTypeNameValue<Value>
+
+export type JsonLengthResult<Value> = JsonLengthResultValue<Value>
+
+export type JsonKeysResult<Value> = JsonKeysResultValue<Value>
+
+export type JsonStripNullsResult<Value> = JsonStripNullsResultValue<Value>
+
+export type JsonValueOfInput<Input> =
+  Input extends Expression.Any
+    ? Expression.RuntimeOf<Input>
+    : Input extends JsonLiteral
+      ? Input
+      : never

package/src/internal/json/shape.ts

@@ -0,0 +1 @@
+export type JsonShape = Record<string, unknown> | readonly unknown[] | string | number | boolean | null