effect 4.0.0-beta.99 → 4.0.0-rc.108

package/src/JsonPatch.ts

@@ -7,9 +7,8 @@
  *
  * @since 4.0.0
  */
-import { format } from "./Formatter.ts"
+import * as InternalRecord from "./internal/record.ts"
 import { escapeToken, unescapeToken } from "./JsonPointer.ts"
-import * as Predicate from "./Predicate.ts"
 import type * as Schema from "./Schema.ts"
 
 /**
@@ -31,7 +30,7 @@ import type * as Schema from "./Schema.ts"
  *
  * **Example** (Defining all operation types)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { JsonPatch } from "effect"
  *
  * const addOp: JsonPatch.JsonPatchOperation = {
@@ -50,6 +49,8 @@ import type * as Schema from "./Schema.ts"
  *   path: "/users/0/name",
  *   value: "Bob"
  * }
+ *
+ * Array.of(addOp.op, removeOp.op, replaceOp.op) // => ["add", "remove", "replace"]
  * ```
  *
  * @see {@link JsonPatch} for the array of operations forming a complete patch
@@ -115,7 +116,7 @@ export type JsonPatchOperation =
  *
  * **Example** (Defining a multi-operation patch)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { JsonPatch } from "effect"
  *
  * const patch: JsonPatch.JsonPatch = [
@@ -124,8 +125,7 @@ export type JsonPatchOperation =
  *   { op: "remove", path: "/oldField" }
  * ]
  *
- * const result = JsonPatch.apply(patch, { count: 3, oldField: "value" })
- * // { count: 5, items: ["apple"] }
+ * JsonPatch.apply(patch, { items: [], count: 3, oldField: "value" }) // => { items: ["apple"], count: 5 }
  * ```
  *
  * @see {@link JsonPatchOperation} for individual operation types
@@ -160,18 +160,16 @@ export type JsonPatch = ReadonlyArray<JsonPatchOperation>
  *
  * **Example** (Computing object diff)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { JsonPatch } from "effect"
  *
  * const oldValue = { users: [{ id: 1, name: "Alice" }], count: 1 }
  * const newValue = { users: [{ id: 1, name: "Bob" }, { id: 2, name: "Charlie" }], count: 2 }
  *
  * const patch = JsonPatch.get(oldValue, newValue)
- * // [
- * //   { op: "replace", path: "/users/0/name", value: "Bob" },
- * //   { op: "add", path: "/users/1", value: { id: 2, name: "Charlie" } },
- * //   { op: "replace", path: "/count", value: 2 }
- * // ]
+ * patch[0] // => { op: "replace", path: "/count", value: 2 }
+ * patch[1] // => { op: "replace", path: "/users/0/name", value: "Bob" }
+ * patch[2] // => { op: "add", path: "/users/1", value: { id: 2, name: "Charlie" } }
  * ```
  *
  * @see {@link apply} to apply the generated patch to a document
@@ -180,9 +178,18 @@ export type JsonPatch = ReadonlyArray<JsonPatchOperation>
  * @since 4.0.0
  */
 export function get(oldValue: Schema.Json, newValue: Schema.Json): JsonPatch {
-  if (Object.is(oldValue, newValue)) return []
   const patches: Array<JsonPatchOperation> = []
+  getLoop(oldValue, newValue, "", patches)
+  return patches
+}
 
+function getLoop(
+  oldValue: Schema.Json,
+  newValue: Schema.Json,
+  path: string,
+  patches: Array<JsonPatchOperation>
+): void {
+  if (Object.is(oldValue, newValue)) return
   if (Array.isArray(oldValue) && Array.isArray(newValue)) {
     const len1 = oldValue.length
     const len2 = newValue.length
@@ -190,25 +197,20 @@ export function get(oldValue: Schema.Json, newValue: Schema.Json): JsonPatch {
     // Compare shared prefix by index
     const shared = Math.min(len1, len2)
     for (let i = 0; i < shared; i++) {
-      const path = `/${i}`
-      const patch = get(oldValue[i], newValue[i])
-      for (const op of patch) {
-        prefixPathInPlace(op, path)
-        patches.push(op)
-      }
+      getLoop(oldValue[i], newValue[i], `${path}/${i}`, patches)
     }
 
     // Remove from end to start so later indices do not shift.
     for (let i = len1 - 1; i >= len2; i--) {
-      patches.push({ op: "remove", path: `/${i}` })
+      patches.push({ op: "remove", path: `${path}/${i}` })
     }
 
     // Add from beginning to end.
     for (let i = len1; i < len2; i++) {
-      patches.push({ op: "add", path: `/${i}`, value: newValue[i] })
+      patches.push({ op: "add", path: `${path}/${i}`, value: newValue[i] })
     }
 
-    return patches
+    return
   }
 
   if (isJsonObject(oldValue) && isJsonObject(newValue)) {
@@ -217,29 +219,23 @@ export function get(oldValue: Schema.Json, newValue: Schema.Json): JsonPatch {
     const allKeys = Array.from(new Set([...keys1, ...keys2])).sort()
 
     for (const key of allKeys) {
-      const esc = escapeToken(key)
-      const path = `/${esc}`
+      const keyPath = `${path}/${escapeToken(key)}`
       const hasKey1 = Object.hasOwn(oldValue, key)
       const hasKey2 = Object.hasOwn(newValue, key)
 
       if (hasKey1 && hasKey2) {
-        const patch = get(oldValue[key], newValue[key])
-        for (const op of patch) {
-          prefixPathInPlace(op, path)
-          patches.push(op)
-        }
+        getLoop(oldValue[key], newValue[key], keyPath, patches)
       } else if (!hasKey1 && hasKey2) {
-        patches.push({ op: "add", path, value: newValue[key] })
-      } else if (hasKey1 && !hasKey2) {
-        patches.push({ op: "remove", path })
+        patches.push({ op: "add", path: keyPath, value: newValue[key] })
+      } else {
+        patches.push({ op: "remove", path: keyPath })
       }
     }
 
-    return patches
+    return
   }
 
-  patches.push({ op: "replace", path: "", value: newValue })
-  return patches
+  patches.push({ op: "replace", path, value: newValue })
 }
 
 /**
@@ -266,7 +262,7 @@ export function get(oldValue: Schema.Json, newValue: Schema.Json): JsonPatch {
  *
  * **Example** (Applying a patch)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { JsonPatch } from "effect"
  *
  * const document = { items: [1, 2, 3], total: 6 }
@@ -275,8 +271,7 @@ export function get(oldValue: Schema.Json, newValue: Schema.Json): JsonPatch {
  *   { op: "replace", path: "/total", value: 10 }
  * ]
  *
- * const result = JsonPatch.apply(patch, document)
- * // { items: [1, 2, 3, 4], total: 10 }
+ * JsonPatch.apply(patch, document) // => { items: [1, 2, 3, 4], total: 10 }
  * ```
  *
  * @see {@link get} to generate patches from value differences
@@ -288,32 +283,14 @@ export function apply(patch: JsonPatch, oldValue: Schema.Json): Schema.Json {
   let doc = oldValue
 
   for (const op of patch) {
-    switch (op.op) {
-      case "replace": {
-        doc = op.path === "" ? op.value : setAt(doc, op.path, op.value, "replace")
-        break
-      }
-      case "add": {
-        doc = addAt(doc, op.path, op.value)
-        break
-      }
-      case "remove": {
-        doc = setAt(doc, op.path, undefined, "remove")
-        break
-      }
-    }
+    doc = applyOperation(doc, op)
   }
 
   return doc
 }
 
-// Mutates op.path in place for perf; safe because child ops are freshly created and not shared.
-function prefixPathInPlace(op: JsonPatchOperation, parent: string): void {
-  ;(op as any).path = op.path === "" ? parent : parent + op.path
-}
-
 function isJsonObject(value: unknown): value is Schema.JsonObject {
-  return Predicate.isObject(value)
+  return typeof value === "object" && value !== null && !Array.isArray(value)
 }
 
 /**
@@ -325,7 +302,7 @@ function isJsonObject(value: unknown): value is Schema.JsonObject {
 function tokenize(pointer: string): Array<string> {
   if (pointer === "") return []
   if (pointer.charCodeAt(0) !== 47 /* "/" */) {
-    throw new Error(`Invalid JSON Pointer, it must start with "/": ${format(pointer)}`)
+    throw new Error(`Invalid JSON Pointer, it must start with "/": ${JSON.stringify(pointer)}`)
   }
   return pointer.split("/").slice(1).map(unescapeToken)
 }
@@ -338,72 +315,44 @@ function toIndex(token: string): number {
   return Number(token)
 }
 
-function addAt(doc: Schema.Json, pointer: string, val: Schema.Json): Schema.Json {
-  if (pointer === "") return val
-
-  const resolved = resolveParent(doc, pointer)
-  if (resolved === null) {
-    throw new Error(`Cannot add at "${pointer}" (parent not found or not a container).`)
-  }
-
-  const { lastToken, parent, stack } = resolved
-
-  if (Array.isArray(parent)) {
-    const idx = lastToken === "-" ? parent.length : toIndex(lastToken)
-    if (idx < 0 || idx > parent.length) throw new Error(`Array index out of bounds at "${pointer}".`)
-    const updated = parent.slice()
-    updated.splice(idx, 0, val)
-    return rebuildFromStack(stack, updated)
-  }
-
-  if (isJsonObject(parent)) {
-    const updated = { ...parent }
-    updated[lastToken] = val
-    return rebuildFromStack(stack, updated)
-  }
-
-  throw new Error(`Cannot add at "${pointer}" (parent not found or not a container).`)
-}
-
-function setAt(
-  doc: Schema.Json,
-  pointer: string,
-  val: Schema.Json | undefined,
-  mode: "replace" | "remove"
-): Schema.Json {
-  if (pointer === "") {
-    if (mode === "remove" || val === undefined) throw new Error("Unsupported operation at the root")
-    return val
+function applyOperation(doc: Schema.Json, op: JsonPatchOperation): Schema.Json {
+  if (op.path === "") {
+    if (op.op === "remove") throw new Error("Unsupported operation at the root")
+    return op.value
   }
 
-  const resolved = resolveParent(doc, pointer)
+  const resolved = resolveParent(doc, op.path)
   if (resolved === null) {
-    throw new Error(`Cannot ${mode} at "${pointer}" (parent not found or not a container).`)
+    throw new Error(`Cannot ${op.op} at "${op.path}" (parent not found or not a container).`)
   }
 
   const { lastToken, parent, stack } = resolved
 
   if (Array.isArray(parent)) {
-    if (lastToken === "-") throw new Error(`"-" is not valid for ${mode} at "${pointer}".`)
-    const idx = toIndex(lastToken)
-    if (idx < 0 || idx >= parent.length) throw new Error(`Array index out of bounds at "${pointer}".`)
+    if (lastToken === "-" && op.op !== "add") {
+      throw new Error(`"-" is not valid for ${op.op} at "${op.path}".`)
+    }
+    const index = lastToken === "-" ? parent.length : toIndex(lastToken)
+    const maxIndex = op.op === "add" ? parent.length : parent.length - 1
+    if (index > maxIndex) throw new Error(`Array index out of bounds at "${op.path}".`)
     const updated = parent.slice()
-    if (mode === "remove") updated.splice(idx, 1)
-    else updated[idx] = val
+    if (op.op === "add") updated.splice(index, 0, op.value)
+    else if (op.op === "remove") updated.splice(index, 1)
+    else updated[index] = op.value
     return rebuildFromStack(stack, updated)
   }
 
   if (isJsonObject(parent)) {
-    if (!Object.hasOwn(parent, lastToken)) {
-      throw new Error(`Property "${lastToken}" does not exist at "${pointer}".`)
+    if (op.op !== "add" && !Object.hasOwn(parent, lastToken)) {
+      throw new Error(`Property "${lastToken}" does not exist at "${op.path}".`)
     }
     const updated = { ...parent }
-    if (mode === "remove") delete updated[lastToken]
-    else updated[lastToken] = val!
+    if (op.op === "remove") delete updated[lastToken]
+    else InternalRecord.assignProperty(updated, lastToken, op.value)
     return rebuildFromStack(stack, updated)
   }
 
-  throw new Error(`Cannot ${mode} at "${pointer}" (parent not found or not a container).`)
+  throw new Error(`Cannot ${op.op} at "${op.path}" (parent not found or not a container).`)
 }
 
 type StackEntry = { readonly container: unknown; readonly token: number | string }
@@ -424,20 +373,18 @@ function resolveParent(
   for (let i = 0; i < tokens.length - 1; i++) {
     const token = tokens[i]
 
-    if (cur == null) return null
-
     if (Array.isArray(cur)) {
       const idx = toIndex(token)
-      if (idx < 0 || idx >= cur.length) return null
+      if (idx >= cur.length) return null
       stack.push({ container: cur, token: idx })
       cur = cur[idx]
       continue
     }
 
-    if (cur && typeof cur === "object") {
+    if (isJsonObject(cur)) {
       if (!Object.hasOwn(cur, token)) return null
       stack.push({ container: cur, token })
-      cur = (cur as any)[token]
+      cur = cur[token]
       continue
     }
 
@@ -460,7 +407,7 @@ function rebuildFromStack(stack: ReadonlyArray<StackEntry>, newParent: Schema.Js
       acc = copy
     } else {
       const copy = { ...(container as Schema.JsonObject) }
-      copy[token as string] = acc
+      InternalRecord.assignProperty(copy, token as string, acc)
       acc = copy
     }
   }

package/src/JsonPointer.ts

@@ -27,12 +27,12 @@
  *
  * **Example** (Escaping special characters)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { JsonPointer } from "effect"
  *
- * JsonPointer.escapeToken("a/b") // "a~1b"
- * JsonPointer.escapeToken("c~d") // "c~0d"
- * JsonPointer.escapeToken("path/to~key") // "path~1to~0key"
+ * JsonPointer.escapeToken("a/b") // => "a~1b"
+ * JsonPointer.escapeToken("c~d") // => "c~0d"
+ * JsonPointer.escapeToken("path/to~key") // => "path~1to~0key"
  * ```
  *
  * @see {@link unescapeToken} The inverse operation for decoding escaped tokens
@@ -63,12 +63,12 @@ export function escapeToken(token: string): string {
  *
  * **Example** (Unescaping special characters)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { JsonPointer } from "effect"
  *
- * JsonPointer.unescapeToken("a~1b") // "a/b"
- * JsonPointer.unescapeToken("c~0d") // "c~d"
- * JsonPointer.unescapeToken("path~1to~0key") // "path/to~key"
+ * JsonPointer.unescapeToken("a~1b") // => "a/b"
+ * JsonPointer.unescapeToken("c~0d") // => "c~d"
+ * JsonPointer.unescapeToken("path~1to~0key") // => "path/to~key"
  * ```
  *
  * @see {@link escapeToken} The inverse operation for encoding tokens