@valbuild/core 0.12.0 → 0.13.0

package/src/patch/deref.test.ts

@@ -0,0 +1,300 @@
+import { file } from "../source/file";
+import { result } from "../fp";
+import { remote } from "../source/remote";
+import { derefPatch, DerefPatchResult } from "./deref";
+import { JSONOps } from "./json";
+import { PatchError } from "./ops";
+
+const ops = new JSONOps();
+describe("deref", () => {
+  test("replace image", () => {
+    const actual = derefPatch(
+      [
+        {
+          op: "replace",
+          path: ["foo", "baz"],
+          value: 2,
+        },
+        {
+          op: "replace",
+          path: ["foo", "$image1"],
+          value: "aWtrZSB25nJzdD8=",
+        },
+        {
+          op: "replace",
+          path: ["foo", "baz"],
+          value: 3,
+        },
+        {
+          op: "replace",
+          path: ["foo", "$image2"],
+          value: "ZnVua2VyIGRldHRlPw==",
+        },
+      ],
+      {
+        foo: {
+          baz: 1,
+          image1: file("/public/val/File\\ Name.jpg", {}),
+          image2: file("/public/val/Some\\ Other\\ image.jpg", {}),
+        },
+      },
+      ops
+    );
+    const expected: DerefPatchResult = {
+      dereferencedPatch: [
+        {
+          op: "replace",
+          path: ["foo", "baz"],
+          value: 2,
+        },
+        {
+          op: "replace",
+          path: ["foo", "baz"],
+          value: 3,
+        },
+      ],
+      fileUpdates: {
+        "/public/val/File\\ Name.jpg": "aWtrZSB25nJzdD8=",
+        "/public/val/Some\\ Other\\ image.jpg": "ZnVua2VyIGRldHRlPw==",
+      },
+      remotePatches: {},
+    };
+    expect(actual).toStrictEqual(result.ok(expected));
+  });
+
+  test("replace image sub-reference fails", () => {
+    const actual = derefPatch(
+      [
+        {
+          op: "replace",
+          path: ["foo", "baz"],
+          value: 2,
+        },
+        {
+          op: "replace",
+          path: ["foo", "$image1", "bar"],
+          value: "aWtrZSB25nJzdD8=",
+        },
+      ],
+      {
+        foo: {
+          baz: 1,
+          image1: file("/public/val/File\\ Name.jpg", {}),
+        },
+      },
+      ops
+    );
+    expect(actual).toStrictEqual(result.err(expect.any(PatchError)));
+  });
+
+  test("replace image with 2 replaces on same image", () => {
+    const actual = derefPatch(
+      [
+        {
+          op: "replace",
+          path: ["foo", "baz"],
+          value: 2,
+        },
+        {
+          op: "replace",
+          path: ["foo", "$image1"],
+          value: "aWtrZSB25nJzdD8=",
+        },
+        {
+          op: "replace",
+          path: ["foo", "baz"],
+          value: 3,
+        },
+        {
+          op: "replace",
+          path: ["foo", "$image2"],
+          value: "ZnVua2VyIGRldHRlPw==",
+        },
+      ],
+      {
+        foo: {
+          baz: 1,
+          image1: file("/public/val/File\\ Name.jpg", {}),
+          image2: file("/public/val/File\\ Name.jpg", {}),
+        },
+      },
+      ops
+    );
+    const expected: DerefPatchResult = {
+      dereferencedPatch: [
+        {
+          op: "replace",
+          path: ["foo", "baz"],
+          value: 2,
+        },
+        {
+          op: "replace",
+          path: ["foo", "baz"],
+          value: 3,
+        },
+      ],
+      fileUpdates: {
+        "/public/val/File\\ Name.jpg": "ZnVua2VyIGRldHRlPw==",
+      },
+      remotePatches: {},
+    };
+    expect(actual).toStrictEqual(result.ok(expected));
+  });
+
+  test("replace remote", () => {
+    const actual = derefPatch(
+      [
+        {
+          op: "replace",
+          path: ["foo", "baz"],
+          value: 2,
+        },
+        {
+          op: "replace",
+          path: ["foo", "$re1", "test1"],
+          value: "next test1 update",
+        },
+        {
+          op: "replace",
+          path: ["foo", "baz"],
+          value: 3,
+        },
+        {
+          op: "replace",
+          path: ["foo", "$re2", "test2", "sub-segment"],
+          value: "next test2 update",
+        },
+      ],
+      {
+        foo: {
+          baz: 1,
+          re1: remote("41f86df3"),
+          re2: remote("96536d44"),
+        },
+      },
+      ops
+    );
+    const expected: DerefPatchResult = {
+      dereferencedPatch: [
+        {
+          op: "replace",
+          path: ["foo", "baz"],
+          value: 2,
+        },
+        {
+          op: "replace",
+          path: ["foo", "baz"],
+          value: 3,
+        },
+      ],
+      fileUpdates: {},
+      remotePatches: {
+        "41f86df3": [
+          {
+            op: "replace",
+            path: ["test1"],
+            value: "next test1 update",
+          },
+        ],
+        "96536d44": [
+          {
+            op: "replace",
+            path: ["test2", "sub-segment"],
+            value: "next test2 update",
+          },
+        ],
+      },
+    };
+    expect(actual).toStrictEqual(result.ok(expected));
+  });
+  test("replace remote with 2 replaces on same ref", () => {
+    const actual = derefPatch(
+      [
+        {
+          op: "replace",
+          path: ["foo", "baz"],
+          value: 2,
+        },
+        {
+          op: "replace",
+          path: ["foo", "$re1", "test1"],
+          value: "next test1 update",
+        },
+        {
+          op: "replace",
+          path: ["foo", "baz"],
+          value: 3,
+        },
+        {
+          op: "replace",
+          path: ["foo", "$re1", "test1"],
+          value: "next test2 update",
+        },
+      ],
+      {
+        foo: {
+          baz: 1,
+          re1: remote("41f86df3"),
+          re2: remote("96536d44"),
+        },
+      },
+      ops
+    );
+    const expected: DerefPatchResult = {
+      dereferencedPatch: [
+        {
+          op: "replace",
+          path: ["foo", "baz"],
+          value: 2,
+        },
+        {
+          op: "replace",
+          path: ["foo", "baz"],
+          value: 3,
+        },
+      ],
+      fileUpdates: {},
+      remotePatches: {
+        "41f86df3": [
+          {
+            op: "replace",
+            path: ["test1"],
+            value: "next test1 update",
+          },
+          {
+            op: "replace",
+            path: ["test1"],
+            value: "next test2 update",
+          },
+        ],
+      },
+    };
+    expect(actual).toStrictEqual(result.ok(expected));
+  });
+
+  test("replace chained references fails", () => {
+    const actual = derefPatch(
+      [
+        {
+          op: "replace",
+          path: ["foo", "baz"],
+          value: 2,
+        },
+        {
+          op: "replace",
+          path: ["foo", "$re1", "$re2"], // we do not support this, but it might be something we need in the future depending on how remote values
+          value: "next test1 update",
+        },
+      ],
+      {
+        foo: {
+          baz: 1,
+          re1: remote("41f86df3"),
+          re2: remote("96536d44"),
+        },
+      },
+      ops
+    );
+    expect(actual).toStrictEqual(result.err(expect.any(PatchError)));
+  });
+});

package/src/patch/deref.ts

@@ -0,0 +1,128 @@
+import { FILE_REF_PROP, isFile } from "../source/file";
+import { result } from "../fp";
+import { isRemote, REMOTE_REF_PROP } from "../source/remote";
+import { Ops, PatchError } from "./ops";
+import { Patch } from "./patch";
+
+function derefPath(
+  path: string[]
+): result.Result<[string[], string[] | null], PatchError> {
+  const dereffedPath: string[] = [];
+  let referencedPath: string[] | null = null;
+  for (const segment of path) {
+    if (segment.startsWith("$")) {
+      const dereffedSegment = segment.slice(1);
+      dereffedPath.push(dereffedSegment);
+      referencedPath = [];
+      for (const segment of path.slice(dereffedPath.length)) {
+        if (segment.startsWith("$")) {
+          return result.err(
+            new PatchError(
+              `Cannot reference within reference: ${segment}. Path: ${path.join(
+                "/"
+              )}`
+            )
+          );
+        }
+        referencedPath.push(segment);
+      }
+      break;
+    } else {
+      dereffedPath.push(segment);
+    }
+  }
+  return result.ok([dereffedPath, referencedPath]);
+}
+
+export type DerefPatchResult = {
+  dereferencedPatch: Patch;
+  fileUpdates: { [path: string]: string };
+  remotePatches: { [ref: string]: Patch };
+};
+
+export function derefPatch<D, E>(
+  patch: Patch,
+  document: D,
+  ops: Ops<D, E>
+): result.Result<DerefPatchResult, E | PatchError> {
+  const remotePatches: {
+    [ref: string]: Patch;
+  } = {};
+  const fileUpdates: {
+    [file: string]: string;
+  } = {};
+  const dereferencedPatch: Patch = [];
+  for (const op of patch) {
+    if (op.op === "replace") {
+      const maybeDerefRes = derefPath(op.path);
+      if (result.isErr(maybeDerefRes)) {
+        return maybeDerefRes;
+      }
+      const [dereffedPath, referencedPath] = maybeDerefRes.value;
+      if (referencedPath) {
+        const maybeValue = ops.get(document, dereffedPath);
+        if (result.isOk(maybeValue)) {
+          const value = maybeValue.value;
+          if (isFile(value)) {
+            if (referencedPath.length > 0) {
+              return result.err(
+                new PatchError(
+                  `Cannot sub-reference file reference at path: ${dereffedPath.join(
+                    "/"
+                  )}`
+                )
+              );
+            }
+            if (typeof op.value !== "string") {
+              return result.err(
+                new PatchError(
+                  `Expected base64 encoded string value for file reference, got ${JSON.stringify(
+                    op.value
+                  )}`
+                )
+              );
+            }
+            fileUpdates[value[FILE_REF_PROP]] = op.value;
+          } else if (isRemote(value)) {
+            if (!remotePatches[value[REMOTE_REF_PROP]]) {
+              remotePatches[value[REMOTE_REF_PROP]] = [];
+            }
+            remotePatches[value[REMOTE_REF_PROP]].push({
+              op: "replace",
+              path: referencedPath,
+              value: op.value,
+            });
+          } else {
+            return result.err(
+              new PatchError(
+                `Unknown reference: ${JSON.stringify(
+                  op
+                )} at path: ${dereffedPath.join("/")}`
+              )
+            );
+          }
+        } else {
+          return maybeValue;
+        }
+      } else {
+        dereferencedPatch.push(op);
+      }
+    } else {
+      const maybeDerefRes = derefPath(op.path);
+      if (result.isErr(maybeDerefRes)) {
+        return maybeDerefRes;
+      }
+      const [, referencedPath] = maybeDerefRes.value;
+      if (referencedPath) {
+        throw new Error(`Unimplemented operation: ${JSON.stringify(op)}`);
+      }
+      dereferencedPatch.push(op);
+    }
+  }
+
+  return result.ok({
+    remotePatches,
+    fileUpdates,
+    dereferencedPatch,
+  });
+}

package/src/patch/index.ts

@@ -0,0 +1,11 @@
+export { JSONOps } from "./json";
+export { type OperationJSON, type Operation } from "./operation";
+export { parsePatch, parseJSONPointer, formatJSONPointer } from "./parse";
+export { type JSONValue, type Ops, PatchError } from "./ops";
+export { type PatchJSON, type Patch, applyPatch } from "./patch";
+export {
+  isNotRoot,
+  deepEqual,
+  deepClone,
+  parseAndValidateArrayIndex,
+} from "./util";