@dxos/effect 0.8.3 → 0.8.4-main.16b68245aa

package/src/dynamic-runtime.ts

@@ -0,0 +1,195 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
+import type * as Fiber from 'effect/Fiber';
+import type * as ManagedRuntime from 'effect/ManagedRuntime';
+import * as Option from 'effect/Option';
+import * as Runtime from 'effect/Runtime';
+
+import { unwrapExit } from './errors';
+
+/**
+ * Helper type to construct a union of tag identifiers from an array of tags.
+ */
+export type TagsToContext<Tags extends ReadonlyArray<Context.Tag<any, any>>> = Tags extends readonly [
+  infer Head,
+  ...infer Tail,
+]
+  ? Head extends Context.Tag<infer Id, any>
+    ? Tail extends ReadonlyArray<Context.Tag<any, any>>
+      ? Id | TagsToContext<Tail>
+      : Id
+    : never
+  : never;
+
+/**
+ * A runtime wrapper that validates required tags are available at runtime
+ * while providing type-level guarantees that effects require those tags.
+ */
+export interface DynamicRuntime<Tags extends ReadonlyArray<Context.Tag<any, any>>> {
+  /**
+   * Run an effect as a promise that requires the specified tags.
+   */
+  readonly runPromise: <A, E>(effect: Effect.Effect<A, E, TagsToContext<Tags>>) => Promise<A>;
+
+  /**
+   * Run an effect synchronously that requires the specified tags.
+   */
+  readonly runSync: <A, E>(effect: Effect.Effect<A, E, TagsToContext<Tags>>) => A;
+
+  /**
+   * Run an effect synchronously returning exit that requires the specified tags.
+   */
+  readonly runSyncExit: <A, E>(effect: Effect.Effect<A, E, TagsToContext<Tags>>) => Exit.Exit<A, E>;
+
+  /**
+   * Run an effect as a promise returning exit that requires the specified tags.
+   */
+  readonly runPromiseExit: <A, E>(effect: Effect.Effect<A, E, TagsToContext<Tags>>) => Promise<Exit.Exit<A, E>>;
+
+  /**
+   * Fork an effect that requires the specified tags.
+   */
+  readonly runFork: <A, E>(effect: Effect.Effect<A, E, TagsToContext<Tags>>) => Fiber.RuntimeFiber<A, E>;
+
+  /**
+   * Get the runtime as an effect that requires the specified tags.
+   */
+  readonly runtimeEffect: Effect.Effect<Runtime.Runtime<TagsToContext<Tags>>, never, never>;
+
+  /**
+   * Dispose the underlying managed runtime.
+   */
+  readonly dispose: () => Promise<void>;
+
+  /**
+   * Get the underlying managed runtime.
+   */
+  readonly managedRuntime: ManagedRuntime.ManagedRuntime<any, any>;
+}
+
+/**
+ * Validate that all required tags are present in the runtime context.
+ */
+const validateTags = <Tags extends ReadonlyArray<Context.Tag<any, any>>>(
+  context: Context.Context<any>,
+  tags: Tags,
+): Effect.Effect<void> =>
+  Effect.gen(function* () {
+    const missingTags: string[] = [];
+    for (const tag of tags) {
+      const option = Context.getOption(context, tag);
+      if (Option.isNone(option)) {
+        missingTags.push(tag.key);
+      }
+    }
+
+    if (missingTags.length > 0) {
+      return yield* Effect.die(new Error(`Missing required tags in runtime: ${missingTags.join(', ')}`));
+    }
+  });
+
+/**
+ * Create a dynamic runtime from a managed runtime and validate required tags.
+ */
+export function make<const Tags extends ReadonlyArray<Context.Tag<any, any>>>(
+  managedRuntime: ManagedRuntime.ManagedRuntime<any, any> | ManagedRuntime.ManagedRuntime<never, never>,
+  tags: Tags,
+): DynamicRuntime<Tags> {
+  type RequiredContext = TagsToContext<Tags>;
+  const managedRuntimeAny = managedRuntime as ManagedRuntime.ManagedRuntime<any, any>;
+
+  // Cache for the validated runtime - once resolved, can be used synchronously.
+  let cachedRuntime: Runtime.Runtime<RequiredContext> | undefined;
+
+  // Cache validated runtime for async operations.
+  let validatedRuntimePromise: Promise<Runtime.Runtime<RequiredContext>> | undefined;
+
+  const getValidatedRuntimeAsync = async (): Promise<Runtime.Runtime<RequiredContext>> => {
+    if (!validatedRuntimePromise) {
+      validatedRuntimePromise = managedRuntimeAny.runPromise(
+        Effect.gen(function* () {
+          const rt = yield* managedRuntimeAny.runtimeEffect;
+          yield* validateTags(rt.context, tags);
+          return rt as Runtime.Runtime<RequiredContext>;
+        }),
+      );
+    }
+    return validatedRuntimePromise;
+  };
+
+  // Get validated runtime for sync operations.
+  const getValidatedRuntime = (): Runtime.Runtime<RequiredContext> => {
+    const validationExit = managedRuntimeAny.runSyncExit(
+      Effect.gen(function* () {
+        const rt = yield* managedRuntimeAny.runtimeEffect;
+        yield* validateTags(rt.context, tags);
+        return rt as Runtime.Runtime<RequiredContext>;
+      }),
+    );
+    return unwrapExit(validationExit);
+  };
+
+  return {
+    managedRuntime: managedRuntimeAny,
+    runPromise: async <A, E>(effect: Effect.Effect<A, E, RequiredContext>): Promise<A> => {
+      const runtime = await getValidatedRuntimeAsync();
+      return Runtime.runPromise(runtime)(effect);
+    },
+    runSync: <A, E>(effect: Effect.Effect<A, E, RequiredContext>): A => {
+      const runtime = getValidatedRuntime();
+      return Runtime.runSync(runtime)(effect);
+    },
+    runSyncExit: <A, E>(effect: Effect.Effect<A, E, RequiredContext>): Exit.Exit<A, E> => {
+      const validationExit = managedRuntimeAny.runSyncExit(
+        Effect.gen(function* () {
+          const rt = yield* managedRuntimeAny.runtimeEffect;
+          yield* validateTags(rt.context, tags);
+          return rt as Runtime.Runtime<RequiredContext>;
+        }),
+      );
+      if (Exit.isSuccess(validationExit)) {
+        const runtime = validationExit.value;
+        return Runtime.runSyncExit(runtime)(effect);
+      }
+      return validationExit as Exit.Exit<A, E>;
+    },
+    runPromiseExit: async <A, E>(effect: Effect.Effect<A, E, RequiredContext>): Promise<Exit.Exit<A, E>> => {
+      try {
+        const runtime = await getValidatedRuntimeAsync();
+        return Runtime.runPromiseExit(runtime)(effect);
+      } catch (error) {
+        // If validation failed, return a failure exit
+        return Exit.die(error);
+      }
+    },
+    runFork: <A, E>(effect: Effect.Effect<A, E, RequiredContext>): Fiber.RuntimeFiber<A, E> => {
+      const runtime = getValidatedRuntime();
+      return Runtime.runFork(runtime)(effect);
+    },
+    runtimeEffect: Effect.gen(function* () {
+      // Return cached runtime if available.
+      if (cachedRuntime) {
+        return cachedRuntime;
+      }
+      const rt = yield* managedRuntimeAny.runtimeEffect;
+      yield* validateTags(rt.context, tags);
+      const runtime = rt as Runtime.Runtime<RequiredContext>;
+      // Cache for future sync calls.
+      cachedRuntime = runtime;
+      return runtime;
+    }).pipe(
+      Effect.catchAll(() =>
+        // This should never happen since validateTags uses Effect.die
+        Effect.die(new Error('Unexpected error in runtimeEffect validation')),
+      ),
+    ),
+    dispose: async (): Promise<void> => {
+      await managedRuntimeAny.dispose();
+    },
+  };
+}

package/src/errors.test.ts

@@ -0,0 +1,22 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Data from 'effect/Data';
+import { test } from 'vitest';
+
+class MyError extends Data.TaggedError('MyError')<{
+  message: string;
+}> {
+  constructor() {
+    super({ message: 'My error message' });
+  }
+}
+
+// Experimenting with error formatting:
+// - If the error doesn't have the message set, vitest will print the error as a JS object.
+// - If the error has non-empty message, vitest will pretty-print the error.
+test.skip('Data error formatting', () => {
+  console.log(JSON.stringify(new MyError(), null, 2));
+  throw new MyError();
+});

package/src/errors.ts

@@ -0,0 +1,252 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Cause from 'effect/Cause';
+import * as Chunk from 'effect/Chunk';
+import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
+import * as GlobalValue from 'effect/GlobalValue';
+import * as Option from 'effect/Option';
+import * as Runtime from 'effect/Runtime';
+import type * as Tracer from 'effect/Tracer';
+
+const spanSymbol = Symbol.for('effect/SpanAnnotation');
+const spanToTrace = GlobalValue.globalValue('effect/Tracer/spanToTrace', () => new WeakMap());
+const locationRegex = /\((.*)\)/g;
+
+/**
+ * Adds effect spans.
+ * Removes effect internal functions.
+ * Unwraps error proxy.
+ */
+const prettyErrorStack = (error: any, appendStacks: string[] = []): any => {
+  if (typeof error !== 'object' || error === null) {
+    return error;
+  }
+
+  const span = error[spanSymbol];
+
+  const lines = typeof error.stack === 'string' ? error.stack.split('\n') : [];
+  const out = [];
+
+  // Very hacky way to remove effect runtime internal stack frames.
+  let atStack = false,
+    inCore = false,
+    passedScheduler = false;
+  for (let i = 0; i < lines.length; i++) {
+    if (!atStack && !lines[i].startsWith('    at ')) {
+      out.push(lines[i]);
+      continue;
+    }
+    atStack = true;
+
+    if (lines[i].includes(' at new BaseEffectError') || lines[i].includes(' at new YieldableError')) {
+      i++;
+      continue;
+    }
+    if (lines[i].includes('Generator.next')) {
+      break;
+    }
+    if (lines[i].includes('effect_internal_function')) {
+      break;
+    }
+
+    const filename = lines[i].match(/\/([a-zA-Z0-9_\-.]+):\d+:\d+\)$/)?.[1];
+
+    if (!inCore && ['core-effect.ts'].includes(filename)) {
+      inCore = true;
+    }
+
+    if (inCore && !passedScheduler && ['Scheduler.ts'].includes(filename)) {
+      passedScheduler = true;
+      continue;
+    }
+
+    if (passedScheduler && !['Scheduler.ts'].includes(filename)) {
+      inCore = false;
+    }
+
+    if (inCore) {
+      continue;
+    }
+
+    out.push(
+      lines[i]
+        .replace(/at .*effect_instruction_i.*\((.*)\)/, 'at $1')
+        .replace(/EffectPrimitive\.\w+/, '<anonymous>')
+        .replace(/at Arguments\./, 'at '),
+    );
+  }
+
+  if (span) {
+    let current: Tracer.Span | Tracer.AnySpan | undefined = span;
+    let i = 0;
+    while (current && current._tag === 'Span' && i < 10) {
+      const stackFn = spanToTrace.get(current);
+      if (typeof stackFn === 'function') {
+        const stack = stackFn();
+        if (typeof stack === 'string') {
+          const locationMatchAll = stack.matchAll(locationRegex);
+          let match = false;
+          for (const [, location] of locationMatchAll) {
+            match = true;
+            out.push(`    at ${current.name} (${location})`);
+          }
+          if (!match) {
+            out.push(`    at ${current.name} (${stack.replace(/^at /, '')})`);
+          }
+        } else {
+          out.push(`    at ${current.name}`);
+        }
+      } else {
+        out.push(`    at ${current.name}`);
+      }
+      current = Option.getOrUndefined(current.parent);
+      i++;
+    }
+  }
+
+  out.push(...appendStacks);
+
+  error = Cause.originalError(error);
+  if (error.cause) {
+    error.cause = prettyErrorStack(error.cause);
+  }
+
+  Object.defineProperty(error, 'stack', {
+    value: out.join('\n'),
+    writable: true,
+    enumerable: false,
+    configurable: true,
+  });
+
+  return error;
+};
+
+/**
+ * Converts a cause to an error.
+ * Inserts effect spans as stack frames.
+ * The error will have stack frames of where the effect was run (if stack trace limit allows).
+ * Removes effect runtime internal stack frames.
+ *
+ * To be used in place of `Effect.runPromise`.
+ *
+ * @throws AggregateError if there are multiple errors.
+ */
+export const causeToError = (cause: Cause.Cause<any>): Error => {
+  if (Cause.isEmpty(cause)) {
+    return new Error('Fiber failed without a cause');
+  } else if (Cause.isInterruptedOnly(cause)) {
+    return new Error('Fiber was interrupted');
+  } else {
+    const errors = [...Chunk.toArray(Cause.failures(cause)), ...Chunk.toArray(Cause.defects(cause))];
+
+    const getStackFrames = (): string[] => {
+      // Bun requies the target object for `captureStackTrace` to be an Error.
+      const o = new Error();
+      Error.captureStackTrace(o, causeToError);
+      return o.stack!.split('\n').slice(1);
+    };
+
+    const stackFrames = getStackFrames();
+    const newErrors = errors.map((error) => prettyErrorStack(error, stackFrames));
+
+    if (newErrors.length === 1) {
+      return newErrors[0];
+    } else {
+      return new AggregateError(newErrors);
+    }
+  }
+};
+
+/**
+ * Throws an error based on the cause.
+ * Inserts effect spans as stack frames.
+ * The error will have stack frames of where the effect was run (if stack trace limit allows).
+ * Removes effect runtime internal stack frames.
+ *
+ * To be used in place of `Effect.runPromise`.
+ *
+ * @throws AggregateError if there are multiple errors.
+ */
+export const throwCause = (cause: Cause.Cause<any>): never => {
+  throw causeToError(cause);
+};
+
+export const unwrapExit = <A>(exit: Exit.Exit<A, any>): A => {
+  if (Exit.isSuccess(exit)) {
+    return exit.value;
+  }
+
+  return throwCause(exit.cause);
+};
+
+/**
+ * Runs the embedded effect asynchronously and throws any failures and defects as errors.
+ * Inserts effect spans as stack frames.
+ * The error will have stack frames of where the effect was run (if stack trace limit allows).
+ * Removes effect runtime internal stack frames.
+ *
+ * To be used in place of `Effect.runPromise`.
+ *
+ * @throws AggregateError if there are multiple errors.
+ */
+export const runAndForwardErrors = async <A, E>(
+  effect: Effect.Effect<A, E, never>,
+  options?: { signal?: AbortSignal },
+): Promise<A> => {
+  const exit = await Effect.runPromiseExit(effect, options);
+  return unwrapExit(exit);
+};
+
+/**
+ * Runs the embedded effect asynchronously and throws any failures and defects as errors.
+ */
+export const runInRuntime: {
+  <R>(
+    runtime: Runtime.Runtime<R>,
+  ): <A, E>(effect: Effect.Effect<A, E, R>, options?: { signal?: AbortSignal } | undefined) => Promise<A>;
+  <R, A, E>(
+    runtime: Runtime.Runtime<R>,
+    effect: Effect.Effect<A, E, R>,
+    options?: { signal?: AbortSignal } | undefined,
+  ): Promise<A>;
+} = (...args: any[]): any => {
+  if (args.length === 1) {
+    const [runtime] = args as [Runtime.Runtime<any>];
+    return async (
+      effect: Effect.Effect<any, any, any>,
+      options?: { signal?: AbortSignal } | undefined,
+    ): Promise<any> => {
+      const exit = await Runtime.runPromiseExit(runtime, effect, options);
+      return unwrapExit(exit);
+    };
+  } else {
+    const [runtime, effect, options] = args as [
+      Runtime.Runtime<any>,
+      Effect.Effect<any, any, any>,
+      { signal?: AbortSignal } | undefined,
+    ];
+    return (async () => {
+      const exit = await Runtime.runPromiseExit(runtime, effect, options);
+      return unwrapExit(exit);
+    })();
+  }
+};
+
+/**
+ * Like `Effect.promise` but also caputes spans for defects.
+ * Workaround for: https://github.com/Effect-TS/effect/issues/5436
+ */
+export const promiseWithCauseCapture: <A>(evaluate: (signal: AbortSignal) => PromiseLike<A>) => Effect.Effect<A> = (
+  evaluate,
+) =>
+  Effect.promise(async (signal) => {
+    try {
+      const result = await evaluate(signal);
+      return Effect.succeed(result);
+    } catch (err) {
+      return Effect.die(err);
+    }
+  }).pipe(Effect.flatten);

package/src/index.ts

@@ -3,5 +3,14 @@
 //
 
 export * from './ast';
-export * from './jsonPath';
+export * from './atom-kvs';
+export * from './context';
+export * as DynamicRuntime from './dynamic-runtime';
+export * from './errors';
+export * from './json-path';
+export * from './resource';
+export * from './types';
 export * from './url';
+export * as RuntimeProvider from './RuntimeProvider';
+export * as Performance from './Performance';
+export * from './async-task-tagging';

package/src/interrupt.test.ts

@@ -0,0 +1,35 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { it } from '@effect/vitest';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import * as Fiber from 'effect/Fiber';
+
+import { runAndForwardErrors } from './errors';
+
+const doWork = Effect.fn('doWork')(function* () {
+  yield* Effect.sleep('1 minute');
+  return 'work done';
+});
+
+it.effect.skip(
+  'call a function to generate a research report',
+  Effect.fnUntraced(
+    function* (_) {
+      const resultFiber = yield* doWork().pipe(Effect.fork);
+      setTimeout(() => {
+        void runAndForwardErrors(Fiber.interrupt(resultFiber));
+      }, 2_000);
+
+      const result = yield* resultFiber;
+      console.log({ result });
+    },
+    Effect.catchAllCause((cause) => {
+      // console.log(inspect(cause, { depth: null, colors: true }));
+      console.log(Cause.pretty(cause));
+      return Effect.failCause(cause);
+    }),
+  ),
+);

package/src/{jsonPath.test.ts → json-path.test.ts}

@@ -4,7 +4,7 @@
 
 import { describe, expect, test } from 'vitest';
 
-import { createJsonPath, getField, isJsonPath, type JsonPath, splitJsonPath } from './jsonPath';
+import { type JsonPath, createJsonPath, getField, getValue, isJsonPath, setValue, splitJsonPath } from './json-path';
 
 describe('createJsonPath', () => {
   test('supported path subset', () => {
@@ -32,9 +32,9 @@ describe('createJsonPath', () => {
 
   test('path splitting', () => {
     const cases = [
-      ['foo.bar[0].baz', ['foo', 'bar', '0', 'baz']],
-      ['users[1].name', ['users', '1', 'name']],
-      ['data[0][1]', ['data', '0', '1']],
+      ['foo.bar[0].baz', ['foo', 'bar', 0, 'baz']],
+      ['users[1].name', ['users', 1, 'name']],
+      ['data[0][1]', ['data', 0, 1]],
       ['simple.path', ['simple', 'path']],
       ['root', ['root']],
     ] as const;
@@ -47,15 +47,15 @@ describe('createJsonPath', () => {
   test('path splitting - extended cases', () => {
     const cases = [
       // Multiple consecutive array indices.
-      ['matrix[0][1][2]', ['matrix', '0', '1', '2']],
+      ['matrix[0][1][2]', ['matrix', 0, 1, 2]],
       // Properties with underscores and $.
       ['$_foo.bar_baz', ['$_foo', 'bar_baz']],
       // Deep nesting.
-      ['very.deep.nested[0].property.path[5]', ['very', 'deep', 'nested', '0', 'property', 'path', '5']],
+      ['very.deep.nested[0].property.path[5]', ['very', 'deep', 'nested', 0, 'property', 'path', 5]],
       // Single character properties.
-      ['a[0].b.c', ['a', '0', 'b', 'c']],
+      ['a[0].b.c', ['a', 0, 'b', 'c']],
       // Properties containing numbers.
-      ['prop123.item456[7]', ['prop123', 'item456', '7']],
+      ['prop123.item456[7]', ['prop123', 'item456', 7]],
     ] as const;
 
     cases.forEach(([input, expected]) => {
@@ -99,3 +99,42 @@ describe('createJsonPath', () => {
     expect(getField({ a: 'foo' }, 'a' as JsonPath)).toBe('foo');
   });
 });
+
+describe('Types', () => {
+  test('checks sanity', async ({ expect }) => {
+    const obj = {};
+    expect(obj).to.exist;
+  });
+});
+
+describe('get/set deep', () => {
+  test('get/set operations', ({ expect }) => {
+    const obj = {
+      name: 'test',
+      items: ['a', 'b', 'c'],
+      nested: {
+        prop: 'value',
+        arr: [1, 2, 3],
+      },
+    };
+
+    // Basic property access.
+    expect(getValue(obj, 'name' as JsonPath)).toBe('test');
+
+    // Array index access.
+    expect(getValue(obj, 'items[1]' as JsonPath)).toBe('b');
+
+    // Nested property access.
+    expect(getValue(obj, 'nested.prop' as JsonPath)).toBe('value');
+
+    // Nested array access.
+    expect(getValue(obj, 'nested.arr[2]' as JsonPath)).toBe(3);
+
+    // Setting values.
+    const updated1 = setValue(obj, 'items[1]' as JsonPath, 'x');
+    expect(updated1.items[1]).toBe('x');
+
+    const updated2 = setValue(obj, 'nested.arr[0]' as JsonPath, 99);
+    expect(updated2.nested.arr[0]).toBe(99);
+  });
+});

package/src/{jsonPath.ts → json-path.ts}

@@ -2,20 +2,26 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema, Option } from 'effect';
+import * as Option from 'effect/Option';
+import * as Schema from 'effect/Schema';
 import { JSONPath } from 'jsonpath-plus';
 
 import { invariant } from '@dxos/invariant';
+import { getDeep, setDeep } from '@dxos/util';
 
 export type JsonProp = string & { __JsonPath: true; __JsonProp: true };
 export type JsonPath = string & { __JsonPath: true };
 
+// TODO(burdon): Start with "$."?
+
 const PATH_REGEX = /^($|[a-zA-Z_$][\w$]*(?:\.[a-zA-Z_$][\w$]*|\[\d+\](?:\.)?)*$)/;
+
 const PROP_REGEX = /^\w+$/;
 
 /**
  * https://www.ietf.org/archive/id/draft-goessner-dispatch-jsonpath-00.html
  */
+// TODO(burdon): Keys could be arbitrary strings.
 export const JsonPath = Schema.String.pipe(Schema.pattern(PATH_REGEX)).annotations({
   title: 'JSON path',
   description: 'JSON path to a property',
@@ -49,7 +55,7 @@ export const isJsonPath = (value: unknown): value is JsonPath => {
  * @param path Array of string or number segments
  * @returns Valid JsonPath or undefined if invalid
  */
-export const createJsonPath = (path: (string | number)[]): JsonPath => {
+export const createJsonPath = (path: readonly (string | number)[]): JsonPath => {
   const candidatePath = path
     .map((p, i) => {
       if (typeof p === 'number') {
@@ -79,7 +85,7 @@ export const fromEffectValidationPath = (effectPath: string): JsonPath => {
  * Splits a JsonPath into its constituent parts.
  * Handles property access and array indexing.
  */
-export const splitJsonPath = (path: JsonPath): string[] => {
+export const splitJsonPath = (path: JsonPath): (string | number)[] => {
   if (!isJsonPath(path)) {
     return [];
   }
@@ -87,14 +93,33 @@ export const splitJsonPath = (path: JsonPath): string[] => {
   return (
     path
       .match(/[a-zA-Z_$][\w$]*|\[\d+\]/g)
-      ?.map((part) => (part.startsWith('[') ? part.replace(/[[\]]/g, '') : part)) ?? []
+      ?.map((part) => part.replace(/[[\]]/g, ''))
+      .map((part) => {
+        const parsed = Number.parseInt(part, 10);
+        return Number.isNaN(parsed) ? part : parsed;
+      }) ?? []
   );
 };
 
 /**
  * Applies a JsonPath to an object.
  */
+// TODO(burdon): Reconcile with getValue.
 export const getField = (object: any, path: JsonPath): any => {
   // By default, JSONPath returns an array of results.
   return JSONPath({ path, json: object })[0];
 };
+
+/**
+ * Get value from object using JsonPath.
+ */
+export const getValue = <T extends object>(obj: T, path: JsonPath): any => {
+  return getDeep(obj, splitJsonPath(path));
+};
+
+/**
+ * Set value on object using JsonPath.
+ */
+export const setValue = <T extends object>(obj: T, path: JsonPath, value: any): T => {
+  return setDeep(obj, splitJsonPath(path), value);
+};