@dxos/effect 0.7.5-main.9d2a38b → 0.7.5-main.e9bb01b

package/dist/types/src/jsonPath.d.ts

@@ -0,0 +1,45 @@
+import { Schema as S } from '@effect/schema';
+export type JsonProp = string & {
+    __JsonPath: true;
+    __JsonProp: true;
+};
+export type JsonPath = string & {
+    __JsonPath: true;
+};
+/**
+ * https://www.ietf.org/archive/id/draft-goessner-dispatch-jsonpath-00.html
+ */
+export declare const JsonPath: S.Schema<JsonPath>;
+export declare const JsonProp: S.Schema<JsonProp>;
+export declare const isJsonPath: (value: unknown) => value is JsonPath;
+/**
+ * Creates a JsonPath from an array of path segments.
+ *
+ * Currently supports:
+ * - Simple property access (e.g., 'foo.bar')
+ * - Array indexing with non-negative integers (e.g., 'foo[0]')
+ * - Identifiers starting with letters, underscore, or $ (e.g., '$foo', '_bar')
+ * - Dot notation for nested properties (e.g., 'foo.bar.baz')
+ *
+ * Does not support (yet?).
+ * - Recursive descent (..)
+ * - Wildcards (*)
+ * - Array slicing
+ * - Filters
+ * - Negative indices
+ *
+ * @param path Array of string or number segments
+ * @returns Valid JsonPath or undefined if invalid
+ */
+export declare const createJsonPath: (path: (string | number)[]) => JsonPath;
+/**
+ * Converts Effect validation path format (e.g. "addresses.[0].zip")
+ * to JsonPath format (e.g. "addresses[0].zip")
+ */
+export declare const fromEffectValidationPath: (effectPath: string) => JsonPath;
+/**
+ * Splits a JsonPath into its constituent parts.
+ * Handles property access and array indexing.
+ */
+export declare const splitJsonPath: (path: JsonPath) => string[];
+//# sourceMappingURL=jsonPath.d.ts.map

package/dist/types/src/jsonPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonPath.d.ts","sourceRoot":"","sources":["../../../src/jsonPath.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,IAAI,CAAC,EAAE,MAAM,gBAAgB,CAAC;AAK7C,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG;IAAE,UAAU,EAAE,IAAI,CAAC;IAAC,UAAU,EAAE,IAAI,CAAA;CAAE,CAAC;AACvE,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG;IAAE,UAAU,EAAE,IAAI,CAAA;CAAE,CAAC;AAKrD;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAkD,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;AAC1F,eAAO,MAAM,QAAQ,EAA0D,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;AAElG,eAAO,MAAM,UAAU,UAAW,OAAO,KAAG,KAAK,IAAI,QAEpD,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,cAAc,SAAU,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,KAAG,QAa1D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,wBAAwB,eAAgB,MAAM,KAAG,QAK7D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa,SAAU,QAAQ,KAAG,MAAM,EAUpD,CAAC"}

package/dist/types/src/jsonPath.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=jsonPath.test.d.ts.map

package/dist/types/src/jsonPath.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonPath.test.d.ts","sourceRoot":"","sources":["../../../src/jsonPath.test.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/effect",
-  "version": "0.7.5-main.9d2a38b",
+  "version": "0.7.5-main.e9bb01b",
   "description": "Effect utils.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -22,14 +22,14 @@
     "src"
   ],
   "dependencies": {
-    "@dxos/invariant": "0.7.5-main.9d2a38b",
-    "@dxos/node-std": "0.7.5-main.9d2a38b",
-    "@dxos/util": "0.7.5-main.9d2a38b"
+    "@dxos/invariant": "0.7.5-main.e9bb01b",
+    "@dxos/util": "0.7.5-main.e9bb01b",
+    "@dxos/node-std": "0.7.5-main.e9bb01b"
   },
   "devDependencies": {
     "@effect/schema": "^0.75.5",
     "effect": "^3.12.1",
-    "@dxos/log": "0.7.5-main.9d2a38b"
+    "@dxos/log": "0.7.5-main.e9bb01b"
   },
   "peerDependencies": {
     "@effect/schema": "^0.75.5",

package/src/ast.test.ts

@@ -3,7 +3,6 @@
 //
 
 import { AST, Schema as S } from '@effect/schema';
-import { isNone, isSome } from 'effect/Option';
 import { describe, test } from 'vitest';
 
 import { invariant } from '@dxos/invariant';
@@ -19,9 +18,8 @@ import {
   isOption,
   isSimpleType,
   visit,
-  JsonPath,
-  type JsonProp,
 } from './ast';
+import { type JsonPath, type JsonProp } from './jsonPath';
 
 const ZipCode = S.String.pipe(
   S.pattern(/^\d{5}$/, {
@@ -183,25 +181,4 @@ describe('AST', () => {
       );
     }
   });
-
-  // TODO(ZaymonFC): Update this when we settle on the right indexing syntax for arrays.
-  test('json path validation', ({ expect }) => {
-    const validatePath = S.validateOption(JsonPath);
-
-    // Valid paths.
-    expect(isSome(validatePath('foo'))).toBe(true);
-    expect(isSome(validatePath('foo.bar'))).toBe(true);
-    expect(isSome(validatePath('foo.bar.baz'))).toBe(true);
-    expect(isSome(validatePath('foo[1].bar'))).toBe(true);
-    expect(isSome(validatePath('_foo.$bar'))).toBe(true);
-
-    // Invalid paths.
-    expect(isNone(validatePath(''))).toBe(true);
-    expect(isNone(validatePath('.'))).toBe(true);
-    expect(isNone(validatePath('foo.'))).toBe(true);
-    expect(isNone(validatePath('foo..bar'))).toBe(true);
-    expect(isNone(validatePath('foo.#bar'))).toBe(true);
-    expect(isNone(validatePath('[1].bar'))).toBe(true);
-    expect(isNone(validatePath('test.[1].bar[1]'))).toBe(true);
-  });
 });

package/src/ast.ts

@@ -8,6 +8,8 @@ import { Option, pipe } from 'effect';
 import { invariant } from '@dxos/invariant';
 import { nonNullable } from '@dxos/util';
 
+import { type JsonPath, type JsonProp } from './jsonPath';
+
 //
 // Refs
 // https://effect.website/docs/schema/introduction
@@ -76,18 +78,6 @@ export namespace SimpleType {
 // Branded types
 //
 
-export type JsonProp = string & { __JsonPath: true; __JsonProp: true };
-export type JsonPath = string & { __JsonPath: true };
-
-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
- */
-export const JsonPath = S.NonEmptyString.pipe(S.pattern(PATH_REGEX)) as any as S.Schema<JsonPath>;
-export const JsonProp = S.NonEmptyString.pipe(S.pattern(PROP_REGEX)) as any as S.Schema<JsonProp>;
-
 export enum VisitResult {
   CONTINUE = 0,
   /**

package/src/index.ts

@@ -9,4 +9,5 @@ import type * as Types from 'effect/Types';
 export { AST, JSONSchema, S, Types };
 
 export * from './ast';
+export * from './jsonPath';
 export * from './url';

package/src/jsonPath.test.ts

@@ -0,0 +1,96 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, expect, test } from 'vitest';
+
+import { createJsonPath, isJsonPath, type JsonPath, splitJsonPath } from './jsonPath';
+
+describe('createJsonPath', () => {
+  test('supported path subset', () => {
+    // Simple property access.
+    expect(createJsonPath(['foo'])).toBe('foo');
+    expect(createJsonPath(['foo', 'bar'])).toBe('foo.bar');
+    expect(createJsonPath(['names', 1, 'bar'])).toBe('names[1].bar');
+    expect(createJsonPath(['names', 1])).toBe('names[1]');
+    expect(createJsonPath(['names', 1, 'names'])).toBe('names[1].names');
+
+    // Array indexing.
+    expect(createJsonPath(['foo', 0, 'bar'])).toBe('foo[0].bar');
+    expect(createJsonPath(['items', 1])).toBe('items[1]');
+
+    // $ is valid in identifiers.
+    expect(createJsonPath(['$foo', '$bar'])).toBe('$foo.$bar');
+    expect(createJsonPath([])).toBe('');
+  });
+
+  test('invalid paths', () => {
+    expect(() => createJsonPath(['123foo'])).toThrow(); // Can't start with number.
+    expect(() => createJsonPath(['foo', -1, 'bar'])).toThrow(); // No negative indices.
+    expect(() => createJsonPath(['foo', 1.5, 'bar'])).toThrow(); // No float indices.
+  });
+
+  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']],
+      ['simple.path', ['simple', 'path']],
+      ['root', ['root']],
+    ] as const;
+
+    cases.forEach(([input, expected]) => {
+      expect(splitJsonPath(input as JsonPath)).toEqual(expected);
+    });
+  });
+
+  test('path splitting - extended cases', () => {
+    const cases = [
+      // Multiple consecutive array indices.
+      ['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']],
+      // Single character properties.
+      ['a[0].b.c', ['a', '0', 'b', 'c']],
+      // Properties containing numbers.
+      ['prop123.item456[7]', ['prop123', 'item456', '7']],
+    ] as const;
+
+    cases.forEach(([input, expected]) => {
+      expect(splitJsonPath(input as JsonPath)).toEqual(expected);
+    });
+  });
+
+  test('invalid path formats', () => {
+    // These should return empty array or handle gracefully.
+    const invalidPaths = ['', '.', '[', ']', 'foo[].bar', 'foo[a].bar', 'foo[-1].bar'] as const;
+
+    invalidPaths.forEach((path) => {
+      expect(splitJsonPath(path as JsonPath)).toEqual([]);
+    });
+  });
+
+  test('isJsonPath validation', () => {
+    // Valid paths.
+    expect(isJsonPath('')).toBe(true);
+    expect(isJsonPath('foo')).toBe(true);
+    expect(isJsonPath('foo.bar')).toBe(true);
+    expect(isJsonPath('foo[0].bar')).toBe(true);
+    expect(isJsonPath('items[1]')).toBe(true);
+    expect(isJsonPath('$foo.$bar')).toBe(true);
+    expect(isJsonPath('matrix[0][1][2]')).toBe(true);
+    expect(isJsonPath('deep.nested[0].path')).toBe(true);
+
+    // Invalid paths.
+    expect(isJsonPath('items[0]name')).toBe(false); // Missing dot
+    expect(isJsonPath('123foo')).toBe(false); // Starts with number
+    expect(isJsonPath('foo[].bar')).toBe(false); // Empty brackets
+    expect(isJsonPath('foo[-1]')).toBe(false); // Negative index
+    expect(isJsonPath('foo[a]')).toBe(false); // Non-numeric index
+    expect(isJsonPath('.foo')).toBe(false); // Starts with dot
+    expect(isJsonPath('foo.')).toBe(false); // Ends with dot
+    expect(isJsonPath('[0]foo')).toBe(false); // Starts with bracket
+  });
+});

package/src/jsonPath.ts

@@ -0,0 +1,85 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Schema as S } from '@effect/schema';
+import { isSome } from 'effect/Option';
+
+import { invariant } from '@dxos/invariant';
+
+export type JsonProp = string & { __JsonPath: true; __JsonProp: true };
+export type JsonPath = string & { __JsonPath: true };
+
+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
+ */
+export const JsonPath = S.String.pipe(S.pattern(PATH_REGEX)) as any as S.Schema<JsonPath>;
+export const JsonProp = S.NonEmptyString.pipe(S.pattern(PROP_REGEX)) as any as S.Schema<JsonProp>;
+
+export const isJsonPath = (value: unknown): value is JsonPath => {
+  return isSome(S.validateOption(JsonPath)(value));
+};
+
+/**
+ * Creates a JsonPath from an array of path segments.
+ *
+ * Currently supports:
+ * - Simple property access (e.g., 'foo.bar')
+ * - Array indexing with non-negative integers (e.g., 'foo[0]')
+ * - Identifiers starting with letters, underscore, or $ (e.g., '$foo', '_bar')
+ * - Dot notation for nested properties (e.g., 'foo.bar.baz')
+ *
+ * Does not support (yet?).
+ * - Recursive descent (..)
+ * - Wildcards (*)
+ * - Array slicing
+ * - Filters
+ * - Negative indices
+ *
+ * @param path Array of string or number segments
+ * @returns Valid JsonPath or undefined if invalid
+ */
+export const createJsonPath = (path: (string | number)[]): JsonPath => {
+  const candidatePath = path
+    .map((p, i) => {
+      if (typeof p === 'number') {
+        return `[${p}]`;
+      } else {
+        return i === 0 ? p : `.${p}`;
+      }
+    })
+    .join('');
+
+  invariant(isJsonPath(candidatePath), `Invalid JsonPath: ${candidatePath}`);
+  return candidatePath;
+};
+
+/**
+ * Converts Effect validation path format (e.g. "addresses.[0].zip")
+ * to JsonPath format (e.g. "addresses[0].zip")
+ */
+export const fromEffectValidationPath = (effectPath: string): JsonPath => {
+  // Handle array notation: convert "prop.[0]" to "prop[0]"
+  const jsonPath = effectPath.replace(/\.\[(\d+)\]/g, '[$1]');
+  invariant(isJsonPath(jsonPath), `Invalid JsonPath: ${jsonPath}`);
+  return jsonPath;
+};
+
+/**
+ * Splits a JsonPath into its constituent parts.
+ * Handles property access and array indexing.
+ */
+export const splitJsonPath = (path: JsonPath): string[] => {
+  if (!isJsonPath(path)) {
+    return [];
+  }
+
+  return (
+    path
+      .match(/[a-zA-Z_$][\w$]*|\[\d+\]/g)
+      ?.map((part) => (part.startsWith('[') ? part.replace(/[[\]]/g, '') : part)) ?? []
+  );
+};