@dxos/effect 0.7.5-labs.e27f9b9 → 0.7.5-main.2567c87

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/effect",
-  "version": "0.7.5-labs.e27f9b9",
+  "version": "0.7.5-main.2567c87",
   "description": "Effect utils.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -22,18 +22,18 @@
     "src"
   ],
   "dependencies": {
-    "@dxos/invariant": "0.7.5-labs.e27f9b9",
-    "@dxos/node-std": "0.7.5-labs.e27f9b9",
-    "@dxos/util": "0.7.5-labs.e27f9b9"
+    "@dxos/invariant": "0.7.5-main.2567c87",
+    "@dxos/util": "0.7.5-main.2567c87",
+    "@dxos/node-std": "0.7.5-main.2567c87"
   },
   "devDependencies": {
     "@effect/schema": "^0.75.5",
-    "effect": "^3.12.3",
-    "@dxos/log": "0.7.5-labs.e27f9b9"
+    "effect": "^3.12.1",
+    "@dxos/log": "0.7.5-main.2567c87"
   },
   "peerDependencies": {
     "@effect/schema": "^0.75.5",
-    "effect": "^3.12.3"
+    "effect": "^3.9.2"
   },
   "publishConfig": {
     "access": "public"

package/src/ast.test.ts

@@ -3,6 +3,7 @@
 //
 
 import { AST, Schema as S } from '@effect/schema';
+import { isNone, isSome } from 'effect/Option';
 import { describe, test } from 'vitest';
 
 import { invariant } from '@dxos/invariant';
@@ -18,8 +19,9 @@ 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}$/, {
@@ -181,4 +183,25 @@ 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,8 +8,6 @@ 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
@@ -78,6 +76,18 @@ 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,
   /**
@@ -403,19 +413,13 @@ export const getDiscriminatedType = (node: AST.AST, value: Record<string, any> =
  * The user is responsible for recursively calling {@link mapAst} on the AST.
  * NOTE: Will evaluate suspended ASTs.
  */
-export const mapAst = (ast: AST.AST, f: (ast: AST.AST, key: keyof any | undefined) => AST.AST): AST.AST => {
+export const mapAst = (ast: AST.AST, f: (ast: AST.AST) => AST.AST): AST.AST => {
   switch (ast._tag) {
     case 'TypeLiteral':
       return new AST.TypeLiteral(
         ast.propertySignatures.map(
           (prop) =>
-            new AST.PropertySignature(
-              prop.name,
-              f(prop.type, prop.name),
-              prop.isOptional,
-              prop.isReadonly,
-              prop.annotations,
-            ),
+            new AST.PropertySignature(prop.name, f(prop.type), prop.isOptional, prop.isReadonly, prop.annotations),
         ),
         ast.indexSignatures,
       );
@@ -423,13 +427,13 @@ export const mapAst = (ast: AST.AST, f: (ast: AST.AST, key: keyof any | undefine
       return AST.Union.make(ast.types.map(f), ast.annotations);
     case 'TupleType':
       return new AST.TupleType(
-        ast.elements.map((t, index) => new AST.OptionalType(f(t.type, index), t.isOptional, t.annotations)),
-        ast.rest.map((t) => new AST.Type(f(t.type, undefined), t.annotations)),
+        ast.elements.map((t) => new AST.OptionalType(f(t.type), t.isOptional, t.annotations)),
+        ast.rest.map((t) => new AST.Type(f(t.type), t.annotations)),
         ast.isReadonly,
         ast.annotations,
       );
     case 'Suspend': {
-      const newAst = f(ast.f(), undefined);
+      const newAst = f(ast.f());
       return new AST.Suspend(() => newAst, ast.annotations);
     }
     default:

package/src/index.ts

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

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

@@ -1,45 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

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

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

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

package/src/jsonPath.test.ts

@@ -1,96 +0,0 @@
-//
-// 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

@@ -1,85 +0,0 @@
-//
-// 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)) ?? []
-  );
-};