@dxos/effect 0.8.2-main.2f9c567 → 0.8.2-main.5885341

package/src/ast.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Option, pipe, SchemaAST, Schema } from 'effect';
+import { Option, pipe, SchemaAST as AST, Schema as S } from 'effect';
 
 import { invariant } from '@dxos/invariant';
 import { isNonNullable } from '@dxos/util';
@@ -13,7 +13,7 @@ import { type JsonPath, type JsonProp } from './jsonPath';
 // Refs
 // https://effect.website/docs/schema/introduction
 // https://www.npmjs.com/package/@effect/schema
-// https://effect-ts.github.io/effect/schema/SchemaAST.ts.html
+// https://effect-ts.github.io/effect/schema/AST.ts.html
 //
 
 export type SimpleType = 'object' | 'string' | 'number' | 'boolean' | 'enum' | 'literal';
@@ -21,36 +21,31 @@ export type SimpleType = 'object' | 'string' | 'number' | 'boolean' | 'enum' | '
 /**
  * Get the base type; e.g., traverse through refinements.
  */
-export const getSimpleType = (node: SchemaAST.AST): SimpleType | undefined => {
-  if (
-    SchemaAST.isDeclaration(node) ||
-    SchemaAST.isObjectKeyword(node) ||
-    SchemaAST.isTypeLiteral(node) ||
-    isDiscriminatedUnion(node)
-  ) {
+export const getSimpleType = (node: AST.AST): SimpleType | undefined => {
+  if (AST.isObjectKeyword(node) || AST.isTypeLiteral(node) || isDiscriminatedUnion(node) || AST.isDeclaration(node)) {
     return 'object';
   }
 
-  if (SchemaAST.isStringKeyword(node)) {
+  if (AST.isStringKeyword(node)) {
     return 'string';
   }
-  if (SchemaAST.isNumberKeyword(node)) {
+  if (AST.isNumberKeyword(node)) {
     return 'number';
   }
-  if (SchemaAST.isBooleanKeyword(node)) {
+  if (AST.isBooleanKeyword(node)) {
     return 'boolean';
   }
 
-  if (SchemaAST.isEnums(node)) {
+  if (AST.isEnums(node)) {
     return 'enum';
   }
 
-  if (SchemaAST.isLiteral(node)) {
+  if (AST.isLiteral(node)) {
     return 'literal';
   }
 };
 
-export const isSimpleType = (node: SchemaAST.AST): boolean => !!getSimpleType(node);
+export const isSimpleType = (node: AST.AST): boolean => !!getSimpleType(node);
 
 export namespace SimpleType {
   /**
@@ -96,9 +91,9 @@ export enum VisitResult {
 
 export type Path = (string | number)[];
 
-export type TestFn = (node: SchemaAST.AST, path: Path, depth: number) => VisitResult | boolean | undefined;
+export type TestFn = (node: AST.AST, path: Path, depth: number) => VisitResult | boolean | undefined;
 
-export type VisitorFn = (node: SchemaAST.AST, path: Path, depth: number) => void;
+export type VisitorFn = (node: AST.AST, path: Path, depth: number) => void;
 
 const defaultTest: TestFn = isSimpleType;
 
@@ -109,9 +104,9 @@ const defaultTest: TestFn = isSimpleType;
  * - https://github.com/syntax-tree/unist-util-is?tab=readme-ov-file#test
  */
 export const visit: {
-  (node: SchemaAST.AST, visitor: VisitorFn): void;
-  (node: SchemaAST.AST, test: TestFn, visitor: VisitorFn): void;
-} = (node: SchemaAST.AST, testOrVisitor: TestFn | VisitorFn, visitor?: VisitorFn): void => {
+  (node: AST.AST, visitor: VisitorFn): void;
+  (node: AST.AST, test: TestFn, visitor: VisitorFn): void;
+} = (node: AST.AST, testOrVisitor: TestFn | VisitorFn, visitor?: VisitorFn): void => {
   if (!visitor) {
     visitNode(node, defaultTest, testOrVisitor);
   } else {
@@ -120,7 +115,7 @@ export const visit: {
 };
 
 const visitNode = (
-  node: SchemaAST.AST,
+  node: AST.AST,
   test: TestFn | undefined,
   visitor: VisitorFn,
   path: Path = [],
@@ -144,8 +139,8 @@ const visitNode = (
   }
 
   // Object.
-  if (SchemaAST.isTypeLiteral(node)) {
-    for (const prop of SchemaAST.getPropertySignatures(node)) {
+  if (AST.isTypeLiteral(node)) {
+    for (const prop of AST.getPropertySignatures(node)) {
       const currentPath = [...path, prop.name.toString()];
       const result = visitNode(prop.type, test, visitor, currentPath, depth + 1);
       if (result === VisitResult.EXIT) {
@@ -155,7 +150,7 @@ const visitNode = (
   }
 
   // Array.
-  else if (SchemaAST.isTupleType(node)) {
+  else if (AST.isTupleType(node)) {
     for (const [i, element] of node.elements.entries()) {
       const currentPath = [...path, i];
       const result = visitNode(element.type, test, visitor, currentPath, depth);
@@ -166,7 +161,7 @@ const visitNode = (
   }
 
   // Branching union (e.g., optional, discriminated unions).
-  else if (SchemaAST.isUnion(node)) {
+  else if (AST.isUnion(node)) {
     for (const type of node.types) {
       const result = visitNode(type, test, visitor, path, depth);
       if (result === VisitResult.EXIT) {
@@ -176,7 +171,7 @@ const visitNode = (
   }
 
   // Refinement.
-  else if (SchemaAST.isRefinement(node)) {
+  else if (AST.isRefinement(node)) {
     const result = visitNode(node.from, test, visitor, path, depth);
     if (result === VisitResult.EXIT) {
       return result;
@@ -190,14 +185,14 @@ const visitNode = (
  * Recursively descend into AST to find first node that passes the test.
  */
 // TODO(burdon): Rewrite using visitNode?
-export const findNode = (node: SchemaAST.AST, test: (node: SchemaAST.AST) => boolean): SchemaAST.AST | undefined => {
+export const findNode = (node: AST.AST, test: (node: AST.AST) => boolean): AST.AST | undefined => {
   if (test(node)) {
     return node;
   }
 
   // Object.
-  else if (SchemaAST.isTypeLiteral(node)) {
-    for (const prop of SchemaAST.getPropertySignatures(node)) {
+  else if (AST.isTypeLiteral(node)) {
+    for (const prop of AST.getPropertySignatures(node)) {
       const child = findNode(prop.type, test);
       if (child) {
         return child;
@@ -206,7 +201,7 @@ export const findNode = (node: SchemaAST.AST, test: (node: SchemaAST.AST) => boo
   }
 
   // Tuple.
-  else if (SchemaAST.isTupleType(node)) {
+  else if (AST.isTupleType(node)) {
     for (const [_, element] of node.elements.entries()) {
       const child = findNode(element.type, test);
       if (child) {
@@ -216,7 +211,7 @@ export const findNode = (node: SchemaAST.AST, test: (node: SchemaAST.AST) => boo
   }
 
   // Branching union (e.g., optional, discriminated unions).
-  else if (SchemaAST.isUnion(node)) {
+  else if (AST.isUnion(node)) {
     if (isOption(node)) {
       for (const type of node.types) {
         const child = findNode(type, test);
@@ -228,7 +223,7 @@ export const findNode = (node: SchemaAST.AST, test: (node: SchemaAST.AST) => boo
   }
 
   // Refinement.
-  else if (SchemaAST.isRefinement(node)) {
+  else if (AST.isRefinement(node)) {
     return findNode(node.from, test);
   }
 };
@@ -236,15 +231,12 @@ export const findNode = (node: SchemaAST.AST, test: (node: SchemaAST.AST) => boo
 /**
  * Get the AST node for the given property (dot-path).
  */
-export const findProperty = (
-  schema: Schema.Schema.AnyNoContext,
-  path: JsonPath | JsonProp,
-): SchemaAST.AST | undefined => {
-  const getProp = (node: SchemaAST.AST, path: JsonProp[]): SchemaAST.AST | undefined => {
+export const findProperty = (schema: S.Schema.AnyNoContext, path: JsonPath | JsonProp): AST.AST | undefined => {
+  const getProp = (node: AST.AST, path: JsonProp[]): AST.AST | undefined => {
     const [name, ...rest] = path;
-    const typeNode = findNode(node, SchemaAST.isTypeLiteral);
+    const typeNode = findNode(node, AST.isTypeLiteral);
     invariant(typeNode);
-    for (const prop of SchemaAST.getPropertySignatures(typeNode)) {
+    for (const prop of AST.getPropertySignatures(typeNode)) {
       if (prop.name === name) {
         if (rest.length) {
           return getProp(prop.type, rest);
@@ -262,11 +254,11 @@ export const findProperty = (
 // Annotations
 //
 
-const defaultAnnotations: Record<string, SchemaAST.Annotated> = {
-  ['ObjectKeyword' as const]: SchemaAST.objectKeyword,
-  ['StringKeyword' as const]: SchemaAST.stringKeyword,
-  ['NumberKeyword' as const]: SchemaAST.numberKeyword,
-  ['BooleanKeyword' as const]: SchemaAST.booleanKeyword,
+const defaultAnnotations: Record<string, AST.Annotated> = {
+  ['ObjectKeyword' as const]: AST.objectKeyword,
+  ['StringKeyword' as const]: AST.stringKeyword,
+  ['NumberKeyword' as const]: AST.numberKeyword,
+  ['BooleanKeyword' as const]: AST.booleanKeyword,
 };
 
 /**
@@ -276,10 +268,10 @@ const defaultAnnotations: Record<string, SchemaAST.Annotated> = {
  */
 export const getAnnotation =
   <T>(annotationId: symbol, noDefault = true) =>
-  (node: SchemaAST.AST): T | undefined => {
+  (node: AST.AST): T | undefined => {
     // Title fallback seems to be the identifier.
-    const id = pipe(SchemaAST.getIdentifierAnnotation(node), Option.getOrUndefined);
-    const value = pipe(SchemaAST.getAnnotation<T>(annotationId)(node), Option.getOrUndefined);
+    const id = pipe(AST.getIdentifierAnnotation(node), Option.getOrUndefined);
+    const value = pipe(AST.getAnnotation<T>(annotationId)(node), Option.getOrUndefined);
     if (noDefault && (value === defaultAnnotations[node._tag]?.annotations[annotationId] || value === id)) {
       return undefined;
     }
@@ -292,16 +284,16 @@ export const getAnnotation =
  * Optionally skips default annotations for basic types (e.g., 'a string').
  */
 // TODO(burdon): Convert to effect pattern (i.e., return operator like getAnnotation).
-export const findAnnotation = <T>(node: SchemaAST.AST, annotationId: symbol, noDefault = true): T | undefined => {
+export const findAnnotation = <T>(node: AST.AST, annotationId: symbol, noDefault = true): T | undefined => {
   const getAnnotationById = getAnnotation(annotationId, noDefault);
 
-  const getBaseAnnotation = (node: SchemaAST.AST): T | undefined => {
+  const getBaseAnnotation = (node: AST.AST): T | undefined => {
     const value = getAnnotationById(node);
     if (value !== undefined) {
       return value as T;
     }
 
-    if (SchemaAST.isUnion(node)) {
+    if (AST.isUnion(node)) {
       if (isOption(node)) {
         return getAnnotationById(node.types[0]) as T;
       }
@@ -316,40 +308,40 @@ export const findAnnotation = <T>(node: SchemaAST.AST, annotationId: symbol, noD
 //
 
 /**
- * Effect Schema.optional creates a union type with undefined as the second type.
+ * Effect S.optional creates a union type with undefined as the second type.
  */
-export const isOption = (node: SchemaAST.AST): boolean => {
-  return SchemaAST.isUnion(node) && node.types.length === 2 && SchemaAST.isUndefinedKeyword(node.types[1]);
+export const isOption = (node: AST.AST): boolean => {
+  return AST.isUnion(node) && node.types.length === 2 && AST.isUndefinedKeyword(node.types[1]);
 };
 
 /**
  * Determines if the node is a union of literal types.
  */
-export const isLiteralUnion = (node: SchemaAST.AST): boolean => {
-  return SchemaAST.isUnion(node) && node.types.every(SchemaAST.isLiteral);
+export const isLiteralUnion = (node: AST.AST): boolean => {
+  return AST.isUnion(node) && node.types.every(AST.isLiteral);
 };
 
 /**
  * Determines if the node is a discriminated union.
  */
-export const isDiscriminatedUnion = (node: SchemaAST.AST): boolean => {
-  return SchemaAST.isUnion(node) && !!getDiscriminatingProps(node)?.length;
+export const isDiscriminatedUnion = (node: AST.AST): boolean => {
+  return AST.isUnion(node) && !!getDiscriminatingProps(node)?.length;
 };
 
 /**
  * Get the discriminating properties for the given union type.
  */
-export const getDiscriminatingProps = (node: SchemaAST.AST): string[] | undefined => {
-  invariant(SchemaAST.isUnion(node));
+export const getDiscriminatingProps = (node: AST.AST): string[] | undefined => {
+  invariant(AST.isUnion(node));
   if (isOption(node)) {
     return;
   }
 
   // Get common literals across all types.
   return node.types.reduce<string[]>((shared, type) => {
-    const props = SchemaAST.getPropertySignatures(type)
+    const props = AST.getPropertySignatures(type)
       // TODO(burdon): Should check each literal is unique.
-      .filter((p) => SchemaAST.isLiteral(p.type))
+      .filter((p) => AST.isLiteral(p.type))
       .map((p) => p.name.toString());
 
     // Return common literals.
@@ -360,11 +352,8 @@ export const getDiscriminatingProps = (node: SchemaAST.AST): string[] | undefine
 /**
  * Get the discriminated type for the given value.
  */
-export const getDiscriminatedType = (
-  node: SchemaAST.AST,
-  value: Record<string, any> = {},
-): SchemaAST.AST | undefined => {
-  invariant(SchemaAST.isUnion(node));
+export const getDiscriminatedType = (node: AST.AST, value: Record<string, any> = {}): AST.AST | undefined => {
+  invariant(AST.isUnion(node));
   invariant(value);
   const props = getDiscriminatingProps(node);
   if (!props?.length) {
@@ -373,10 +362,10 @@ export const getDiscriminatedType = (
 
   // Match provided values.
   for (const type of node.types) {
-    const match = SchemaAST.getPropertySignatures(type)
+    const match = AST.getPropertySignatures(type)
       .filter((prop) => props?.includes(prop.name.toString()))
       .every((prop) => {
-        invariant(SchemaAST.isLiteral(prop.type));
+        invariant(AST.isLiteral(prop.type));
         return prop.type.literal === value[prop.name.toString()];
       });
 
@@ -393,36 +382,33 @@ export const getDiscriminatedType = (
       .map((prop) => {
         const literals = node.types
           .map((type) => {
-            const literal = SchemaAST.getPropertySignatures(type).find((p) => p.name.toString() === prop)!;
-            invariant(SchemaAST.isLiteral(literal.type));
+            const literal = AST.getPropertySignatures(type).find((p) => p.name.toString() === prop)!;
+            invariant(AST.isLiteral(literal.type));
             return literal.type.literal;
           })
           .filter(isNonNullable);
 
-        return literals.length ? [prop, Schema.Literal(...literals)] : undefined;
+        return literals.length ? [prop, S.Literal(...literals)] : undefined;
       })
       .filter(isNonNullable),
   );
 
-  const schema = Schema.Struct(fields);
+  const schema = S.Struct(fields);
   return schema.ast;
 };
 
 /**
  * Maps AST nodes.
- * The user is responsible for recursively calling {@link mapAst} on the SchemaAST.
+ * The user is responsible for recursively calling {@link mapAst} on the AST.
  * NOTE: Will evaluate suspended ASTs.
  */
-export const mapAst = (
-  ast: SchemaAST.AST,
-  f: (ast: SchemaAST.AST, key: keyof any | undefined) => SchemaAST.AST,
-): SchemaAST.AST => {
+export const mapAst = (ast: AST.AST, f: (ast: AST.AST, key: keyof any | undefined) => AST.AST): AST.AST => {
   switch (ast._tag) {
     case 'TypeLiteral': {
-      return new SchemaAST.TypeLiteral(
+      return new AST.TypeLiteral(
         ast.propertySignatures.map(
           (prop) =>
-            new SchemaAST.PropertySignature(
+            new AST.PropertySignature(
               prop.name,
               f(prop.type, prop.name),
               prop.isOptional,
@@ -434,19 +420,19 @@ export const mapAst = (
       );
     }
     case 'Union': {
-      return SchemaAST.Union.make(ast.types.map(f), ast.annotations);
+      return AST.Union.make(ast.types.map(f), ast.annotations);
     }
     case 'TupleType': {
-      return new SchemaAST.TupleType(
-        ast.elements.map((t, index) => new SchemaAST.OptionalType(f(t.type, index), t.isOptional, t.annotations)),
-        ast.rest.map((t) => new SchemaAST.Type(f(t.type, undefined), t.annotations)),
+      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.isReadonly,
         ast.annotations,
       );
     }
     case 'Suspend': {
       const newAst = f(ast.f(), undefined);
-      return new SchemaAST.Suspend(() => newAst, ast.annotations);
+      return new AST.Suspend(() => newAst, ast.annotations);
     }
     default: {
       // TODO(dmaretskyi): Support more nodes.

package/src/jsonPath.ts

@@ -2,7 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema, Option } from 'effect';
+import { Schema as S } from 'effect';
+import { isSome } from 'effect/Option';
 import { JSONPath } from 'jsonpath-plus';
 
 import { invariant } from '@dxos/invariant';
@@ -16,14 +17,14 @@ const PROP_REGEX = /\w+/;
 /**
  * https://www.ietf.org/archive/id/draft-goessner-dispatch-jsonpath-00.html
  */
-export const JsonPath = Schema.String.pipe(Schema.pattern(PATH_REGEX)).annotations({
+export const JsonPath = S.String.pipe(S.pattern(PATH_REGEX)).annotations({
   title: 'JSON path',
   description: 'JSON path to a property',
-}) as any as Schema.Schema<JsonPath>;
-export const JsonProp = Schema.NonEmptyString.pipe(Schema.pattern(PROP_REGEX)) as any as Schema.Schema<JsonProp>;
+}) 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 Option.isSome(Schema.validateOption(JsonPath)(value));
+  return isSome(S.validateOption(JsonPath)(value));
 };
 
 /**

package/src/url.test.ts

@@ -2,18 +2,18 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
+import { Schema as S } from 'effect';
 import { describe, expect, test } from 'vitest';
 
 import { ParamKeyAnnotation, UrlParser } from './url';
 
-const Invitation = Schema.Struct({
-  accessToken: Schema.String,
-  deviceInvitationCode: Schema.String.pipe(ParamKeyAnnotation({ key: 'deviceInvitationCode' })),
-  spaceInvitationCode: Schema.String,
-  experimental: Schema.Boolean,
-  testing: Schema.Boolean,
-  timeout: Schema.Number,
+const Invitation = S.Struct({
+  accessToken: S.String,
+  deviceInvitationCode: S.String.pipe(ParamKeyAnnotation({ key: 'deviceInvitationCode' })),
+  spaceInvitationCode: S.String,
+  experimental: S.Boolean,
+  testing: S.Boolean,
+  timeout: S.Number,
 });
 
 describe('Params', () => {

package/src/url.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { SchemaAST, type Schema, Option, pipe } from 'effect';
+import { SchemaAST as AST, type Schema as S, Option, pipe } from 'effect';
 
 import { decamelize } from '@dxos/util';
 
@@ -10,12 +10,12 @@ const ParamKeyAnnotationId = Symbol.for('@dxos/schema/annotation/ParamKey');
 
 type ParamKeyAnnotationValue = { key: string };
 
-export const getParamKeyAnnotation: (annotated: SchemaAST.Annotated) => Option.Option<ParamKeyAnnotationValue> =
-  SchemaAST.getAnnotation<ParamKeyAnnotationValue>(ParamKeyAnnotationId);
+export const getParamKeyAnnotation: (annotated: AST.Annotated) => Option.Option<ParamKeyAnnotationValue> =
+  AST.getAnnotation<ParamKeyAnnotationValue>(ParamKeyAnnotationId);
 
 export const ParamKeyAnnotation =
   (value: ParamKeyAnnotationValue) =>
-  <S extends Schema.Annotable.All>(self: S): Schema.Annotable.Self<S> =>
+  <S extends S.Annotable.All>(self: S): S.Annotable.Self<S> =>
     self.annotations({ [ParamKeyAnnotationId]: value });
 
 /**
@@ -23,7 +23,7 @@ export const ParamKeyAnnotation =
  * Supports custom key serialization.
  */
 export class UrlParser<T extends Record<string, any>> {
-  constructor(private readonly _schema: Schema.Struct<T>) {}
+  constructor(private readonly _schema: S.Struct<T>) {}
 
   /**
    * Parse URL params.
@@ -37,9 +37,9 @@ export class UrlParser<T extends Record<string, any>> {
       }
 
       if (value != null) {
-        if (SchemaAST.isNumberKeyword(type.ast)) {
+        if (AST.isNumberKeyword(type.ast)) {
           params[key] = parseInt(value);
-        } else if (SchemaAST.isBooleanKeyword(type.ast)) {
+        } else if (AST.isBooleanKeyword(type.ast)) {
           params[key] = value === 'true' || value === '1';
         } else {
           params[key] = value;