@dxos/effect 0.7.0 → 0.7.1-staging.7f6f91c

package/src/ast.test.ts

@@ -12,7 +12,10 @@ import {
   findNode,
   findProperty,
   getAnnotation,
+  getDiscriminatingProps,
+  getDiscriminatedType,
   getSimpleType,
+  isOption,
   isSimpleType,
   visit,
   type JsonPath,
@@ -89,20 +92,39 @@ describe('AST', () => {
   });
 
   test('findAnnotation', ({ expect }) => {
-    const Type = S.NonEmptyString.pipe(S.pattern(/^\d{5}$/)).annotations({
+    const TestSchema = S.NonEmptyString.pipe(S.pattern(/^\d{5}$/)).annotations({
       [AST.TitleAnnotationId]: 'original title',
     });
-    const Contact = S.Struct({
-      p1: Type.annotations({ [AST.TitleAnnotationId]: 'new title' }),
-      p2: Type.annotations({ [AST.TitleAnnotationId]: 'new title' }).pipe(S.optional),
-      p3: S.optional(Type.annotations({ [AST.TitleAnnotationId]: 'new title' })),
+
+    const ContactSchema = S.Struct({
+      p1: TestSchema.annotations({ [AST.TitleAnnotationId]: 'new title' }),
+      p2: TestSchema.annotations({ [AST.TitleAnnotationId]: 'new title' }).pipe(S.optional),
+      p3: S.optional(TestSchema.annotations({ [AST.TitleAnnotationId]: 'new title' })),
     });
 
-    {
-      const prop = findProperty(Contact, 'p3' as JsonPath);
+    for (const p of ['p1', 'p2', 'p3']) {
+      const prop = findProperty(ContactSchema, p as JsonPath);
       invariant(prop);
       const value = findAnnotation(prop, AST.TitleAnnotationId);
-      expect(value).to.eq('new title');
+      expect(value, `invalid title for ${p}`).to.eq('new title');
+    }
+  });
+
+  test('findAnnotation skips defaults', ({ expect }) => {
+    const annotation = findAnnotation(
+      S.String.annotations({ [AST.TitleAnnotationId]: 'test' }).ast,
+      AST.TitleAnnotationId,
+      { noDefault: true },
+    );
+    expect(annotation).to.eq('test');
+
+    const annotationIds = [AST.TitleAnnotationId, AST.DescriptionAnnotationId];
+    const schemas = [S.Object, S.String, S.Number, S.Boolean];
+    for (const schema of schemas) {
+      for (const annotationId of annotationIds) {
+        const annotation = findAnnotation(schema.ast, annotationId, { noDefault: true });
+        expect(annotation, schema.ast._tag).to.eq(undefined);
+      }
     }
   });
 
@@ -119,6 +141,46 @@ describe('AST', () => {
 
     const props: string[] = [];
     visit(TestSchema.ast, (_, path) => props.push(path.join('.')));
-    console.log(JSON.stringify(props, null, 2));
+  });
+
+  test('discriminated unions', ({ expect }) => {
+    const TestUnionSchema = S.Union(
+      S.Struct({ kind: S.Literal('a'), label: S.String }),
+      S.Struct({ kind: S.Literal('b'), count: S.Number, active: S.Boolean }),
+    );
+
+    type TestUnionType = S.Schema.Type<typeof TestUnionSchema>;
+
+    {
+      expect(isOption(TestUnionSchema.ast)).to.be.false;
+      expect(getDiscriminatingProps(TestUnionSchema.ast)).to.deep.eq(['kind']);
+
+      const node = findNode(TestUnionSchema.ast, isSimpleType);
+      expect(node).to.eq(TestUnionSchema.ast);
+    }
+
+    {
+      invariant(AST.isUnion(TestUnionSchema.ast));
+      const [a, b] = TestUnionSchema.ast.types;
+
+      const obj1: TestUnionType = {
+        kind: 'a',
+        label: 'test',
+      };
+
+      const obj2: TestUnionType = {
+        kind: 'b',
+        count: 100,
+        active: true,
+      };
+
+      expect(getDiscriminatedType(TestUnionSchema.ast, obj1)?.toJSON()).to.deep.eq(a.toJSON());
+      expect(getDiscriminatedType(TestUnionSchema.ast, obj2)?.toJSON()).to.deep.eq(b.toJSON());
+      expect(getDiscriminatedType(TestUnionSchema.ast)?.toJSON()).to.deep.eq(
+        S.Struct({
+          kind: S.Literal('a', 'b'),
+        }).ast.toJSON(),
+      );
+    }
   });
 });

package/src/ast.ts

@@ -6,20 +6,25 @@ import { AST, Schema as S } from '@effect/schema';
 import { Option, pipe } from 'effect';
 
 import { invariant } from '@dxos/invariant';
+import { nonNullable } from '@dxos/util';
 
 //
 // Refs
-// https://effect.website/docs/guides/schema
+// https://effect.website/docs/schema/introduction
 // https://www.npmjs.com/package/@effect/schema
 // https://effect-ts.github.io/effect/schema/AST.ts.html
 //
 
 export type SimpleType = 'object' | 'string' | 'number' | 'boolean' | 'enum' | 'literal';
 
+/**
+ * Get the base type; e.g., traverse through refinements.
+ */
 export const getSimpleType = (node: AST.AST): SimpleType | undefined => {
-  if (AST.isObjectKeyword(node)) {
+  if (AST.isObjectKeyword(node) || AST.isTypeLiteral(node) || isDiscriminatedUnion(node)) {
     return 'object';
   }
+
   if (AST.isStringKeyword(node)) {
     return 'string';
   }
@@ -29,15 +34,17 @@ export const getSimpleType = (node: AST.AST): SimpleType | undefined => {
   if (AST.isBooleanKeyword(node)) {
     return 'boolean';
   }
+
   if (AST.isEnums(node)) {
     return 'enum';
   }
+
   if (AST.isLiteral(node)) {
     return 'literal';
   }
 };
 
-export const isSimpleType = (node: AST.AST) => !!getSimpleType(node);
+export const isSimpleType = (node: AST.AST): boolean => !!getSimpleType(node);
 
 //
 // Branded types
@@ -136,7 +143,7 @@ const visitNode = (
     }
   }
 
-  // Branching union.
+  // Branching union (e.g., optional, discriminated unions).
   else if (AST.isUnion(node)) {
     for (const type of node.types) {
       const result = visitNode(type, test, visitor, path, depth);
@@ -154,13 +161,13 @@ const visitNode = (
     }
   }
 
-  // TODO(burdon): Transform?
+  // TODO(burdon): Transforms?
 };
 
 /**
  * Recursively descend into AST to find first node that passes the test.
  */
-// TODO(burdon): Reuse visitor.
+// TODO(burdon): Rewrite using visitNode?
 export const findNode = (node: AST.AST, test: (node: AST.AST) => boolean): AST.AST | undefined => {
   if (test(node)) {
     return node;
@@ -176,7 +183,7 @@ export const findNode = (node: AST.AST, test: (node: AST.AST) => boolean): AST.A
     }
   }
 
-  // Array.
+  // Tuple.
   else if (AST.isTupleType(node)) {
     for (const [_, element] of node.elements.entries()) {
       const child = findNode(element.type, test);
@@ -186,12 +193,14 @@ export const findNode = (node: AST.AST, test: (node: AST.AST) => boolean): AST.A
     }
   }
 
-  // Branching union.
+  // Branching union (e.g., optional, discriminated unions).
   else if (AST.isUnion(node)) {
-    for (const type of node.types) {
-      const child = findNode(type, test);
-      if (child) {
-        return child;
+    if (isOption(node)) {
+      for (const type of node.types) {
+        const child = findNode(type, test);
+        if (child) {
+          return child;
+        }
       }
     }
   }
@@ -200,8 +209,6 @@ export const findNode = (node: AST.AST, test: (node: AST.AST) => boolean): AST.A
   else if (AST.isRefinement(node)) {
     return findNode(node.from, test);
   }
-
-  return undefined;
 };
 
 /**
@@ -221,33 +228,143 @@ export const findProperty = (schema: S.Schema<any>, path: JsonPath | JsonProp):
         }
       }
     }
-
-    return undefined;
   };
 
   return getProp(schema.ast, path.split('.') as JsonProp[]);
 };
 
+//
+// Annotations
+//
+
+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,
+};
+
 /**
- * Recursively descend into AST to find first matching annotations
+ * Recursively descend into AST to find first matching annotations.
+ * Optionally skips default annotations for basic types (e.g., 'a string').
  */
-export const findAnnotation = <T>(node: AST.AST, annotationId: symbol): T | undefined => {
+export const findAnnotation = <T>(
+  node: AST.AST,
+  annotationId: symbol,
+  options?: { noDefault: boolean },
+): T | undefined => {
   const getAnnotationById = getAnnotation(annotationId);
+
   const getBaseAnnotation = (node: AST.AST): T | undefined => {
     const value = getAnnotationById(node);
     if (value !== undefined) {
+      if (options?.noDefault && value === defaultAnnotations[node._tag]?.annotations[annotationId]) {
+        return undefined;
+      }
+
       return value as T;
     }
 
     if (AST.isUnion(node)) {
-      for (const type of node.types) {
-        const value = getBaseAnnotation(type);
-        if (value !== undefined) {
-          return value as T;
-        }
+      if (isOption(node)) {
+        return getAnnotationById(node.types[0]) as T;
       }
     }
   };
 
   return getBaseAnnotation(node);
 };
+
+//
+// Unions
+//
+
+/**
+ * Effect S.optional creates a union type with undefined as the second type.
+ */
+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: AST.AST): boolean => {
+  return AST.isUnion(node) && node.types.every(AST.isLiteral);
+};
+
+/**
+ * Determines if the node is a discriminated union.
+ */
+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: 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 = AST.getPropertySignatures(type)
+      // TODO(burdon): Should check each literal is unique.
+      .filter((p) => AST.isLiteral(p.type))
+      .map((p) => p.name.toString());
+
+    // Return common literals.
+    return shared.length === 0 ? props : shared.filter((prop) => props.includes(prop));
+  }, []);
+};
+
+/**
+ * Get the discriminated type for the given value.
+ */
+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) {
+    return;
+  }
+
+  // Match provided values.
+  for (const type of node.types) {
+    const match = AST.getPropertySignatures(type)
+      .filter((prop) => props?.includes(prop.name.toString()))
+      .every((prop) => {
+        invariant(AST.isLiteral(prop.type));
+        return prop.type.literal === value[prop.name.toString()];
+      });
+
+    if (match) {
+      return type;
+    }
+  }
+
+  // Create union of discriminating properties.
+  // NOTE: This may not work with non-overlapping variants.
+  // TODO(burdon): Iterate through props and knock-out variants that don't match.
+  const fields = Object.fromEntries(
+    props
+      .map((prop) => {
+        const literals = node.types
+          .map((type) => {
+            const literal = AST.getPropertySignatures(type).find((p) => p.name.toString() === prop)!;
+            invariant(AST.isLiteral(literal.type));
+            return literal.type.literal;
+          })
+          .filter(nonNullable);
+
+        return literals.length ? [prop, S.Literal(...literals)] : undefined;
+      })
+      .filter(nonNullable),
+  );
+
+  const schema = S.Struct(fields);
+  return schema.ast;
+};