@graphprotocol/hypergraph 0.0.1

package/src/entity/variant-schema.ts

@@ -0,0 +1,677 @@
+/**
+ * @since 1.0.0
+ */
+import type { Brand } from 'effect/Brand';
+import type * as Effect from 'effect/Effect';
+import { constUndefined, dual } from 'effect/Function';
+import * as Option from 'effect/Option';
+import * as ParseResult from 'effect/ParseResult';
+import { type Pipeable, pipeArguments } from 'effect/Pipeable';
+import * as Predicate from 'effect/Predicate';
+import * as Schema from 'effect/Schema';
+import type * as AST from 'effect/SchemaAST';
+import * as Struct_ from 'effect/Struct';
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const TypeId: unique symbol = Symbol.for('@effect/experimental/VariantSchema');
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type TypeId = typeof TypeId;
+
+const cacheSymbol = Symbol.for('@effect/experimental/VariantSchema/cache');
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface Struct<in out A extends Field.Fields> extends Pipeable {
+  readonly [TypeId]: A;
+  /** @internal */
+  [cacheSymbol]?: Record<string, Schema.Schema.All>;
+}
+
+/**
+ * @since 1.0.0
+ * @category guards
+ */
+export const isStruct = (u: unknown): u is Struct<any> => Predicate.hasProperty(u, TypeId);
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export declare namespace Struct {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Any = { readonly [TypeId]: any };
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Fields = {
+    readonly [key: string]: Schema.Schema.All | Schema.PropertySignature.All | Field<any> | Struct<any> | undefined;
+  };
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Validate<A, Variant extends string> = {
+    readonly [K in keyof A]: A[K] extends { readonly [TypeId]: infer _ }
+      ? Validate<A[K], Variant>
+      : A[K] extends Field<infer Config>
+        ? [keyof Config] extends [Variant]
+          ? {}
+          : 'field must have valid variants'
+        : {};
+  };
+}
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const FieldTypeId: unique symbol = Symbol.for('@effect/experimental/VariantSchema/Field');
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type FieldTypeId = typeof FieldTypeId;
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface Field<in out A extends Field.Config> extends Pipeable {
+  readonly [FieldTypeId]: FieldTypeId;
+  readonly schemas: A;
+}
+
+/**
+ * @since 1.0.0
+ * @category guards
+ */
+export const isField = (u: unknown): u is Field<any> => Predicate.hasProperty(u, FieldTypeId);
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export declare namespace Field {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Any = { readonly [FieldTypeId]: FieldTypeId };
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  type ValueAny = Schema.Schema.All | Schema.PropertySignature.All;
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Config = {
+    readonly [key: string]: Schema.Schema.All | Schema.PropertySignature.All | undefined;
+  };
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type ConfigWithKeys<K extends string> = {
+    readonly [P in K]?: Schema.Schema.All | Schema.PropertySignature.All;
+  };
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Fields = {
+    readonly [key: string]: Schema.Schema.All | Schema.PropertySignature.All | Field<any> | Struct<any> | undefined;
+  };
+}
+
+/**
+ * @since 1.0.0
+ * @category extractors
+ */
+export type ExtractFields<V extends string, Fields extends Struct.Fields, IsDefault = false> = {
+  readonly [K in keyof Fields as [Fields[K]] extends [Field<infer Config>]
+    ? V extends keyof Config
+      ? K
+      : never
+    : K]: [Fields[K]] extends [Struct<infer _>]
+    ? Extract<V, Fields[K], IsDefault>
+    : [Fields[K]] extends [Field<infer Config>]
+      ? [Config[V]] extends [Schema.Schema.All | Schema.PropertySignature.All]
+        ? Config[V]
+        : never
+      : [Fields[K]] extends [Schema.Schema.All | Schema.PropertySignature.All]
+        ? Fields[K]
+        : never;
+};
+
+/**
+ * @since 1.0.0
+ * @category extractors
+ */
+export type Extract<V extends string, A extends Struct<any>, IsDefault = false> = [A] extends [Struct<infer Fields>]
+  ? IsDefault extends true
+    ? [A] extends [Schema.Schema.Any]
+      ? A
+      : Schema.Struct<Schema.Simplify<ExtractFields<V, Fields>>>
+    : Schema.Struct<Schema.Simplify<ExtractFields<V, Fields>>>
+  : never;
+
+const extract: {
+  <V extends string, const IsDefault extends boolean = false>(
+    variant: V,
+    options?: {
+      readonly isDefault?: IsDefault | undefined;
+    },
+  ): <A extends Struct<any>>(self: A) => Extract<V, A, IsDefault>;
+  <V extends string, A extends Struct<any>, const IsDefault extends boolean = false>(
+    self: A,
+    variant: V,
+    options?: {
+      readonly isDefault?: IsDefault | undefined;
+    },
+  ): Extract<V, A, IsDefault>;
+} = dual(
+  (args) => isStruct(args[0]),
+  <V extends string, A extends Struct<any>>(
+    self: A,
+    variant: V,
+    options?: {
+      readonly isDefault?: boolean | undefined;
+    },
+  ): Extract<V, A> => {
+    const cache = self[cacheSymbol] ?? (self[cacheSymbol] = {});
+    const cacheKey = options?.isDefault === true ? '__default' : variant;
+    if (cache[cacheKey] !== undefined) {
+      return cache[cacheKey] as any;
+    }
+    const fields: Record<string, any> = {};
+    for (const key of Object.keys(self[TypeId])) {
+      const value = self[TypeId][key];
+      if (TypeId in value) {
+        if (options?.isDefault === true && Schema.isSchema(value)) {
+          fields[key] = value;
+        } else {
+          fields[key] = extract(value, variant);
+        }
+      } else if (FieldTypeId in value) {
+        if (variant in value.schemas) {
+          fields[key] = value.schemas[variant];
+        }
+      } else {
+        fields[key] = value;
+      }
+    }
+    return (cache[cacheKey] = Schema.Struct(fields) as any);
+  },
+);
+
+/**
+ * @category accessors
+ * @since 1.0.0
+ */
+export const fields = <A extends Struct<any>>(self: A): A[TypeId] => self[TypeId];
+
+type RequiredKeys<T> = {
+  [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
+}[keyof T];
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface Class<Self, Fields extends Struct.Fields, SchemaFields extends Schema.Struct.Fields, A, I, R, C>
+  extends Schema.Schema<Self, Schema.Simplify<I>, R>,
+    Struct<Fields> {
+  new (
+    props: RequiredKeys<C> extends never ? void | Schema.Simplify<C> : Schema.Simplify<C>,
+    options?: {
+      readonly disableValidation?: boolean;
+    },
+  ): A;
+
+  readonly ast: AST.Transformation;
+
+  make<Args extends Array<any>, X>(this: { new (...args: Args): X }, ...args: Args): X;
+
+  annotations(annotations: Schema.Annotations.Schema<Self>): Schema.SchemaClass<Self, Schema.Simplify<I>, R>;
+
+  readonly identifier: string;
+  readonly fields: SchemaFields;
+}
+
+type ClassFromFields<Self, Fields extends Struct.Fields, SchemaFields extends Schema.Struct.Fields> = Class<
+  Self,
+  Fields,
+  SchemaFields,
+  Schema.Struct.Type<SchemaFields>,
+  Schema.Struct.Encoded<SchemaFields>,
+  Schema.Struct.Context<SchemaFields>,
+  Schema.Struct.Constructor<SchemaFields>
+>;
+
+type MissingSelfGeneric<Params extends string = ''> =
+  `Missing \`Self\` generic - use \`class Self extends Class<Self>()(${Params}{ ... })\``;
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface Union<Members extends ReadonlyArray<Struct<any>>>
+  extends Schema.Union<{
+    readonly [K in keyof Members]: [Members[K]] extends [Schema.Schema.All] ? Members[K] : never;
+  }> {}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export declare namespace Union {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Variants<Members extends ReadonlyArray<Struct<any>>, Variants extends string> = {
+    readonly [Variant in Variants]: Schema.Union<{
+      [K in keyof Members]: Extract<Variant, Members[K]>;
+    }>;
+  };
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface fromKey<S extends Schema.Schema.All, Key extends string>
+  extends Schema.PropertySignature<
+    ':',
+    Schema.Schema.Type<S>,
+    Key,
+    ':',
+    Schema.Schema.Encoded<S>,
+    false,
+    Schema.Schema.Context<S>
+  > {}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export declare namespace fromKey {
+  /**
+   * @since 1.0.0
+   */
+  export type Rename<S, Key extends string> = S extends Schema.PropertySignature<
+    infer _TypeToken,
+    infer _Type,
+    infer _Key,
+    infer _EncodedToken,
+    infer _Encoded,
+    infer _HasDefault,
+    infer _R
+  >
+    ? Schema.PropertySignature<_TypeToken, _Type, Key, _EncodedToken, _Encoded, _HasDefault, _R>
+    : S extends Schema.Schema.All
+      ? fromKey<S, Key>
+      : never;
+}
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const make = <const Variants extends ReadonlyArray<string>, const Default extends Variants[number]>(options: {
+  readonly variants: Variants;
+  readonly defaultVariant: Default;
+}): {
+  readonly Struct: <const A extends Struct.Fields>(fields: A & Struct.Validate<A, Variants[number]>) => Struct<A>;
+  readonly Field: <const A extends Field.ConfigWithKeys<Variants[number]>>(
+    config: A & { readonly [K in Exclude<keyof A, Variants[number]>]: never },
+  ) => Field<A>;
+  readonly FieldOnly: <const Keys extends ReadonlyArray<Variants[number]>>(
+    ...keys: Keys
+  ) => <S extends Schema.Schema.All | Schema.PropertySignature.All>(
+    schema: S,
+  ) => Field<{ readonly [K in Keys[number]]: S }>;
+  readonly FieldExcept: <const Keys extends ReadonlyArray<Variants[number]>>(
+    ...keys: Keys
+  ) => <S extends Schema.Schema.All | Schema.PropertySignature.All>(
+    schema: S,
+  ) => Field<{ readonly [K in Exclude<Variants[number], Keys[number]>]: S }>;
+  readonly fieldEvolve: {
+    <
+      Self extends Field<any> | Field.ValueAny,
+      const Mapping extends Self extends Field<infer S>
+        ? { readonly [K in keyof S]?: (variant: S[K]) => Field.ValueAny }
+        : { readonly [K in Variants[number]]?: (variant: Self) => Field.ValueAny },
+    >(
+      f: Mapping,
+    ): (self: Self) => Field<
+      Self extends Field<infer S>
+        ? {
+            readonly [K in keyof S]: K extends keyof Mapping
+              ? Mapping[K] extends (arg: any) => any
+                ? ReturnType<Mapping[K]>
+                : S[K]
+              : S[K];
+          }
+        : {
+            readonly [K in Variants[number]]: K extends keyof Mapping
+              ? Mapping[K] extends (arg: any) => any
+                ? ReturnType<Mapping[K]>
+                : Self
+              : Self;
+          }
+    >;
+    <
+      Self extends Field<any> | Field.ValueAny,
+      const Mapping extends Self extends Field<infer S>
+        ? {
+            readonly [K in keyof S]?: (variant: S[K]) => Field.ValueAny;
+          }
+        : { readonly [K in Variants[number]]?: (variant: Self) => Field.ValueAny },
+    >(
+      self: Self,
+      f: Mapping,
+    ): Field<
+      Self extends Field<infer S>
+        ? {
+            readonly [K in keyof S]: K extends keyof Mapping
+              ? Mapping[K] extends (arg: any) => any
+                ? ReturnType<Mapping[K]>
+                : S[K]
+              : S[K];
+          }
+        : {
+            readonly [K in Variants[number]]: K extends keyof Mapping
+              ? Mapping[K] extends (arg: any) => any
+                ? ReturnType<Mapping[K]>
+                : Self
+              : Self;
+          }
+    >;
+  };
+  readonly fieldFromKey: {
+    <
+      Self extends Field<any> | Field.ValueAny,
+      const Mapping extends Self extends Field<infer S>
+        ? { readonly [K in keyof S]?: string }
+        : { readonly [K in Variants[number]]?: string },
+    >(
+      mapping: Mapping,
+    ): (self: Self) => Field<
+      Self extends Field<infer S>
+        ? {
+            readonly [K in keyof S]: K extends keyof Mapping
+              ? Mapping[K] extends string
+                ? fromKey.Rename<S[K], Mapping[K]>
+                : S[K]
+              : S[K];
+          }
+        : {
+            readonly [K in Variants[number]]: K extends keyof Mapping
+              ? Mapping[K] extends string
+                ? fromKey.Rename<Self, Mapping[K]>
+                : Self
+              : Self;
+          }
+    >;
+    <
+      Self extends Field<any> | Field.ValueAny,
+      const Mapping extends Self extends Field<infer S>
+        ? { readonly [K in keyof S]?: string }
+        : { readonly [K in Variants[number]]?: string },
+    >(
+      self: Self,
+      mapping: Mapping,
+    ): Field<
+      Self extends Field<infer S>
+        ? {
+            readonly [K in keyof S]: K extends keyof Mapping
+              ? Mapping[K] extends string
+                ? fromKey.Rename<S[K], Mapping[K]>
+                : S[K]
+              : S[K];
+          }
+        : {
+            readonly [K in Variants[number]]: K extends keyof Mapping
+              ? Mapping[K] extends string
+                ? fromKey.Rename<Self, Mapping[K]>
+                : Self
+              : Self;
+          }
+    >;
+  };
+  readonly Class: <Self = never>(
+    identifier: string,
+  ) => <const Fields extends Struct.Fields>(
+    fields: Fields & Struct.Validate<Fields, Variants[number]>,
+    annotations?: Schema.Annotations.Schema<Self>,
+  ) => [Self] extends [never]
+    ? MissingSelfGeneric
+    : ClassFromFields<Self, Fields, Schema.Simplify<ExtractFields<Default, Fields, true>>> & {
+        readonly [V in Variants[number]]: Extract<V, Struct<Fields>>;
+      };
+  readonly Union: <const Members extends ReadonlyArray<Struct<any>>>(
+    ...members: Members
+  ) => Union<Members> & Union.Variants<Members, Variants[number]>;
+  readonly extract: {
+    <V extends Variants[number]>(
+      variant: V,
+    ): <A extends Struct<any>>(self: A) => Extract<V, A, V extends Default ? true : false>;
+    <V extends Variants[number], A extends Struct<any>>(
+      self: A,
+      variant: V,
+    ): Extract<V, A, V extends Default ? true : false>;
+  };
+} => {
+  function Class<Self>(identifier: string) {
+    return (fields: Struct.Fields, annotations?: Schema.Annotations.Schema<Self>) => {
+      const idField = Field({
+        select: Schema.String,
+      });
+      const deletedField = Field({
+        select: Schema.Boolean,
+      });
+      const versionField = Field({
+        select: Schema.String,
+      });
+      const relationField = Field({
+        select: Schema.optional(
+          Schema.Struct({
+            id: Schema.String,
+          }),
+        ),
+      });
+
+      const extractFields: Struct.Fields = {
+        ...fields,
+        id: idField,
+        __deleted: deletedField,
+        __version: versionField,
+        _relation: relationField,
+      };
+      const variantStruct = Struct(extractFields);
+      const schema = extract(variantStruct, options.defaultVariant, {
+        isDefault: true,
+      });
+      class Base extends Schema.Class<any>(identifier)(schema.fields, annotations) {
+        static [TypeId] = extractFields;
+      }
+      for (const variant of options.variants) {
+        Object.defineProperty(Base, variant, {
+          value: extract(variantStruct, variant).annotations({
+            identifier: `${identifier}.${variant}`,
+            title: `${identifier}.${variant}`,
+          }),
+        });
+      }
+      return Base;
+    };
+  }
+  function FieldOnly<Keys extends Variants>(...keys: Keys) {
+    return <S extends Schema.Schema.All | Schema.PropertySignature.All>(schema: S) => {
+      const obj: Record<string, S> = {};
+      for (const key of keys) {
+        obj[key] = schema;
+      }
+      return Field(obj);
+    };
+  }
+  function FieldExcept<Keys extends Variants>(...keys: Keys) {
+    return <S extends Schema.Schema.All | Schema.PropertySignature.All>(schema: S) => {
+      const obj: Record<string, S> = {};
+      for (const variant of options.variants) {
+        if (!keys.includes(variant)) {
+          obj[variant] = schema;
+        }
+      }
+      return Field(obj);
+    };
+  }
+  function UnionVariants(...members: ReadonlyArray<Struct<any>>) {
+    return Union(members, options.variants);
+  }
+  const fieldEvolve = dual(
+    2,
+    (
+      self: Field<any> | Schema.Schema.All | Schema.PropertySignature.All,
+      f: Record<string, (schema: Field.ValueAny) => Field.ValueAny>,
+    ): Field<any> => {
+      const field = isField(self)
+        ? self
+        : Field(Object.fromEntries(options.variants.map((variant) => [variant, self])));
+      return Field(Struct_.evolve(field.schemas, f));
+    },
+  );
+  const fieldFromKey = dual(
+    2,
+    (
+      self:
+        | Field<{
+            readonly [key: string]: Schema.Schema.All | Schema.PropertySignature.Any | undefined;
+          }>
+        | Schema.Schema.All
+        | Schema.PropertySignature.Any,
+      mapping: Record<string, string>,
+    ): Field<any> => {
+      const obj: Record<string, any> = {};
+      if (isField(self)) {
+        for (const [key, schema] of Object.entries(self.schemas)) {
+          obj[key] = mapping[key] !== undefined ? renameFieldValue(schema as any, mapping[key]) : schema;
+        }
+      } else {
+        for (const key of options.variants) {
+          obj[key] = mapping[key] !== undefined ? renameFieldValue(self as any, mapping[key]) : self;
+        }
+      }
+      return Field(obj);
+    },
+  );
+  const extractVariants = dual(2, (self: Struct<any>, variant: string): any =>
+    extract(self, variant, {
+      isDefault: variant === options.defaultVariant,
+    }),
+  );
+  return {
+    Struct,
+    Field,
+    FieldOnly,
+    FieldExcept,
+    Class,
+    Union: UnionVariants,
+    fieldEvolve,
+    fieldFromKey,
+    extract: extractVariants,
+  } as any;
+};
+
+/**
+ * @since 1.0.0
+ * @category overrideable
+ */
+export const Override = <A>(value: A): A & Brand<'Override'> => value as any;
+
+/**
+ * @since 1.0.0
+ * @category overrideable
+ */
+export interface Overrideable<To, From, R = never>
+  extends Schema.PropertySignature<':', (To & Brand<'Override'>) | undefined, never, ':', From, true, R> {}
+
+/**
+ * @since 1.0.0
+ * @category overrideable
+ */
+export const Overrideable = <From, IFrom, RFrom, To, ITo, R>(
+  from: Schema.Schema<From, IFrom, RFrom>,
+  to: Schema.Schema<To, ITo>,
+  options: {
+    readonly generate: (_: Option.Option<ITo>) => Effect.Effect<From, ParseResult.ParseIssue, R>;
+  },
+): Overrideable<To, IFrom, RFrom | R> =>
+  Schema.transformOrFail(from, Schema.Union(Schema.Undefined, to.pipe(Schema.brand('Override'))), {
+    decode: (_) => ParseResult.succeed(undefined),
+    encode: (dt) => options.generate(dt === undefined ? Option.none() : Option.some(dt)),
+  }).pipe(Schema.propertySignature, Schema.withConstructorDefault(constUndefined));
+
+const StructProto = {
+  pipe() {
+    return pipeArguments(this, arguments);
+  },
+};
+
+const Struct = <const A extends Field.Fields>(fields: A): Struct<A> => {
+  const self = Object.create(StructProto);
+  self[TypeId] = fields;
+  return self;
+};
+
+const FieldProto = {
+  [FieldTypeId]: FieldTypeId,
+  pipe() {
+    return pipeArguments(this, arguments);
+  },
+};
+
+const Field = <const A extends Field.Config>(schemas: A): Field<A> => {
+  const self = Object.create(FieldProto);
+  self.schemas = schemas;
+  return self;
+};
+
+const Union = <Members extends ReadonlyArray<Struct<any>>, Variants extends ReadonlyArray<string>>(
+  members: Members,
+  variants: Variants,
+) => {
+  class VariantUnion extends (Schema.Union(...members.filter((member) => Schema.isSchema(member))) as any) {}
+  for (const variant of variants) {
+    Object.defineProperty(VariantUnion, variant, {
+      value: Schema.Union(...members.map((member) => extract(member, variant))),
+    });
+  }
+  return VariantUnion;
+};
+
+const renameFieldValue = <F extends Schema.Schema.All | Schema.PropertySignature.Any>(self: F, key: string) =>
+  Schema.isPropertySignature(self) ? Schema.fromKey(self, key) : Schema.fromKey(Schema.propertySignature(self), key);